ruby-lsp 0.8.0 → 0.9.0

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -0,0 +1,220 @@
+# 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\nThis is another Foo comment", foo_entry.comments.join("\n"))
+
+      bar_entry = @index["Bar"].first
+      assert_equal("This Bar comment has 1 line padding", bar_entry.comments.join("\n"))
+    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\nThis is another Foo comment", foo_entry.comments.join("\n"))
+
+      bar_entry = @index["Foo::Bar"].first
+      assert_equal("This is a Bar comment", bar_entry.comments.join("\n"))
+    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", first_foo_entry.comments.join("\n"))
+
+      second_foo_entry = @index["Foo"][1]
+      assert_equal("This is another Foo comment", second_foo_entry.comments.join("\n"))
+    end
+
+    def test_comments_removes_the_leading_pound_and_space
+      index(<<~RUBY)
+        # This is a Foo comment
+        class Foo; end
+
+        #This is a Bar comment
+        class Bar; end
+      RUBY
+
+      first_foo_entry = @index["Foo"][0]
+      assert_equal("This is a Foo comment", first_foo_entry.comments.join("\n"))
+
+      second_foo_entry = @index["Bar"][0]
+      assert_equal("This is a Bar comment", second_foo_entry.comments.join("\n"))
+    end
+  end
+end

data/lib/ruby_indexer/test/configuration_test.rb

@@ -0,0 +1,114 @@
+# 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") })
+      assert(files_to_index.none? { |path| path == __FILE__ })
+    end
+
+    def test_files_to_index_only_includes_gem_require_paths
+      @config.load_config
+      files_to_index = @config.files_to_index
+
+      Bundler.locked_gems.specs.each do |lazy_spec|
+        next if lazy_spec.name == "ruby-lsp"
+
+        spec = Gem::Specification.find_by_name(lazy_spec.name)
+        assert(files_to_index.none? { |path| path.start_with?("#{spec.full_gem_path}/test/") })
+      rescue Gem::MissingSpecError
+        # Transitive dependencies might be missing when running tests on Windows
+      end
+    end
+
+    def test_files_to_index_does_not_include_default_gem_path_when_in_bundle
+      @config.load_config
+      files_to_index = @config.files_to_index
+
+      assert(files_to_index.none? { |path| path.start_with?("#{RbConfig::CONFIG["rubylibdir"]}/psych") })
+    end
+
+    def test_files_to_index_includes_default_gems
+      @config.load_config
+      files_to_index = @config.files_to_index
+
+      assert_includes(files_to_index, "#{RbConfig::CONFIG["rubylibdir"]}/pathname.rb")
+      assert_includes(files_to_index, "#{RbConfig::CONFIG["rubylibdir"]}/ipaddr.rb")
+      assert_includes(files_to_index, "#{RbConfig::CONFIG["rubylibdir"]}/abbrev.rb")
+    end
+
+    def test_files_to_index_includes_project_files
+      @config.load_config
+      files_to_index = @config.files_to_index
+
+      Dir.glob("#{Dir.pwd}/lib/**/*.rb").each do |path|
+        next if path.end_with?("_test.rb")
+
+        assert_includes(files_to_index, path)
+      end
+    end
+
+    def test_files_to_index_avoids_duplicates_if_bundle_path_is_inside_project
+      Bundler.settings.set_global("path", "vendor/bundle")
+      config = Configuration.new
+      config.load_config
+
+      assert_includes(config.instance_variable_get(:@excluded_patterns), "#{Dir.pwd}/vendor/bundle/**/*.rb")
+    ensure
+      Bundler.settings.set_global("path", nil)
+    end
+
+    def test_files_to_index_does_not_include_gems_own_installed_files
+      @config.load_config
+      files_to_index = @config.files_to_index
+
+      assert(files_to_index.none? { |path| path.start_with?(Bundler.bundle_path.join("gems", "ruby-lsp").to_s) })
+    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
+
+    def test_magic_comments_regex
+      regex = RubyIndexer.configuration.magic_comment_regex
+
+      [
+        "# frozen_string_literal:",
+        "# typed:",
+        "# compiled:",
+        "# encoding:",
+        "# shareable_constant_value:",
+        "# warn_indent:",
+        "# rubocop:",
+        "# nodoc:",
+        "# doc:",
+        "# coding:",
+        "# warn_past_scope:",
+      ].each do |comment|
+        assert_match(regex, comment)
+      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", foo_comment)
+
+      a_foo_comment = @index["A::FOO"].first.comments.join("\n")
+      assert_equal("A::FOO comment", a_foo_comment)
+
+      bar_comment = @index["BAR"].first.comments.join("\n")
+      assert_equal("::BAR comment", bar_comment)
+
+      a_baz_comment = @index["A::BAZ"].first.comments.join("\n")
+      assert_equal("A::BAZ comment", 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,129 @@
+# 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
+
+    def test_fuzzy_search
+      @index.index_single("/fake/path/foo.rb", <<~RUBY)
+        class Bar; end
+
+        module Foo
+          class Bar
+          end
+
+          class Baz
+            class Something
+            end
+          end
+        end
+      RUBY
+
+      result = @index.fuzzy_search("Bar")
+      assert_equal(1, result.length)
+      assert_equal(@index["Bar"].first, result.first)
+
+      result = @index.fuzzy_search("foobarsomeking")
+      assert_equal(5, result.length)
+      assert_equal(["Foo::Baz::Something", "Foo::Bar", "Foo::Baz", "Foo", "Bar"], result.map(&:name))
+
+      result = @index.fuzzy_search("FooBaz")
+      assert_equal(4, result.length)
+      assert_equal(["Foo::Baz", "Foo::Bar", "Foo", "Foo::Baz::Something"], result.map(&:name))
+    end
+
+    def test_index_single_ignores_directories
+      FileUtils.mkdir("lib/this_is_a_dir.rb")
+      @index.index_single("lib/this_is_a_dir.rb")
+    ensure
+      FileUtils.rm_r("lib/this_is_a_dir.rb")
+    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