# File lib/ruby_indexer/test/constant_test.rb, line 209deftest_aliasing_namespacesindex(<<~RUBY)
module A
module B
module C
end
end
ALIAS = B
end
module Other
ONE_MORE = A::ALIAS
end
RUBYunresolve_entry = @index["A::ALIAS"].firstassert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
assert_equal(["A"], unresolve_entry.nesting)
assert_equal("B", unresolve_entry.target)
resolved_entry = @index.resolve("ALIAS", ["A"]).firstassert_instance_of(Entry::Alias, resolved_entry)
assert_equal("A::B", resolved_entry.target)
resolved_entry = @index.resolve("ALIAS::C", ["A"]).firstassert_instance_of(Entry::Module, resolved_entry)
assert_equal("A::B::C", resolved_entry.name)
unresolve_entry = @index["Other::ONE_MORE"].firstassert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
assert_equal(["Other"], unresolve_entry.nesting)
assert_equal("A::ALIAS", unresolve_entry.target)
resolved_entry = @index.resolve("Other::ONE_MORE::C", []).firstassert_instance_of(Entry::Module, resolved_entry)
end
# File lib/ruby_indexer/test/constant_test.rb, line 21deftest_constant_or_writesindex(<<~RUBY)
FOO ||= 1
class ::Bar
FOO ||= 2
end
RUBYassert_entry("FOO", Entry::Constant, "/fake/path/foo.rb:0-0:0-9")
assert_entry("Bar::FOO", Entry::Constant, "/fake/path/foo.rb:3-2:3-11")
end
test_constant_path_or_writes()
# File lib/ruby_indexer/test/constant_test.rb, line 54deftest_constant_path_or_writesindex(<<~RUBY)
class A
FOO ||= 1
::BAR ||= 1
end
A::BAZ ||= 1
RUBYassert_entry("A::FOO", Entry::Constant, "/fake/path/foo.rb:1-2:1-11")
assert_entry("BAR", Entry::Constant, "/fake/path/foo.rb:2-2:2-13")
assert_entry("A::BAZ", Entry::Constant, "/fake/path/foo.rb:5-0:5-12")
end
test_constant_path_writes()
# File lib/ruby_indexer/test/constant_test.rb, line 34deftest_constant_path_writesindex(<<~RUBY)
class A
FOO = 1
::BAR = 1
module B
FOO = 1
end
end
A::BAZ = 1
RUBYassert_entry("A::FOO", Entry::Constant, "/fake/path/foo.rb:1-2:1-9")
assert_entry("BAR", Entry::Constant, "/fake/path/foo.rb:2-2:2-11")
assert_entry("A::B::FOO", Entry::Constant, "/fake/path/foo.rb:5-4:5-11")
assert_entry("A::BAZ", Entry::Constant, "/fake/path/foo.rb:9-0:9-10")
end
test_constant_writes()
# File lib/ruby_indexer/test/constant_test.rb, line 8deftest_constant_writesindex(<<~RUBY)
FOO = 1
class ::Bar
FOO = 2
end
RUBYassert_entry("FOO", Entry::Constant, "/fake/path/foo.rb:0-0:0-7")
assert_entry("Bar::FOO", Entry::Constant, "/fake/path/foo.rb:3-2:3-9")
end
test_indexing_constant_aliases()
# File lib/ruby_indexer/test/constant_test.rb, line 185deftest_indexing_constant_aliasesindex(<<~RUBY)
module A
module B
module C
end
end
FIRST = B::C
end
SECOND = A::FIRST
RUBYunresolve_entry = @index["A::FIRST"].firstassert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
assert_equal(["A"], unresolve_entry.nesting)
assert_equal("B::C", unresolve_entry.target)
resolved_entry = @index.resolve("A::FIRST", []).firstassert_instance_of(Entry::Alias, resolved_entry)
assert_equal("A::B::C", resolved_entry.target)
end
test_indexing_constant_targets()
# File lib/ruby_indexer/test/constant_test.rb, line 328deftest_indexing_constant_targetsindex(<<~RUBY)
module A
B, C = [1, Y]
D::E, F::G = [Z, 4]
H, I::J = [5, B]
K, L = C
end
module Real
Z = 1
Y = 2
end
RUBYassert_entry("A::B", Entry::Constant, "/fake/path/foo.rb:1-2:1-3")
assert_entry("A::C", Entry::UnresolvedAlias, "/fake/path/foo.rb:1-5:1-6")
assert_entry("A::D::E", Entry::UnresolvedAlias, "/fake/path/foo.rb:2-2:2-6")
assert_entry("A::F::G", Entry::Constant, "/fake/path/foo.rb:2-8:2-12")
assert_entry("A::H", Entry::Constant, "/fake/path/foo.rb:3-2:3-3")
assert_entry("A::I::J", Entry::UnresolvedAlias, "/fake/path/foo.rb:3-5:3-9")
assert_entry("A::K", Entry::Constant, "/fake/path/foo.rb:4-2:4-3")
assert_entry("A::L", Entry::Constant, "/fake/path/foo.rb:4-5:4-6")
end
test_indexing_constant_targets_with_splats()
# File lib/ruby_indexer/test/constant_test.rb, line 353deftest_indexing_constant_targets_with_splatsindex(<<~RUBY)
A, *, B = baz
C, = bar
(D, E) = baz
F, G = *baz, qux
H, I = [baz, *qux]
J, L = [*something, String]
M = [String]
RUBYassert_entry("A", Entry::Constant, "/fake/path/foo.rb:0-0:0-1")
assert_entry("B", Entry::Constant, "/fake/path/foo.rb:0-6:0-7")
assert_entry("D", Entry::Constant, "/fake/path/foo.rb:2-1:2-2")
assert_entry("E", Entry::Constant, "/fake/path/foo.rb:2-4:2-5")
assert_entry("F", Entry::Constant, "/fake/path/foo.rb:3-0:3-1")
assert_entry("G", Entry::Constant, "/fake/path/foo.rb:3-3:3-4")
assert_entry("H", Entry::Constant, "/fake/path/foo.rb:4-0:4-1")
assert_entry("I", Entry::Constant, "/fake/path/foo.rb:4-3:4-4")
assert_entry("J", Entry::Constant, "/fake/path/foo.rb:5-0:5-1")
assert_entry("L", Entry::Constant, "/fake/path/foo.rb:5-3:5-4")
assert_entry("M", Entry::Constant, "/fake/path/foo.rb:6-0:6-12")
end
test_indexing_destructuring_an_array()
# File lib/ruby_indexer/test/constant_test.rb, line 377deftest_indexing_destructuring_an_arrayindex(<<~RUBY)
Baz = [1, 2]
Foo, Bar = Baz
This, That = foo, bar
RUBYassert_entry("Baz", Entry::Constant, "/fake/path/foo.rb:0-0:0-12")
assert_entry("Foo", Entry::Constant, "/fake/path/foo.rb:1-0:1-3")
assert_entry("Bar", Entry::Constant, "/fake/path/foo.rb:1-5:1-8")
assert_entry("This", Entry::Constant, "/fake/path/foo.rb:2-0:2-4")
assert_entry("That", Entry::Constant, "/fake/path/foo.rb:2-6:2-10")
end
test_indexing_or_and_operator_nodes()
# File lib/ruby_indexer/test/constant_test.rb, line 310deftest_indexing_or_and_operator_nodesindex(<<~RUBY)
A ||= 1
B &&= 2
C &= 3
D::E ||= 4
F::G &&= 5
H::I &= 6
RUBYassert_entry("A", Entry::Constant, "/fake/path/foo.rb:0-0:0-7")
assert_entry("B", Entry::Constant, "/fake/path/foo.rb:1-0:1-7")
assert_entry("C", Entry::Constant, "/fake/path/foo.rb:2-0:2-6")
assert_entry("D::E", Entry::Constant, "/fake/path/foo.rb:3-0:3-10")
assert_entry("F::G", Entry::Constant, "/fake/path/foo.rb:4-0:4-10")
assert_entry("H::I", Entry::Constant, "/fake/path/foo.rb:5-0:5-9")
end
test_indexing_same_line_constant_aliases()
# File lib/ruby_indexer/test/constant_test.rb, line 247deftest_indexing_same_line_constant_aliasesindex(<<~RUBY)
module A
B = C = 1
D = E ||= 1
F = G::H &&= 1
I::J = K::L = M = 1
end
RUBY# B and Cunresolve_entry = @index["A::B"].firstassert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
assert_equal(["A"], unresolve_entry.nesting)
assert_equal("C", unresolve_entry.target)
resolved_entry = @index.resolve("A::B", []).firstassert_instance_of(Entry::Alias, resolved_entry)
assert_equal("A::C", resolved_entry.target)
constant = @index["A::C"].firstassert_instance_of(Entry::Constant, constant)
# D and Eunresolve_entry = @index["A::D"].firstassert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
assert_equal(["A"], unresolve_entry.nesting)
assert_equal("E", unresolve_entry.target)
resolved_entry = @index.resolve("A::D", []).firstassert_instance_of(Entry::Alias, resolved_entry)
assert_equal("A::E", resolved_entry.target)
# F and G::Hunresolve_entry = @index["A::F"].firstassert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
assert_equal(["A"], unresolve_entry.nesting)
assert_equal("G::H", unresolve_entry.target)
resolved_entry = @index.resolve("A::F", []).firstassert_instance_of(Entry::Alias, resolved_entry)
assert_equal("A::G::H", resolved_entry.target)
# I::J, K::L and Munresolve_entry = @index["A::I::J"].firstassert_instance_of(Entry::UnresolvedAlias, unresolve_entry)
assert_equal(["A"], unresolve_entry.nesting)
assert_equal("K::L", unresolve_entry.target)
resolved_entry = @index.resolve("A::I::J", []).firstassert_instance_of(Entry::Alias, resolved_entry)
assert_equal("A::K::L", resolved_entry.target)
# When we are resolving A::I::J, we invoke `resolve("K::L", ["A"])`, which recursively resolves A::K::L too.# Therefore, both A::I::J and A::K::L point to A::M by the end of the previous resolve invocationresolved_entry = @index["A::K::L"].firstassert_instance_of(Entry::Alias, resolved_entry)
assert_equal("A::M", resolved_entry.target)
constant = @index["A::M"].firstassert_instance_of(Entry::Constant, constant)
end
# File lib/ruby_indexer/test/constant_test.rb, line 131deftest_marking_constants_as_private_reopening_namespacesindex(<<~RUBY)
module A
module B
CONST_A = 1
private_constant(:CONST_A)
CONST_B = 2
CONST_C = 3
end
module B
private_constant(:CONST_B)
end
end
module A
module B
private_constant(:CONST_C)
end
end
RUBYa_const = @index["A::B::CONST_A"].firstassert_equal(:private, a_const.visibility)
b_const = @index["A::B::CONST_B"].firstassert_equal(:private, b_const.visibility)
c_const = @index["A::B::CONST_C"].firstassert_equal(:private, c_const.visibility)
end
test_marking_constants_as_private_with_receiver()
# File lib/ruby_indexer/test/constant_test.rb, line 164deftest_marking_constants_as_private_with_receiverindex(<<~RUBY)
module A
module B
CONST_A = 1
CONST_B = 2
end
B.private_constant(:CONST_A)
end
A::B.private_constant(:CONST_B)
RUBYa_const = @index["A::B::CONST_A"].firstassert_equal(:private, a_const.visibility)
b_const = @index["A::B::CONST_B"].firstassert_equal(:private, b_const.visibility)
end
test_private_constant_indexing()
# File lib/ruby_indexer/test/constant_test.rb, line 108deftest_private_constant_indexingindex(<<~RUBY)
class A
B = 1
private_constant(:B)
C = 2
private_constant("C")
D = 1
end
RUBYb_const = @index["A::B"].firstassert_equal(:private, b_const.visibility)
c_const = @index["A::C"].firstassert_equal(:private, c_const.visibility)
d_const = @index["A::D"].firstassert_equal(:public, d_const.visibility)
end