ruby-lsp 0.22.0 → 0.23.0

data/lib/ruby_indexer/test/class_variables_test.rb

@@ -0,0 +1,140 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "test_case"
+
+module RubyIndexer
+  class ClassVariableTest < TestCase
+    def test_class_variable_and_write
+      index(<<~RUBY)
+        class Foo
+          @@bar &&= 1
+        end
+      RUBY
+
+      assert_entry("@@bar", Entry::ClassVariable, "/fake/path/foo.rb:1-2:1-7")
+
+      entry = T.must(@index["@@bar"]&.first)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo", owner.name)
+    end
+
+    def test_class_variable_operator_write
+      index(<<~RUBY)
+        class Foo
+          @@bar += 1
+        end
+      RUBY
+
+      assert_entry("@@bar", Entry::ClassVariable, "/fake/path/foo.rb:1-2:1-7")
+    end
+
+    def test_class_variable_or_write
+      index(<<~RUBY)
+        class Foo
+          @@bar ||= 1
+        end
+      RUBY
+
+      assert_entry("@@bar", Entry::ClassVariable, "/fake/path/foo.rb:1-2:1-7")
+    end
+
+    def test_class_variable_target_node
+      index(<<~RUBY)
+        class Foo
+          @@foo, @@bar = 1
+        end
+      RUBY
+
+      assert_entry("@@foo", Entry::ClassVariable, "/fake/path/foo.rb:1-2:1-7")
+      assert_entry("@@bar", Entry::ClassVariable, "/fake/path/foo.rb:1-9:1-14")
+
+      entry = T.must(@index["@@foo"]&.first)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo", owner.name)
+
+      entry = T.must(@index["@@bar"]&.first)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo", owner.name)
+    end
+
+    def test_class_variable_write
+      index(<<~RUBY)
+        class Foo
+          @@bar = 1
+        end
+      RUBY
+
+      assert_entry("@@bar", Entry::ClassVariable, "/fake/path/foo.rb:1-2:1-7")
+    end
+
+    def test_empty_name_class_variable
+      index(<<~RUBY)
+        module Foo
+          @@ = 1
+        end
+      RUBY
+
+      refute_entry("@@")
+    end
+
+    def test_top_level_class_variable
+      index(<<~RUBY)
+        @foo = 123
+      RUBY
+
+      entry = T.must(@index["@foo"]&.first)
+      assert_nil(entry.owner)
+    end
+
+    def test_class_variable_inside_self_method
+      index(<<~RUBY)
+        class Foo
+          def self.bar
+            @@bar = 123
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["@@bar"]&.first)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo", owner.name)
+    end
+
+    def test_class_variable_inside_singleton_class
+      index(<<~RUBY)
+        class Foo
+          class << self
+            @@bar = 123
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["@@bar"]&.first)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo", owner.name)
+    end
+
+    def test_class_variable_in_singleton_class_method
+      index(<<~RUBY)
+        class Foo
+          class << self
+            def self.bar
+              @@bar = 123
+            end
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["@@bar"]&.first)
+      owner = T.must(entry.owner)
+      assert_instance_of(Entry::Class, owner)
+      assert_equal("Foo", owner.name)
+    end
+  end
+end

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -200,7 +200,7 @@ module RubyIndexer
 
       assert_entry("Foo", Entry::Class, "/fake/path/foo.rb:0-0:1-3")
 
-      @index.delete(IndexablePath.new(nil, "/fake/path/foo.rb"))
+      @index.delete(URI::Generic.from_path(path: "/fake/path/foo.rb"))
       refute_entry("Foo")
 
       assert_no_indexed_entries
@@ -618,10 +618,12 @@ module RubyIndexer
     end
 
     def test_lazy_comment_fetching_uses_correct_line_breaks_for_rendering
-      path = "lib/ruby_lsp/node_context.rb"
-      indexable = IndexablePath.new("#{Dir.pwd}/lib", path)
+      uri = URI::Generic.from_path(
+        load_path_entry: "#{Dir.pwd}/lib",
+        path: "#{Dir.pwd}/lib/ruby_lsp/node_context.rb",
+      )
 
-      @index.index_single(indexable, collect_comments: false)
+      @index.index_file(uri, collect_comments: false)
 
       entry = @index["RubyLsp::NodeContext"].first
 
@@ -632,9 +634,12 @@ module RubyIndexer
     end
 
     def test_lazy_comment_fetching_does_not_fail_if_file_gets_deleted
-      indexable = IndexablePath.new("#{Dir.pwd}/lib", "lib/ruby_lsp/does_not_exist.rb")
+      uri = URI::Generic.from_path(
+        load_path_entry: "#{Dir.pwd}/lib",
+        path: "#{Dir.pwd}/lib/ruby_lsp/does_not_exist.rb",
+      )
 
-      @index.index_single(indexable, <<~RUBY, collect_comments: false)
+      @index.index_single(uri, <<~RUBY, collect_comments: false)
         class Foo
         end
       RUBY

data/lib/ruby_indexer/test/configuration_test.rb

@@ -13,63 +13,62 @@ module RubyIndexer
 
     def test_load_configuration_executes_configure_block
       @config.apply_config({ "excluded_patterns" => ["**/fixtures/**/*.rb"] })
-      indexables = @config.indexables
+      uris = @config.indexable_uris
 
-      assert(indexables.none? { |indexable| indexable.full_path.include?("test/fixtures") })
-      assert(indexables.none? { |indexable| indexable.full_path.include?("minitest-reporters") })
-      assert(indexables.none? { |indexable| indexable.full_path.include?("ansi") })
-      assert(indexables.any? { |indexable| indexable.full_path.include?("sorbet-runtime") })
-      assert(indexables.none? { |indexable| indexable.full_path == __FILE__ })
+      bundle_path = Bundler.bundle_path.join("gems")
+
+      assert(uris.none? { |uri| uri.full_path.include?("test/fixtures") })
+      assert(uris.none? { |uri| uri.full_path.include?(bundle_path.join("minitest-reporters").to_s) })
+      assert(uris.none? { |uri| uri.full_path.include?(bundle_path.join("ansi").to_s) })
+      assert(uris.any? { |uri| uri.full_path.include?(bundle_path.join("sorbet-runtime").to_s) })
+      assert(uris.none? { |uri| uri.full_path == __FILE__ })
     end
 
-    def test_indexables_have_expanded_full_paths
+    def test_indexable_uris_have_expanded_full_paths
       @config.apply_config({ "included_patterns" => ["**/*.rb"] })
-      indexables = @config.indexables
+      uris = @config.indexable_uris
 
       # All paths should be expanded
-      assert(indexables.all? { |indexable| File.absolute_path?(indexable.full_path) })
+      assert(uris.all? { |uri| File.absolute_path?(uri.full_path) })
     end
 
-    def test_indexables_only_includes_gem_require_paths
-      indexables = @config.indexables
+    def test_indexable_uris_only_includes_gem_require_paths
+      uris = @config.indexable_uris
 
       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(indexables.none? { |indexable| indexable.full_path.start_with?("#{spec.full_gem_path}/test/") })
+        assert(uris.none? { |uri| uri.full_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_indexables_does_not_include_default_gem_path_when_in_bundle
-      indexables = @config.indexables
-
-      assert(
-        indexables.none? { |indexable| indexable.full_path.start_with?("#{RbConfig::CONFIG["rubylibdir"]}/psych") },
-      )
+    def test_indexable_uris_does_not_include_default_gem_path_when_in_bundle
+      uris = @config.indexable_uris
+      assert(uris.none? { |uri| uri.full_path.start_with?("#{RbConfig::CONFIG["rubylibdir"]}/psych") })
     end
 
-    def test_indexables_includes_default_gems
-      indexables = @config.indexables.map(&:full_path)
+    def test_indexable_uris_includes_default_gems
+      paths = @config.indexable_uris.map(&:full_path)
 
-      assert_includes(indexables, "#{RbConfig::CONFIG["rubylibdir"]}/pathname.rb")
-      assert_includes(indexables, "#{RbConfig::CONFIG["rubylibdir"]}/ipaddr.rb")
-      assert_includes(indexables, "#{RbConfig::CONFIG["rubylibdir"]}/erb.rb")
+      assert_includes(paths, "#{RbConfig::CONFIG["rubylibdir"]}/pathname.rb")
+      assert_includes(paths, "#{RbConfig::CONFIG["rubylibdir"]}/ipaddr.rb")
+      assert_includes(paths, "#{RbConfig::CONFIG["rubylibdir"]}/erb.rb")
     end
 
-    def test_indexables_includes_project_files
-      indexables = @config.indexables.map(&:full_path)
+    def test_indexable_uris_includes_project_files
+      paths = @config.indexable_uris.map(&:full_path)
 
       Dir.glob("#{Dir.pwd}/lib/**/*.rb").each do |path|
         next if path.end_with?("_test.rb")
 
-        assert_includes(indexables, path)
+        assert_includes(paths, path)
       end
     end
 
-    def test_indexables_avoids_duplicates_if_bundle_path_is_inside_project
+    def test_indexable_uris_avoids_duplicates_if_bundle_path_is_inside_project
       Bundler.settings.temporary(path: "vendor/bundle") do
         config = Configuration.new
 
@@ -77,33 +76,32 @@ module RubyIndexer
       end
     end
 
-    def test_indexables_does_not_include_gems_own_installed_files
-      indexables = @config.indexables
-      indexables_inside_bundled_lsp = indexables.select do |indexable|
-        indexable.full_path.start_with?(Bundler.bundle_path.join("gems", "ruby-lsp").to_s)
+    def test_indexable_uris_does_not_include_gems_own_installed_files
+      uris = @config.indexable_uris
+      uris_inside_bundled_lsp = uris.select do |uri|
+        uri.full_path.start_with?(Bundler.bundle_path.join("gems", "ruby-lsp").to_s)
       end
 
       assert_empty(
-        indexables_inside_bundled_lsp,
-        "Indexables should not include files from the gem currently being worked on. " \
-          "Included: #{indexables_inside_bundled_lsp.map(&:full_path)}",
+        uris_inside_bundled_lsp,
+        "Indexable URIs should not include files from the gem currently being worked on. " \
+          "Included: #{uris_inside_bundled_lsp.map(&:full_path)}",
       )
     end
 
-    def test_indexables_does_not_include_non_ruby_files_inside_rubylibdir
+    def test_indexable_uris_does_not_include_non_ruby_files_inside_rubylibdir
       path = Pathname.new(RbConfig::CONFIG["rubylibdir"]).join("extra_file.txt").to_s
       FileUtils.touch(path)
-      indexables = @config.indexables
 
-      assert(indexables.none? { |indexable| indexable.full_path == path })
+      uris = @config.indexable_uris
+      assert(uris.none? { |uri| uri.full_path == path })
     ensure
       FileUtils.rm(T.must(path))
     end
 
     def test_paths_are_unique
-      indexables = @config.indexables
-
-      assert_equal(indexables.uniq.length, indexables.length)
+      uris = @config.indexable_uris
+      assert_equal(uris.uniq.length, uris.length)
     end
 
     def test_configuration_raises_for_unknown_keys
@@ -132,7 +130,7 @@ module RubyIndexer
       end
     end
 
-    def test_indexables_respect_given_workspace_path
+    def test_indexable_uris_respect_given_workspace_path
       Dir.mktmpdir do |dir|
         FileUtils.mkdir(File.join(dir, "ignore"))
         FileUtils.touch(File.join(dir, "ignore", "file0.rb"))
@@ -141,21 +139,21 @@ module RubyIndexer
 
         @config.apply_config({ "excluded_patterns" => ["ignore/**/*.rb"] })
         @config.workspace_path = dir
-        indexables = @config.indexables
 
-        assert(indexables.none? { |indexable| indexable.full_path.start_with?(File.join(dir, "ignore")) })
+        uris = @config.indexable_uris
+        assert(uris.none? { |uri| uri.full_path.start_with?(File.join(dir, "ignore")) })
 
-        # After switching the workspace path, all indexables will be found in one of these places:
+        # After switching the workspace path, all indexable URIs will be found in one of these places:
         # - The new workspace path
         # - The Ruby LSP's own code (because Bundler is requiring the dependency from source)
         # - Bundled gems
         # - Default gems
         assert(
-          indexables.all? do |i|
-            i.full_path.start_with?(dir) ||
-            i.full_path.start_with?(File.join(Dir.pwd, "lib")) ||
-            i.full_path.start_with?(Bundler.bundle_path.to_s) ||
-            i.full_path.start_with?(RbConfig::CONFIG["rubylibdir"])
+          uris.all? do |u|
+            u.full_path.start_with?(dir) ||
+            u.full_path.start_with?(File.join(Dir.pwd, "lib")) ||
+            u.full_path.start_with?(Bundler.bundle_path.to_s) ||
+            u.full_path.start_with?(RbConfig::CONFIG["rubylibdir"])
           end,
         )
       end
@@ -166,8 +164,75 @@ module RubyIndexer
         FileUtils.touch(File.join(dir, "find_me.rb"))
         @config.workspace_path = dir
 
-        indexables = @config.indexables
-        assert(indexables.find { |i| File.basename(i.full_path) == "find_me.rb" })
+        uris = @config.indexable_uris
+        assert(uris.find { |u| File.basename(u.full_path) == "find_me.rb" })
+      end
+    end
+
+    def test_transitive_dependencies_for_non_dev_gems_are_not_excluded
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          # Both IRB and debug depend on reline. Since IRB is in the default group, reline should not be excluded
+          File.write(File.join(dir, "Gemfile"), <<~RUBY)
+            source "https://rubygems.org"
+            gem "irb"
+            gem "ruby-lsp", path: "#{Bundler.root}"
+
+            group :development do
+              gem "debug"
+            end
+          RUBY
+
+          Bundler.with_unbundled_env do
+            capture_subprocess_io do
+              system("bundle install")
+            end
+
+            stdout, _stderr = capture_subprocess_io do
+              script = [
+                "require \"ruby_lsp/internal\"",
+                "print RubyIndexer::Configuration.new.instance_variable_get(:@excluded_gems).join(\",\")",
+              ].join(";")
+              system("bundle exec ruby -e '#{script}'")
+            end
+
+            excluded_gems = stdout.split(",")
+            assert_includes(excluded_gems, "debug")
+            refute_includes(excluded_gems, "reline")
+            refute_includes(excluded_gems, "irb")
+          end
+        end
+      end
+    end
+
+    def test_does_not_fail_if_there_are_missing_specs_due_to_platform_constraints
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          File.write(File.join(dir, "Gemfile"), <<~RUBY)
+            source "https://rubygems.org"
+            gem "ruby-lsp", path: "#{Bundler.root}"
+
+            platforms :windows do
+              gem "tzinfo"
+              gem "tzinfo-data"
+            end
+          RUBY
+
+          Bundler.with_unbundled_env do
+            capture_subprocess_io { system("bundle install") }
+
+            _stdout, stderr = capture_subprocess_io do
+              script = [
+                "require \"ruby_lsp/internal\"",
+                "RubyIndexer::Configuration.new.indexable_uris",
+              ].join(";")
+
+              system("bundle exec ruby -e '#{script}'")
+            end
+
+            assert_empty(stderr)
+          end
+        end
       end
     end
   end

data/lib/ruby_indexer/test/enhancements_test.rb

@@ -172,7 +172,7 @@ module RubyIndexer
       end
 
       assert_match(
-        %r{Indexing error in /fake/path/foo\.rb with 'TestEnhancement' on call node enter enhancement},
+        %r{Indexing error in file:///fake/path/foo\.rb with 'TestEnhancement' on call node enter enhancement},
         stderr,
       )
       # The module should still be indexed
@@ -205,7 +205,7 @@ module RubyIndexer
       end
 
       assert_match(
-        %r{Indexing error in /fake/path/foo\.rb with 'TestEnhancement' on call node leave enhancement},
+        %r{Indexing error in file:///fake/path/foo\.rb with 'TestEnhancement' on call node leave enhancement},
         stderr,
       )
       # The module should still be indexed