ruby-lsp 0.23.11 → 0.26.6

data/lib/ruby_indexer/test/reference_finder_test.rb

@@ -1,330 +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_read_references
-      refs = find_instance_variable_references("@foo", <<~RUBY)
-        class Foo
-          def foo
-            @foo
-          end
-        end
-      RUBY
-      assert_equal(1, refs.size)
-
-      assert_equal("@foo", refs[0].name)
-      assert_equal(3, refs[0].location.start_line)
-    end
-
-    def test_finds_instance_variable_write_references
-      refs = find_instance_variable_references("@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_ignore_context
-      refs = find_instance_variable_references("@name", <<~RUBY)
-        class Foo
-          def name
-            @name = "foo"
-          end
-        end
-        class Bar
-          def name
-            @name = "bar"
-          end
-        end
-      RUBY
-      assert_equal(2, refs.size)
-
-      assert_equal("@name", refs[0].name)
-      assert_equal(3, refs[0].location.start_line)
-
-      assert_equal("@name", refs[1].name)
-      assert_equal(8, refs[1].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, source)
-      target = ReferenceFinder::InstanceVariableTarget.new(instance_variable_name)
-      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,51 +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
-
-    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]
-      refute_nil(entries, "Expected #{expected_name} to be indexed")
-      refute_empty(entries, "Expected #{expected_name} to be indexed")
-
-      entry = entries.first
-      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,72 +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:/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:/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
-  end
-end

data/lib/ruby_lsp/load_sorbet.rb

@@ -1,62 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "sorbet-runtime"
-
-begin
-  T::Configuration.default_checked_level = :never
-  # Suppresses call validation errors
-  T::Configuration.call_validation_error_handler = ->(*arg) {}
-  # Suppresses errors caused by T.cast, T.let, T.must, etc.
-  T::Configuration.inline_type_error_handler = ->(*arg) {}
-  # Suppresses errors caused by incorrect parameter ordering
-  T::Configuration.sig_validation_error_handler = ->(*arg) {}
-rescue
-  # Need this rescue so that if another gem has
-  # already set the checked level by the time we
-  # get to it, we don't fail outright.
-  nil
-end
-
-module RubyLsp
-  # No-op all inline type assertions defined in T
-  module InlineTypeAssertions
-    def absurd(value)
-      value
-    end
-
-    def any(type_a, type_b, *types)
-      T::Types::Union.new([type_a, type_b, *types])
-    end
-
-    def assert_type!(value, type, checked: true)
-      value
-    end
-
-    def bind(value, type, checked: true)
-      value
-    end
-
-    def cast(value, type, checked: true)
-      value
-    end
-
-    def let(value, type, checked: true)
-      value
-    end
-
-    def must(arg)
-      arg
-    end
-
-    def nilable(type)
-      T::Types::Union.new([type, T::Utils::Nilable::NIL_TYPE])
-    end
-
-    def unsafe(value)
-      value
-    end
-
-    T.singleton_class.prepend(self)
-  end
-end