ruby-lsp 0.26.5 → 0.26.7

data/lib/ruby_indexer/test/reference_finder_test.rb

@@ -1,395 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "test_helper"
-
-module RubyIndexer
-  class ReferenceFinderTest < Minitest::Test
-    def test_finds_constant_references
-      refs = find_const_references("Foo::Bar", <<~RUBY)
-        module Foo
-          class Bar
-          end
-
-          Bar
-        end
-
-        Foo::Bar
-      RUBY
-
-      assert_equal("Bar", refs[0].name)
-      assert_equal(2, refs[0].location.start_line)
-
-      assert_equal("Bar", refs[1].name)
-      assert_equal(5, refs[1].location.start_line)
-
-      assert_equal("Foo::Bar", refs[2].name)
-      assert_equal(8, refs[2].location.start_line)
-    end
-
-    def test_finds_constant_references_inside_singleton_contexts
-      refs = find_const_references("Foo::<Class:Foo>::Bar", <<~RUBY)
-        class Foo
-          class << self
-            class Bar
-            end
-
-            Bar
-          end
-        end
-      RUBY
-
-      assert_equal("Bar", refs[0].name)
-      assert_equal(3, refs[0].location.start_line)
-
-      assert_equal("Bar", refs[1].name)
-      assert_equal(6, refs[1].location.start_line)
-    end
-
-    def test_finds_top_level_constant_references
-      refs = find_const_references("Bar", <<~RUBY)
-        class Bar
-        end
-
-        class Foo
-          ::Bar
-
-          class << self
-            ::Bar
-          end
-        end
-      RUBY
-
-      assert_equal("Bar", refs[0].name)
-      assert_equal(1, refs[0].location.start_line)
-
-      assert_equal("::Bar", refs[1].name)
-      assert_equal(5, refs[1].location.start_line)
-
-      assert_equal("::Bar", refs[2].name)
-      assert_equal(8, refs[2].location.start_line)
-    end
-
-    def test_finds_method_references
-      refs = find_method_references("foo", <<~RUBY)
-        class Bar
-          def foo
-          end
-
-          def baz
-            foo
-          end
-        end
-      RUBY
-
-      assert_equal(2, refs.size)
-
-      assert_equal("foo", refs[0].name)
-      assert_equal(2, refs[0].location.start_line)
-
-      assert_equal("foo", refs[1].name)
-      assert_equal(6, refs[1].location.start_line)
-    end
-
-    def test_does_not_mismatch_on_readers_and_writers
-      refs = find_method_references("foo", <<~RUBY)
-        class Bar
-          def foo
-          end
-
-          def foo=(value)
-          end
-
-          def baz
-            self.foo = 1
-            self.foo
-          end
-        end
-      RUBY
-
-      # We want to match `foo` but not `foo=`
-      assert_equal(2, refs.size)
-
-      assert_equal("foo", refs[0].name)
-      assert_equal(2, refs[0].location.start_line)
-
-      assert_equal("foo", refs[1].name)
-      assert_equal(10, refs[1].location.start_line)
-    end
-
-    def test_matches_writers
-      refs = find_method_references("foo=", <<~RUBY)
-        class Bar
-          def foo
-          end
-
-          def foo=(value)
-          end
-
-          def baz
-            self.foo = 1
-            self.foo
-          end
-        end
-      RUBY
-
-      # We want to match `foo=` but not `foo`
-      assert_equal(2, refs.size)
-
-      assert_equal("foo=", refs[0].name)
-      assert_equal(5, refs[0].location.start_line)
-
-      assert_equal("foo=", refs[1].name)
-      assert_equal(9, refs[1].location.start_line)
-    end
-
-    def test_find_inherited_methods
-      refs = find_method_references("foo", <<~RUBY)
-        class Bar
-          def foo
-          end
-        end
-
-        class Baz < Bar
-          super.foo
-        end
-      RUBY
-
-      assert_equal(2, refs.size)
-
-      assert_equal("foo", refs[0].name)
-      assert_equal(2, refs[0].location.start_line)
-
-      assert_equal("foo", refs[1].name)
-      assert_equal(7, refs[1].location.start_line)
-    end
-
-    def test_finds_methods_created_in_mixins
-      refs = find_method_references("foo", <<~RUBY)
-        module Mixin
-          def foo
-          end
-        end
-
-        class Bar
-          include Mixin
-        end
-
-        Bar.foo
-      RUBY
-
-      assert_equal(2, refs.size)
-
-      assert_equal("foo", refs[0].name)
-      assert_equal(2, refs[0].location.start_line)
-
-      assert_equal("foo", refs[1].name)
-      assert_equal(10, refs[1].location.start_line)
-    end
-
-    def test_finds_singleton_methods
-      # The current implementation matches on both `Bar.foo` and `Bar#foo` even though they are different
-
-      refs = find_method_references("foo", <<~RUBY)
-        class Bar
-          class << self
-            def foo
-            end
-          end
-
-          def foo
-          end
-        end
-
-        Bar.foo
-      RUBY
-
-      assert_equal(3, refs.size)
-
-      assert_equal("foo", refs[0].name)
-      assert_equal(3, refs[0].location.start_line)
-
-      assert_equal("foo", refs[1].name)
-      assert_equal(7, refs[1].location.start_line)
-
-      assert_equal("foo", refs[2].name)
-      assert_equal(11, refs[2].location.start_line)
-    end
-
-    def test_finds_instance_variable_references
-      refs = find_instance_variable_references("@name", ["Foo"], <<~RUBY)
-        class Foo
-          def initialize
-            @name = "foo"
-          end
-          def name
-            @name
-          end
-          def name_capital
-            @name[0]
-          end
-        end
-
-        class Bar
-          def initialize
-            @name = "foo"
-          end
-          def name
-            @name
-          end
-        end
-      RUBY
-      assert_equal(3, refs.size)
-
-      assert_equal("@name", refs[0].name)
-      assert_equal(3, refs[0].location.start_line)
-
-      assert_equal("@name", refs[1].name)
-      assert_equal(6, refs[1].location.start_line)
-
-      assert_equal("@name", refs[2].name)
-      assert_equal(9, refs[2].location.start_line)
-    end
-
-    def test_finds_instance_variable_write_references
-      refs = find_instance_variable_references("@foo", ["Foo"], <<~RUBY)
-        class Foo
-          def write
-            @foo = 1
-            @foo &&= 2
-            @foo ||= 3
-            @foo += 4
-            @foo, @bar = []
-          end
-        end
-      RUBY
-      assert_equal(5, refs.size)
-
-      assert_equal(["@foo"], refs.map(&:name).uniq)
-      assert_equal(3, refs[0].location.start_line)
-      assert_equal(4, refs[1].location.start_line)
-      assert_equal(5, refs[2].location.start_line)
-      assert_equal(6, refs[3].location.start_line)
-      assert_equal(7, refs[4].location.start_line)
-    end
-
-    def test_finds_instance_variable_references_in_owner_ancestors
-      refs = find_instance_variable_references("@name", ["Foo", "Base", "Top", "Parent"], <<~RUBY)
-        module Base
-          def change_name(name)
-            @name = name
-          end
-          def name
-            @name
-          end
-
-          module ::Top
-            def name
-              @name
-            end
-          end
-        end
-
-        class Parent
-          def initialize
-            @name = "parent"
-          end
-          def name_capital
-            @name[0]
-          end
-        end
-
-        class Foo < Parent
-          include Base
-          def initialize
-            @name = "foo"
-          end
-          def name
-            @name
-          end
-        end
-
-        class Bar
-          def name
-            @name = "bar"
-          end
-        end
-      RUBY
-      assert_equal(7, refs.size)
-
-      assert_equal("@name", refs[0].name)
-      assert_equal(3, refs[0].location.start_line)
-
-      assert_equal("@name", refs[1].name)
-      assert_equal(6, refs[1].location.start_line)
-
-      assert_equal("@name", refs[2].name)
-      assert_equal(11, refs[2].location.start_line)
-
-      assert_equal("@name", refs[3].name)
-      assert_equal(18, refs[3].location.start_line)
-
-      assert_equal("@name", refs[4].name)
-      assert_equal(21, refs[4].location.start_line)
-
-      assert_equal("@name", refs[5].name)
-      assert_equal(28, refs[5].location.start_line)
-
-      assert_equal("@name", refs[6].name)
-      assert_equal(31, refs[6].location.start_line)
-    end
-
-    def test_accounts_for_reopened_classes
-      refs = find_const_references("Foo", <<~RUBY)
-        class Foo
-        end
-        class Foo
-          class Bar
-          end
-        end
-
-        Foo.new
-      RUBY
-
-      assert_equal(3, refs.size)
-
-      assert_equal("Foo", refs[0].name)
-      assert_equal(1, refs[0].location.start_line)
-
-      assert_equal("Foo", refs[1].name)
-      assert_equal(3, refs[1].location.start_line)
-
-      assert_equal("Foo", refs[2].name)
-      assert_equal(8, refs[2].location.start_line)
-    end
-
-    private
-
-    def find_const_references(const_name, source)
-      target = ReferenceFinder::ConstTarget.new(const_name)
-      find_references(target, source)
-    end
-
-    def find_method_references(method_name, source)
-      target = ReferenceFinder::MethodTarget.new(method_name)
-      find_references(target, source)
-    end
-
-    def find_instance_variable_references(instance_variable_name, owner_ancestors, source)
-      target = ReferenceFinder::InstanceVariableTarget.new(instance_variable_name, owner_ancestors)
-      find_references(target, source)
-    end
-
-    def find_references(target, source)
-      file_path = "/fake.rb"
-      uri = URI::Generic.from_path(path: file_path)
-      index = Index.new
-      index.index_single(uri, source)
-      parse_result = Prism.parse(source)
-      dispatcher = Prism::Dispatcher.new
-      finder = ReferenceFinder.new(target, index, dispatcher, uri)
-      dispatcher.visit(parse_result.value)
-      finder.references
-    end
-  end
-end

data/lib/ruby_indexer/test/test_case.rb

@@ -1,57 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "test_helper"
-
-module RubyIndexer
-  class TestCase < Minitest::Test
-    def setup
-      @index = Index.new
-      RBSIndexer.new(@index).index_ruby_core
-      @default_indexed_entries = @index.instance_variable_get(:@entries).dup
-    end
-
-    def teardown
-      entries = @index.instance_variable_get(:@entries).values.flatten
-      entries.each do |entry|
-        assert_includes([:public, :private, :protected], entry.visibility)
-      end
-    end
-
-    private
-
-    def index(source, uri: URI::Generic.from_path(path: "/fake/path/foo.rb"))
-      @index.index_single(uri, source)
-    end
-
-    def assert_entry(expected_name, type, expected_location, visibility: nil)
-      entries = @index[expected_name] #: as !nil
-      refute_nil(entries, "Expected #{expected_name} to be indexed")
-      refute_empty(entries, "Expected #{expected_name} to be indexed")
-
-      entry = entries.first #: as !nil
-      assert_instance_of(type, entry, "Expected #{expected_name} to be a #{type}")
-
-      location = entry.location
-      location_string =
-        "#{entry.file_path}:#{location.start_line - 1}-#{location.start_column}" \
-          ":#{location.end_line - 1}-#{location.end_column}"
-
-      assert_equal(expected_location, location_string)
-      assert_equal(visibility, entry.visibility) if visibility
-    end
-
-    def refute_entry(expected_name)
-      entries = @index[expected_name]
-      assert_nil(entries, "Expected #{expected_name} to not be indexed")
-    end
-
-    def assert_no_indexed_entries
-      assert_equal(@default_indexed_entries, @index.instance_variable_get(:@entries))
-    end
-
-    def assert_no_entry(entry)
-      refute(@index.indexed?(entry), "Expected '#{entry}' to not be indexed")
-    end
-  end
-end

data/lib/ruby_indexer/test/uri_test.rb

@@ -1,85 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "test_helper"
-
-module RubyIndexer
-  class URITest < Minitest::Test
-    def test_from_path_on_unix
-      uri = URI::Generic.from_path(path: "/some/unix/path/to/file.rb")
-      assert_equal("/some/unix/path/to/file.rb", uri.path)
-    end
-
-    def test_from_path_on_windows
-      uri = URI::Generic.from_path(path: "C:/some/windows/path/to/file.rb")
-      assert_equal("/C%3A/some/windows/path/to/file.rb", uri.path)
-    end
-
-    def test_from_path_on_windows_with_lowercase_drive
-      uri = URI::Generic.from_path(path: "c:/some/windows/path/to/file.rb")
-      assert_equal("/c%3A/some/windows/path/to/file.rb", uri.path)
-    end
-
-    def test_to_standardized_path_on_unix
-      uri = URI::Generic.from_path(path: "/some/unix/path/to/file.rb")
-      assert_equal(uri.path, uri.to_standardized_path)
-    end
-
-    def test_to_standardized_path_on_windows
-      uri = URI::Generic.from_path(path: "C:/some/windows/path/to/file.rb")
-      assert_equal("C:/some/windows/path/to/file.rb", uri.to_standardized_path)
-    end
-
-    def test_to_standardized_path_on_windows_with_lowercase_drive
-      uri = URI::Generic.from_path(path: "c:/some/windows/path/to/file.rb")
-      assert_equal("c:/some/windows/path/to/file.rb", uri.to_standardized_path)
-    end
-
-    def test_to_standardized_path_on_windows_with_received_uri
-      uri = URI("file:///c%3A/some/windows/path/to/file.rb")
-      assert_equal("c:/some/windows/path/to/file.rb", uri.to_standardized_path)
-    end
-
-    def test_plus_signs_are_properly_unescaped
-      path = "/opt/rubies/3.3.0/lib/ruby/3.3.0+0/pathname.rb"
-      uri = URI::Generic.from_path(path: path)
-      assert_equal(path, uri.to_standardized_path)
-    end
-
-    def test_from_path_with_fragment
-      uri = URI::Generic.from_path(path: "/some/unix/path/to/file.rb", fragment: "L1,3-2,9")
-      assert_equal("file:///some/unix/path/to/file.rb#L1,3-2,9", uri.to_s)
-    end
-
-    def test_from_path_windows_long_file_paths
-      uri = URI::Generic.from_path(path: "//?/C:/hostedtoolcache/windows/Ruby/3.3.1/x64/lib/ruby/3.3.0/open-uri.rb")
-      assert_equal("C:/hostedtoolcache/windows/Ruby/3.3.1/x64/lib/ruby/3.3.0/open-uri.rb", uri.to_standardized_path)
-    end
-
-    def test_from_path_computes_require_path_when_load_path_entry_is_given
-      uri = URI::Generic.from_path(path: "/some/unix/path/to/file.rb", load_path_entry: "/some/unix/path")
-      assert_equal("to/file", uri.require_path)
-    end
-
-    def test_allows_adding_require_path_with_load_path_entry
-      uri = URI::Generic.from_path(path: "/some/unix/path/to/file.rb")
-      assert_nil(uri.require_path)
-
-      uri.add_require_path_from_load_entry("/some/unix/path")
-      assert_equal("to/file", uri.require_path)
-    end
-
-    def test_from_path_escapes_colon_characters
-      uri = URI::Generic.from_path(path: "c:/some/windows/path with/spaces/file.rb")
-      assert_equal("c:/some/windows/path with/spaces/file.rb", uri.to_standardized_path)
-      assert_equal("file:///c%3A/some/windows/path%20with/spaces/file.rb", uri.to_s)
-    end
-
-    def test_from_path_with_unicode_characters
-      path = "/path/with/unicode/文件.rb"
-      uri = URI::Generic.from_path(path: path)
-      assert_equal(path, uri.to_standardized_path)
-      assert_equal("file:///path/with/unicode/%E6%96%87%E4%BB%B6.rb", uri.to_s)
-    end
-  end
-end