ruby-lsp 0.7.6 → 0.8.1

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -0,0 +1,204 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "test_case"
+
+module RubyIndexer
+  class ClassesAndModulesTest < TestCase
+    def test_empty_statements_class
+      index(<<~RUBY)
+        class Foo
+        end
+      RUBY
+
+      assert_entry("Foo", Index::Entry::Class, "/fake/path/foo.rb:0-0:1-2")
+    end
+
+    def test_class_with_statements
+      index(<<~RUBY)
+        class Foo
+          def something; end
+        end
+      RUBY
+
+      assert_entry("Foo", Index::Entry::Class, "/fake/path/foo.rb:0-0:2-2")
+    end
+
+    def test_colon_colon_class
+      index(<<~RUBY)
+        class ::Foo
+        end
+      RUBY
+
+      assert_entry("Foo", Index::Entry::Class, "/fake/path/foo.rb:0-0:1-2")
+    end
+
+    def test_colon_colon_class_inside_class
+      index(<<~RUBY)
+        class Bar
+          class ::Foo
+          end
+        end
+      RUBY
+
+      assert_entry("Bar", Index::Entry::Class, "/fake/path/foo.rb:0-0:3-2")
+      assert_entry("Foo", Index::Entry::Class, "/fake/path/foo.rb:1-2:2-4")
+    end
+
+    def test_namespaced_class
+      index(<<~RUBY)
+        class Foo::Bar
+        end
+      RUBY
+
+      assert_entry("Foo::Bar", Index::Entry::Class, "/fake/path/foo.rb:0-0:1-2")
+    end
+
+    def test_dynamically_namespaced_class
+      index(<<~RUBY)
+        class self::Bar
+        end
+      RUBY
+
+      refute_entry("self::Bar")
+    end
+
+    def test_empty_statements_module
+      index(<<~RUBY)
+        module Foo
+        end
+      RUBY
+
+      assert_entry("Foo", Index::Entry::Module, "/fake/path/foo.rb:0-0:1-2")
+    end
+
+    def test_module_with_statements
+      index(<<~RUBY)
+        module Foo
+          def something; end
+        end
+      RUBY
+
+      assert_entry("Foo", Index::Entry::Module, "/fake/path/foo.rb:0-0:2-2")
+    end
+
+    def test_colon_colon_module
+      index(<<~RUBY)
+        module ::Foo
+        end
+      RUBY
+
+      assert_entry("Foo", Index::Entry::Module, "/fake/path/foo.rb:0-0:1-2")
+    end
+
+    def test_namespaced_module
+      index(<<~RUBY)
+        module Foo::Bar
+        end
+      RUBY
+
+      assert_entry("Foo::Bar", Index::Entry::Module, "/fake/path/foo.rb:0-0:1-2")
+    end
+
+    def test_dynamically_namespaced_module
+      index(<<~RUBY)
+        module self::Bar
+        end
+      RUBY
+
+      refute_entry("self::Bar")
+    end
+
+    def test_nested_modules_and_classes
+      index(<<~RUBY)
+        module Foo
+          class Bar
+          end
+
+          module Baz
+            class Qux
+              class Something
+              end
+            end
+          end
+        end
+      RUBY
+
+      assert_entry("Foo", Index::Entry::Module, "/fake/path/foo.rb:0-0:10-2")
+      assert_entry("Foo::Bar", Index::Entry::Class, "/fake/path/foo.rb:1-2:2-4")
+      assert_entry("Foo::Baz", Index::Entry::Module, "/fake/path/foo.rb:4-2:9-4")
+      assert_entry("Foo::Baz::Qux", Index::Entry::Class, "/fake/path/foo.rb:5-4:8-6")
+      assert_entry("Foo::Baz::Qux::Something", Index::Entry::Class, "/fake/path/foo.rb:6-6:7-8")
+    end
+
+    def test_deleting_from_index_based_on_file_path
+      index(<<~RUBY)
+        class Foo
+        end
+      RUBY
+
+      assert_entry("Foo", Index::Entry::Class, "/fake/path/foo.rb:0-0:1-2")
+
+      @index.delete("/fake/path/foo.rb")
+      refute_entry("Foo")
+      assert_empty(@index.instance_variable_get(:@files_to_entries))
+    end
+
+    def test_comments_can_be_attached_to_a_class
+      index(<<~RUBY)
+        # This is method comment
+        def foo; end
+        # This is a Foo comment
+        # This is another Foo comment
+        class Foo
+          # This should not be attached
+        end
+
+        # Ignore me
+
+        # This Bar comment has 1 line padding
+
+        class Bar; end
+      RUBY
+
+      foo_entry = @index["Foo"].first
+      assert_equal("# This is a Foo comment\n# This is another Foo comment\n", foo_entry.comments.join)
+
+      bar_entry = @index["Bar"].first
+      assert_equal("# This Bar comment has 1 line padding\n", bar_entry.comments.join)
+    end
+
+    def test_comments_can_be_attached_to_a_namespaced_class
+      index(<<~RUBY)
+        # This is a Foo comment
+        # This is another Foo comment
+        class Foo
+          # This is a Bar comment
+          class Bar; end
+        end
+      RUBY
+
+      foo_entry = @index["Foo"].first
+      assert_equal("# This is a Foo comment\n# This is another Foo comment\n", foo_entry.comments.join)
+
+      bar_entry = @index["Foo::Bar"].first
+      assert_equal("# This is a Bar comment\n", bar_entry.comments.join)
+    end
+
+    def test_comments_can_be_attached_to_a_reopened_class
+      index(<<~RUBY)
+        # This is a Foo comment
+        class Foo; end
+
+        # This is another Foo comment
+        class Foo; end
+      RUBY
+
+      first_foo_entry = @index["Foo"][0]
+      assert_equal("# This is a Foo comment\n", first_foo_entry.comments.join)
+
+      second_foo_entry = @index["Foo"][1]
+      assert_equal("# This is another Foo comment\n", second_foo_entry.comments.join)
+    end
+  end
+end

data/lib/ruby_indexer/test/configuration_test.rb

@@ -0,0 +1,35 @@
+# typed: true
+# frozen_string_literal: true
+
+require "test_helper"
+
+module RubyIndexer
+  class ConfigurationTest < Minitest::Test
+    def setup
+      @config = Configuration.new
+    end
+
+    def test_load_configuration_executes_configure_block
+      @config.load_config
+      files_to_index = @config.files_to_index
+
+      assert(files_to_index.none? { |path| path.include?("test/fixtures") })
+      assert(files_to_index.none? { |path| path.include?("minitest-reporters") })
+    end
+
+    def test_paths_are_unique
+      @config.load_config
+      files_to_index = @config.files_to_index
+
+      assert_equal(files_to_index.uniq.length, files_to_index.length)
+    end
+
+    def test_configuration_raises_for_unknown_keys
+      Psych::Nodes::Document.any_instance.expects(:to_ruby).returns({ "unknown_config" => 123 })
+
+      assert_raises(ArgumentError) do
+        @config.load_config
+      end
+    end
+  end
+end

data/lib/ruby_indexer/test/constant_test.rb

@@ -0,0 +1,108 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "test_case"
+
+module RubyIndexer
+  class ConstantTest < TestCase
+    def test_constant_writes
+      index(<<~RUBY)
+        FOO = 1
+
+        class ::Bar
+          FOO = 2
+        end
+      RUBY
+
+      assert_entry("FOO", Index::Entry::Constant, "/fake/path/foo.rb:0-0:0-6")
+      assert_entry("Bar::FOO", Index::Entry::Constant, "/fake/path/foo.rb:3-2:3-8")
+    end
+
+    def test_constant_or_writes
+      index(<<~RUBY)
+        FOO ||= 1
+
+        class ::Bar
+          FOO ||= 2
+        end
+      RUBY
+
+      assert_entry("FOO", Index::Entry::Constant, "/fake/path/foo.rb:0-0:0-8")
+      assert_entry("Bar::FOO", Index::Entry::Constant, "/fake/path/foo.rb:3-2:3-10")
+    end
+
+    def test_constant_path_writes
+      index(<<~RUBY)
+        class A
+          FOO = 1
+          ::BAR = 1
+
+          module B
+            FOO = 1
+          end
+        end
+
+        A::BAZ = 1
+      RUBY
+
+      assert_entry("A::FOO", Index::Entry::Constant, "/fake/path/foo.rb:1-2:1-8")
+      assert_entry("BAR", Index::Entry::Constant, "/fake/path/foo.rb:2-2:2-10")
+      assert_entry("A::B::FOO", Index::Entry::Constant, "/fake/path/foo.rb:5-4:5-10")
+      assert_entry("A::BAZ", Index::Entry::Constant, "/fake/path/foo.rb:9-0:9-9")
+    end
+
+    def test_constant_path_or_writes
+      index(<<~RUBY)
+        class A
+          FOO ||= 1
+          ::BAR ||= 1
+        end
+
+        A::BAZ ||= 1
+      RUBY
+
+      assert_entry("A::FOO", Index::Entry::Constant, "/fake/path/foo.rb:1-2:1-10")
+      assert_entry("BAR", Index::Entry::Constant, "/fake/path/foo.rb:2-2:2-12")
+      assert_entry("A::BAZ", Index::Entry::Constant, "/fake/path/foo.rb:5-0:5-11")
+    end
+
+    def test_comments_for_constants
+      index(<<~RUBY)
+        # FOO comment
+        FOO = 1
+
+        class A
+          # A::FOO comment
+          FOO = 1
+
+          # ::BAR comment
+          ::BAR = 1
+        end
+
+        # A::BAZ comment
+        A::BAZ = 1
+      RUBY
+
+      foo_comment = @index["FOO"].first.comments.join("\n")
+      assert_equal("# FOO comment\n", foo_comment)
+
+      a_foo_comment = @index["A::FOO"].first.comments.join("\n")
+      assert_equal("# A::FOO comment\n", a_foo_comment)
+
+      bar_comment = @index["BAR"].first.comments.join("\n")
+      assert_equal("# ::BAR comment\n", bar_comment)
+
+      a_baz_comment = @index["A::BAZ"].first.comments.join("\n")
+      assert_equal("# A::BAZ comment\n", a_baz_comment)
+    end
+
+    def test_variable_path_constants_are_ignored
+      index(<<~RUBY)
+        var::FOO = 1
+        self.class::FOO = 1
+      RUBY
+
+      assert_no_entry
+    end
+  end
+end

data/lib/ruby_indexer/test/index_test.rb

@@ -0,0 +1,94 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "test_case"
+
+module RubyIndexer
+  class IndexTest < TestCase
+    def test_deleting_one_entry_for_a_class
+      @index.index_single("/fake/path/foo.rb", <<~RUBY)
+        class Foo
+        end
+      RUBY
+      @index.index_single("/fake/path/other_foo.rb", <<~RUBY)
+        class Foo
+        end
+      RUBY
+
+      entries = @index["Foo"]
+      assert_equal(2, entries.length)
+
+      @index.delete("/fake/path/other_foo.rb")
+      entries = @index["Foo"]
+      assert_equal(1, entries.length)
+    end
+
+    def test_deleting_all_entries_for_a_class
+      @index.index_single("/fake/path/foo.rb", <<~RUBY)
+        class Foo
+        end
+      RUBY
+
+      entries = @index["Foo"]
+      assert_equal(1, entries.length)
+
+      @index.delete("/fake/path/foo.rb")
+      entries = @index["Foo"]
+      assert_nil(entries)
+    end
+
+    def test_index_resolve
+      @index.index_single("/fake/path/foo.rb", <<~RUBY)
+        class Bar; end
+
+        module Foo
+          class Bar
+          end
+
+          class Baz
+            class Something
+            end
+          end
+        end
+      RUBY
+
+      entries = @index.resolve("Something", ["Foo", "Baz"])
+      refute_empty(entries)
+      assert_equal("Foo::Baz::Something", entries.first.name)
+
+      entries = @index.resolve("Bar", ["Foo"])
+      refute_empty(entries)
+      assert_equal("Foo::Bar", entries.first.name)
+
+      entries = @index.resolve("Bar", ["Foo", "Baz"])
+      refute_empty(entries)
+      assert_equal("Foo::Bar", entries.first.name)
+
+      entries = @index.resolve("Foo::Bar", ["Foo", "Baz"])
+      refute_empty(entries)
+      assert_equal("Foo::Bar", entries.first.name)
+
+      assert_nil(@index.resolve("DoesNotExist", ["Foo"]))
+    end
+
+    def test_accessing_with_colon_colon_prefix
+      @index.index_single("/fake/path/foo.rb", <<~RUBY)
+        class Bar; end
+
+        module Foo
+          class Bar
+          end
+
+          class Baz
+            class Something
+            end
+          end
+        end
+      RUBY
+
+      entries = @index["::Foo::Baz::Something"]
+      refute_empty(entries)
+      assert_equal("Foo::Baz::Something", entries.first.name)
+    end
+  end
+end

data/lib/ruby_indexer/test/test_case.rb

@@ -0,0 +1,42 @@
+# typed: true
+# frozen_string_literal: true
+
+require "test_helper"
+
+module RubyIndexer
+  class TestCase < Minitest::Test
+    def setup
+      @index = Index.new
+    end
+
+    private
+
+    def index(source)
+      @index.index_single("/fake/path/foo.rb", source)
+    end
+
+    def assert_entry(expected_name, type, expected_location)
+      entries = @index[expected_name]
+      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)
+    end
+
+    def refute_entry(expected_name)
+      entries = @index[expected_name]
+      assert_nil(entries, "Expected #{expected_name} to not be indexed")
+    end
+
+    def assert_no_entry
+      assert_empty(@index.instance_variable_get(:@entries), "Expected nothing to be indexed")
+    end
+  end
+end

data/lib/ruby_lsp/document.rb

@@ -18,16 +18,16 @@ module RubyLsp
     sig { returns(Integer) }
     attr_reader :version
 
-    sig { returns(String) }
+    sig { returns(URI::Generic) }
     attr_reader :uri
 
-    sig { params(source: String, version: Integer, uri: String, encoding: String).void }
+    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: String).void }
     def initialize(source:, version:, uri:, encoding: Constant::PositionEncodingKind::UTF8)
       @cache = T.let({}, T::Hash[String, T.untyped])
       @encoding = T.let(encoding, String)
       @source = T.let(source, String)
       @version = T.let(version, Integer)
-      @uri = T.let(uri, String)
+      @uri = T.let(uri, URI::Generic)
       @unparsed_edits = T.let([], T::Array[EditShape])
       @syntax_error = T.let(false, T::Boolean)
       @tree = T.let(SyntaxTree.parse(@source), T.nilable(SyntaxTree::Node))