ruby-lsp 0.21.3 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f580352765054aabd1821330dab6fa4ce5fb65746dee3a96640589a511a047f0
-  data.tar.gz: 41b51b6a3c13116b64a116f50337df14624088d8c50b2d5675c753b0ae612220
+  metadata.gz: e48cef95e466e2a75943921fc08ede1a449e07096e44078ca063bdbee6d3c54b
+  data.tar.gz: c0ce6a0636645674e9e9a87219124b622b1280420c14c4bd12f8f0f0aafc3f32
 SHA512:
-  metadata.gz: 6801b771e4aec3f493211f8b50c5c6e2998cd7d2ff1061bbc8e7afb83c87e653fcf7dfd23c3b41ec2fa65cd1d1eec3fab840a9188936904c08c6f2745c12c5a8
-  data.tar.gz: 9b68fee2853275c1343fa2815c6fe4263e6c90277b5e6567dfb84d4e0dd9d112353d77f18055384d9cb9aeb6a263ce8ec1b4b66f8b1eb2950f800aedf73fba3a
+  metadata.gz: 89d02237ecce7e784bb5275ba4d5fc30b64981ea337b078f3117037b98d8f734e0d7e6266078e76023125dd52bbcb6ded8d04fdac1c29eb8292fd29e401cece4
+  data.tar.gz: 7245d82a481bd9e6a56d0cce9ad03796bd1a6d9e770beb5632fcaf7669ab0af9e9c0c95f0b671d844231af718add21b98011665ac3355fab5647ab12378b60bf

data/VERSION

@@ -1 +1 @@
-0.21.3
+0.22.0

data/exe/ruby-lsp

@@ -54,7 +54,7 @@ rescue OptionParser::InvalidOption => e
   exit(1)
 end
 
-# When we're running without bundler, then we need to make sure the custom bundle is fully configured and re-execute
+# When we're running without bundler, then we need to make sure the composed bundle is fully configured and re-execute
 # using `BUNDLE_GEMFILE=.ruby-lsp/Gemfile bundle exec ruby-lsp` so that we have access to the gems that are a part of
 # the application's bundle
 if ENV["BUNDLE_GEMFILE"].nil?

data/exe/ruby-lsp-launcher

@@ -74,9 +74,6 @@ rescue StandardError => e
   # If Bundler.setup fails, we need to restore the original $LOAD_PATH so that we can still require the Ruby LSP server
   # in degraded mode
   $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
-ensure
-  require "fileutils"
-  FileUtils.rm(bundle_env_path) if File.exist?(bundle_env_path)
 end
 
 error_path = File.join(".ruby-lsp", "install_error")

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -109,6 +109,12 @@ module RubyIndexer
 
       indexables = T.let([], T::Array[IndexablePath])
 
+      # Handle top level files separately. The path below is an optimization to prevent descending down directories that
+      # are going to be excluded anyway, so we need to handle top level scripts separately
+      Dir.glob(File.join(@workspace_path, "*.rb"), flags).each do |path|
+        indexables << IndexablePath.new(nil, path)
+      end
+
       # Add user specified patterns
       @included_patterns.each do |pattern|
         load_path_entry = T.let(nil, T.nilable(String))

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -18,13 +18,12 @@ module RubyIndexer
         parse_result: Prism::ParseResult,
         file_path: String,
         collect_comments: T::Boolean,
-        enhancements: T::Array[Enhancement],
       ).void
     end
-    def initialize(index, dispatcher, parse_result, file_path, collect_comments: false, enhancements: [])
+    def initialize(index, dispatcher, parse_result, file_path, collect_comments: false)
       @index = index
       @file_path = file_path
-      @enhancements = enhancements
+      @enhancements = T.let(Enhancement.all(self), T::Array[Enhancement])
       @visibility_stack = T.let([Entry::Visibility::PUBLIC], T::Array[Entry::Visibility])
       @comments_by_line = T.let(
         parse_result.comments.to_h do |c|
@@ -37,6 +36,7 @@ module RubyIndexer
         parse_result.code_units_cache(@index.configuration.encoding),
         T.any(T.proc.params(arg0: Integer).returns(Integer), Prism::CodeUnitsCache),
       )
+      @source_lines = T.let(parse_result.source.lines, T::Array[String])
 
       # The nesting stack we're currently inside. Used to determine the fully qualified name of constants, but only
       # stored by unresolved aliases which need the original nesting to be lazily resolved
@@ -85,15 +85,9 @@ module RubyIndexer
 
     sig { params(node: Prism::ClassNode).void }
     def on_class_node_enter(node)
-      @visibility_stack.push(Entry::Visibility::PUBLIC)
       constant_path = node.constant_path
-      name = constant_path.slice
-
-      comments = collect_comments(node)
-
       superclass = node.superclass
-
-      nesting = actual_nesting(name)
+      nesting = actual_nesting(constant_path.slice)
 
       parent_class = case superclass
       when Prism::ConstantReadNode, Prism::ConstantPathNode
@@ -112,53 +106,29 @@ module RubyIndexer
         end
       end
 
-      entry = Entry::Class.new(
+      add_class(
         nesting,
-        @file_path,
-        Location.from_prism_location(node.location, @code_units_cache),
-        Location.from_prism_location(constant_path.location, @code_units_cache),
-        comments,
-        parent_class,
+        node.location,
+        constant_path.location,
+        parent_class_name: parent_class,
+        comments: collect_comments(node),
       )
-
-      @owner_stack << entry
-      @index.add(entry)
-      @stack << name
     end
 
     sig { params(node: Prism::ClassNode).void }
     def on_class_node_leave(node)
-      @stack.pop
-      @owner_stack.pop
-      @visibility_stack.pop
+      pop_namespace_stack
     end
 
     sig { params(node: Prism::ModuleNode).void }
     def on_module_node_enter(node)
-      @visibility_stack.push(Entry::Visibility::PUBLIC)
       constant_path = node.constant_path
-      name = constant_path.slice
-
-      comments = collect_comments(node)
-
-      entry = Entry::Module.new(
-        actual_nesting(name),
-        @file_path,
-        Location.from_prism_location(node.location, @code_units_cache),
-        Location.from_prism_location(constant_path.location, @code_units_cache),
-        comments,
-      )
-
-      @owner_stack << entry
-      @index.add(entry)
-      @stack << name
+      add_module(constant_path.slice, node.location, constant_path.location, comments: collect_comments(node))
     end
 
     sig { params(node: Prism::ModuleNode).void }
     def on_module_node_leave(node)
-      @stack.pop
-      @owner_stack.pop
-      @visibility_stack.pop
+      pop_namespace_stack
     end
 
     sig { params(node: Prism::SingletonClassNode).void }
@@ -200,9 +170,7 @@ module RubyIndexer
 
     sig { params(node: Prism::SingletonClassNode).void }
     def on_singleton_class_node_leave(node)
-      @stack.pop
-      @owner_stack.pop
-      @visibility_stack.pop
+      pop_namespace_stack
     end
 
     sig { params(node: Prism::MultiWriteNode).void }
@@ -317,7 +285,7 @@ module RubyIndexer
       end
 
       @enhancements.each do |enhancement|
-        enhancement.on_call_node_enter(@owner_stack.last, node, @file_path, @code_units_cache)
+        enhancement.on_call_node_enter(node)
       rescue StandardError => e
         @indexing_errors << <<~MSG
           Indexing error in #{@file_path} with '#{enhancement.class.name}' on call node enter enhancement: #{e.message}
@@ -338,7 +306,7 @@ module RubyIndexer
       end
 
       @enhancements.each do |enhancement|
-        enhancement.on_call_node_leave(@owner_stack.last, node, @file_path, @code_units_cache)
+        enhancement.on_call_node_leave(node)
       rescue StandardError => e
         @indexing_errors << <<~MSG
           Indexing error in #{@file_path} with '#{enhancement.class.name}' on call node leave enhancement: #{e.message}
@@ -463,6 +431,98 @@ module RubyIndexer
       )
     end
 
+    sig do
+      params(
+        name: String,
+        node_location: Prism::Location,
+        signatures: T::Array[Entry::Signature],
+        visibility: Entry::Visibility,
+        comments: T.nilable(String),
+      ).void
+    end
+    def add_method(name, node_location, signatures, visibility: Entry::Visibility::PUBLIC, comments: nil)
+      location = Location.from_prism_location(node_location, @code_units_cache)
+
+      @index.add(Entry::Method.new(
+        name,
+        @file_path,
+        location,
+        location,
+        comments,
+        signatures,
+        visibility,
+        @owner_stack.last,
+      ))
+    end
+
+    sig do
+      params(
+        name: String,
+        full_location: Prism::Location,
+        name_location: Prism::Location,
+        comments: T.nilable(String),
+      ).void
+    end
+    def add_module(name, full_location, name_location, comments: nil)
+      location = Location.from_prism_location(full_location, @code_units_cache)
+      name_loc = Location.from_prism_location(name_location, @code_units_cache)
+
+      entry = Entry::Module.new(
+        actual_nesting(name),
+        @file_path,
+        location,
+        name_loc,
+        comments,
+      )
+
+      advance_namespace_stack(name, entry)
+    end
+
+    sig do
+      params(
+        name_or_nesting: T.any(String, T::Array[String]),
+        full_location: Prism::Location,
+        name_location: Prism::Location,
+        parent_class_name: T.nilable(String),
+        comments: T.nilable(String),
+      ).void
+    end
+    def add_class(name_or_nesting, full_location, name_location, parent_class_name: nil, comments: nil)
+      nesting = name_or_nesting.is_a?(Array) ? name_or_nesting : actual_nesting(name_or_nesting)
+      entry = Entry::Class.new(
+        nesting,
+        @file_path,
+        Location.from_prism_location(full_location, @code_units_cache),
+        Location.from_prism_location(name_location, @code_units_cache),
+        comments,
+        parent_class_name,
+      )
+
+      advance_namespace_stack(T.must(nesting.last), entry)
+    end
+
+    sig { params(block: T.proc.params(index: Index, base: Entry::Namespace).void).void }
+    def register_included_hook(&block)
+      owner = @owner_stack.last
+      return unless owner
+
+      @index.register_included_hook(owner.name) do |index, base|
+        block.call(index, base)
+      end
+    end
+
+    sig { void }
+    def pop_namespace_stack
+      @stack.pop
+      @owner_stack.pop
+      @visibility_stack.pop
+    end
+
+    sig { returns(T.nilable(Entry::Namespace)) }
+    def current_owner
+      @owner_stack.last
+    end
+
     private
 
     sig do
@@ -661,8 +721,7 @@ module RubyIndexer
       comments = +""
 
       start_line = node.location.start_line - 1
-      start_line -= 1 unless @comments_by_line.key?(start_line)
-
+      start_line -= 1 unless comment_exists_at?(start_line)
       start_line.downto(1) do |line|
         comment = @comments_by_line[line]
         break unless comment
@@ -683,6 +742,11 @@ module RubyIndexer
       comments
     end
 
+    sig { params(line: Integer).returns(T::Boolean) }
+    def comment_exists_at?(line)
+      @comments_by_line.key?(line) || !@source_lines[line - 1].to_s.strip.empty?
+    end
+
     sig { params(name: String).returns(String) }
     def fully_qualify_name(name)
       if @stack.empty? || name.start_with?("::")
@@ -746,16 +810,22 @@ module RubyIndexer
       return unless arguments
 
       arguments.each do |node|
-        next unless node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
-
-        case operation
-        when :include
-          owner.mixin_operations << Entry::Include.new(node.full_name)
-        when :prepend
-          owner.mixin_operations << Entry::Prepend.new(node.full_name)
-        when :extend
+        next unless node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode) ||
+          (node.is_a?(Prism::SelfNode) && operation == :extend)
+
+        if node.is_a?(Prism::SelfNode)
           singleton = @index.existing_or_new_singleton_class(owner.name)
-          singleton.mixin_operations << Entry::Include.new(node.full_name)
+          singleton.mixin_operations << Entry::Include.new(owner.name)
+        else
+          case operation
+          when :include
+            owner.mixin_operations << Entry::Include.new(node.full_name)
+          when :prepend
+            owner.mixin_operations << Entry::Prepend.new(node.full_name)
+          when :extend
+            singleton = @index.existing_or_new_singleton_class(owner.name)
+            singleton.mixin_operations << Entry::Include.new(node.full_name)
+          end
         end
       rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
              Prism::ConstantPathNode::MissingNodesInConstantPathError
@@ -910,5 +980,13 @@ module RubyIndexer
 
       corrected_nesting
     end
+
+    sig { params(short_name: String, entry: Entry::Namespace).void }
+    def advance_namespace_stack(short_name, entry)
+      @visibility_stack.push(Entry::Visibility::PUBLIC)
+      @owner_stack << entry
+      @index.add(entry)
+      @stack << short_name
+    end
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/enhancement.rb

@@ -8,38 +8,41 @@ module RubyIndexer
 
     abstract!
 
-    sig { params(index: Index).void }
-    def initialize(index)
-      @index = index
+    @enhancements = T.let([], T::Array[T::Class[Enhancement]])
+
+    class << self
+      extend T::Sig
+
+      sig { params(child: T::Class[Enhancement]).void }
+      def inherited(child)
+        @enhancements << child
+        super
+      end
+
+      sig { params(listener: DeclarationListener).returns(T::Array[Enhancement]) }
+      def all(listener)
+        @enhancements.map { |enhancement| enhancement.new(listener) }
+      end
+
+      # Only available for testing purposes
+      sig { void }
+      def clear
+        @enhancements.clear
+      end
+    end
+
+    sig { params(listener: DeclarationListener).void }
+    def initialize(listener)
+      @listener = listener
     end
 
     # The `on_extend` indexing enhancement is invoked whenever an extend is encountered in the code. It can be used to
     # register for an included callback, similar to what `ActiveSupport::Concern` does in order to auto-extend the
     # `ClassMethods` modules
-    sig do
-      overridable.params(
-        owner: T.nilable(Entry::Namespace),
-        node: Prism::CallNode,
-        file_path: String,
-        code_units_cache: T.any(
-          T.proc.params(arg0: Integer).returns(Integer),
-          Prism::CodeUnitsCache,
-        ),
-      ).void
-    end
-    def on_call_node_enter(owner, node, file_path, code_units_cache); end
-
-    sig do
-      overridable.params(
-        owner: T.nilable(Entry::Namespace),
-        node: Prism::CallNode,
-        file_path: String,
-        code_units_cache: T.any(
-          T.proc.params(arg0: Integer).returns(Integer),
-          Prism::CodeUnitsCache,
-        ),
-      ).void
-    end
-    def on_call_node_leave(owner, node, file_path, code_units_cache); end
+    sig { overridable.params(node: Prism::CallNode).void }
+    def on_call_node_enter(node); end # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+
+    sig { overridable.params(node: Prism::CallNode).void }
+    def on_call_node_leave(node); end # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -7,6 +7,7 @@ module RubyIndexer
 
     class UnresolvableAliasError < StandardError; end
     class NonExistingNamespaceError < StandardError; end
+    class IndexNotEmptyError < StandardError; end
 
     # The minimum Jaro-Winkler similarity score for an entry to be considered a match for a given fuzzy search query
     ENTRY_SIMILARITY_THRESHOLD = 0.7
@@ -39,9 +40,6 @@ module RubyIndexer
       # Holds the linearized ancestors list for every namespace
       @ancestors = T.let({}, T::Hash[String, T::Array[String]])
 
-      # List of classes that are enhancing the index
-      @enhancements = T.let([], T::Array[Enhancement])
-
       # Map of module name to included hooks that have to be executed when we include the given module
       @included_hooks = T.let(
         {},
@@ -51,12 +49,6 @@ module RubyIndexer
       @configuration = T.let(RubyIndexer::Configuration.new, Configuration)
     end
 
-    # Register an enhancement to the index. Enhancements must conform to the `Enhancement` interface
-    sig { params(enhancement: Enhancement).void }
-    def register_enhancement(enhancement)
-      @enhancements << enhancement
-    end
-
     # Register an included `hook` that will be executed when `module_name` is included into any namespace
     sig { params(module_name: String, hook: T.proc.params(index: Index, base: Entry::Namespace).void).void }
     def register_included_hook(module_name, &hook)
@@ -360,6 +352,15 @@ module RubyIndexer
       ).void
     end
     def index_all(indexable_paths: @configuration.indexables, &block)
+      # When troubleshooting an indexing issue, e.g. through irb, it's not obvious that `index_all` will augment the
+      # existing index values, meaning it may contain 'stale' entries. This check ensures that the user is aware of this
+      # behavior and can take appropriate action.
+      # binding.break
+      if @entries.any?
+        raise IndexNotEmptyError,
+          "The index is not empty. To prevent invalid entries, `index_all` can only be called once."
+      end
+
       RBSIndexer.new(self).index_ruby_core
       # Calculate how many paths are worth 1% of progress
       progress_step = (indexable_paths.length / 100.0).ceil
@@ -386,7 +387,6 @@ module RubyIndexer
         result,
         indexable_path.full_path,
         collect_comments: collect_comments,
-        enhancements: @enhancements,
       )
       dispatcher.dispatch(result.value)
 

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -302,10 +302,10 @@ module RubyIndexer
       RUBY
 
       b_const = @index["A::B"].first
-      assert_equal(Entry::Visibility::PRIVATE, b_const.visibility)
+      assert_predicate(b_const, :private?)
 
       c_const = @index["A::C"].first
-      assert_equal(Entry::Visibility::PRIVATE, c_const.visibility)
+      assert_predicate(c_const, :private?)
 
       d_const = @index["A::D"].first
       assert_equal(Entry::Visibility::PUBLIC, d_const.visibility)

data/lib/ruby_indexer/test/configuration_test.rb

@@ -160,5 +160,15 @@ module RubyIndexer
         )
       end
     end
+
+    def test_includes_top_level_files
+      Dir.mktmpdir do |dir|
+        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" })
+      end
+    end
   end
 end

data/lib/ruby_indexer/test/constant_test.rb

@@ -130,13 +130,13 @@ module RubyIndexer
       RUBY
 
       b_const = @index["A::B"].first
-      assert_equal(Entry::Visibility::PRIVATE, b_const.visibility)
+      assert_predicate(b_const, :private?)
 
       c_const = @index["A::C"].first
-      assert_equal(Entry::Visibility::PRIVATE, c_const.visibility)
+      assert_predicate(c_const, :private?)
 
       d_const = @index["A::D"].first
-      assert_equal(Entry::Visibility::PUBLIC, d_const.visibility)
+      assert_predicate(d_const, :public?)
     end
 
     def test_marking_constants_as_private_reopening_namespaces
@@ -163,13 +163,13 @@ module RubyIndexer
       RUBY
 
       a_const = @index["A::B::CONST_A"].first
-      assert_equal(Entry::Visibility::PRIVATE, a_const.visibility)
+      assert_predicate(a_const, :private?)
 
       b_const = @index["A::B::CONST_B"].first
-      assert_equal(Entry::Visibility::PRIVATE, b_const.visibility)
+      assert_predicate(b_const, :private?)
 
       c_const = @index["A::B::CONST_C"].first
-      assert_equal(Entry::Visibility::PRIVATE, c_const.visibility)
+      assert_predicate(c_const, :private?)
     end
 
     def test_marking_constants_as_private_with_receiver
@@ -187,10 +187,10 @@ module RubyIndexer
       RUBY
 
       a_const = @index["A::B::CONST_A"].first
-      assert_equal(Entry::Visibility::PRIVATE, a_const.visibility)
+      assert_predicate(a_const, :private?)
 
       b_const = @index["A::B::CONST_B"].first
-      assert_equal(Entry::Visibility::PRIVATE, b_const.visibility)
+      assert_predicate(b_const, :private?)
     end
 
     def test_indexing_constant_aliases

data/lib/ruby_indexer/test/enhancements_test.rb

@@ -5,24 +5,28 @@ require_relative "test_case"
 
 module RubyIndexer
   class EnhancementTest < TestCase
+    def teardown
+      super
+      Enhancement.clear
+    end
+
     def test_enhancing_indexing_included_hook
-      enhancement_class = Class.new(Enhancement) do
-        def on_call_node_enter(owner, node, file_path, code_units_cache)
+      Class.new(Enhancement) do
+        def on_call_node_enter(call_node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+          owner = @listener.current_owner
           return unless owner
-          return unless node.name == :extend
+          return unless call_node.name == :extend
 
-          arguments = node.arguments&.arguments
+          arguments = call_node.arguments&.arguments
           return unless arguments
 
-          location = Location.from_prism_location(node.location, code_units_cache)
-
           arguments.each do |node|
             next unless node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
 
             module_name = node.full_name
             next unless module_name == "ActiveSupport::Concern"
 
-            @index.register_included_hook(owner.name) do |index, base|
+            @listener.register_included_hook do |index, base|
               class_methods_name = "#{owner.name}::ClassMethods"
 
               if index.indexed?(class_methods_name)
@@ -31,16 +35,11 @@ module RubyIndexer
               end
             end
 
-            @index.add(Entry::Method.new(
+            @listener.add_method(
               "new_method",
-              file_path,
-              location,
-              location,
-              nil,
+              call_node.location,
               [Entry::Signature.new([Entry::RequiredParameter.new(name: :a)])],
-              Entry::Visibility::PUBLIC,
-              owner,
-            ))
+            )
           rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
                  Prism::ConstantPathNode::MissingNodesInConstantPathError
             # Do nothing
@@ -48,7 +47,6 @@ module RubyIndexer
         end
       end
 
-      @index.register_enhancement(enhancement_class.new(@index))
       index(<<~RUBY)
         module ActiveSupport
           module Concern
@@ -96,9 +94,9 @@ module RubyIndexer
     end
 
     def test_enhancing_indexing_configuration_dsl
-      enhancement_class = Class.new(Enhancement) do
-        def on_call_node_enter(owner, node, file_path, code_units_cache)
-          return unless owner
+      Class.new(Enhancement) do
+        def on_call_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+          return unless @listener.current_owner
 
           name = node.name
           return unless name == :has_many
@@ -109,22 +107,14 @@ module RubyIndexer
           association_name = arguments.first
           return unless association_name.is_a?(Prism::SymbolNode)
 
-          location = Location.from_prism_location(association_name.location, code_units_cache)
-
-          @index.add(Entry::Method.new(
+          @listener.add_method(
             T.must(association_name.value),
-            file_path,
-            location,
-            location,
-            nil,
+            association_name.location,
             [],
-            Entry::Visibility::PUBLIC,
-            owner,
-          ))
+          )
         end
       end
 
-      @index.register_enhancement(enhancement_class.new(@index))
       index(<<~RUBY)
         module ActiveSupport
           module Concern
@@ -157,8 +147,8 @@ module RubyIndexer
     end
 
     def test_error_handling_in_on_call_node_enter_enhancement
-      enhancement_class = Class.new(Enhancement) do
-        def on_call_node_enter(owner, node, file_path, code_units_cache)
+      Class.new(Enhancement) do
+        def on_call_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
           raise "Error"
         end
 
@@ -169,8 +159,6 @@ module RubyIndexer
         end
       end
 
-      @index.register_enhancement(enhancement_class.new(@index))
-
       _stdout, stderr = capture_io do
         index(<<~RUBY)
           module ActiveSupport
@@ -192,8 +180,8 @@ module RubyIndexer
     end
 
     def test_error_handling_in_on_call_node_leave_enhancement
-      enhancement_class = Class.new(Enhancement) do
-        def on_call_node_leave(owner, node, file_path, code_units_cache)
+      Class.new(Enhancement) do
+        def on_call_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
           raise "Error"
         end
 
@@ -204,8 +192,6 @@ module RubyIndexer
         end
       end
 
-      @index.register_enhancement(enhancement_class.new(@index))
-
       _stdout, stderr = capture_io do
         index(<<~RUBY)
           module ActiveSupport
@@ -225,5 +211,115 @@ module RubyIndexer
       # The module should still be indexed
       assert_entry("ActiveSupport::Concern", Entry::Module, "/fake/path/foo.rb:1-2:5-5")
     end
+
+    def test_advancing_namespace_stack_from_enhancement
+      Class.new(Enhancement) do
+        def on_call_node_enter(call_node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+          owner = @listener.current_owner
+          return unless owner
+
+          case call_node.name
+          when :class_methods
+            @listener.add_module("ClassMethods", call_node.location, call_node.location)
+          when :extend
+            arguments = call_node.arguments&.arguments
+            return unless arguments
+
+            arguments.each do |node|
+              next unless node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
+
+              module_name = node.full_name
+              next unless module_name == "ActiveSupport::Concern"
+
+              @listener.register_included_hook do |index, base|
+                class_methods_name = "#{owner.name}::ClassMethods"
+
+                if index.indexed?(class_methods_name)
+                  singleton = index.existing_or_new_singleton_class(base.name)
+                  singleton.mixin_operations << Entry::Include.new(class_methods_name)
+                end
+              end
+            end
+          end
+        end
+
+        def on_call_node_leave(call_node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+          return unless call_node.name == :class_methods
+
+          @listener.pop_namespace_stack
+        end
+      end
+
+      index(<<~RUBY)
+        module ActiveSupport
+          module Concern
+          end
+        end
+
+        module MyConcern
+          extend ActiveSupport::Concern
+
+          class_methods do
+            def foo; end
+          end
+        end
+
+        class User
+          include MyConcern
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "User::<Class:User>",
+          "MyConcern::ClassMethods",
+          "Object::<Class:Object>",
+          "BasicObject::<Class:BasicObject>",
+          "Class",
+          "Module",
+          "Object",
+          "Kernel",
+          "BasicObject",
+        ],
+        @index.linearized_ancestors_of("User::<Class:User>"),
+      )
+
+      refute_nil(@index.resolve_method("foo", "User::<Class:User>"))
+    end
+
+    def test_creating_anonymous_classes_from_enhancement
+      Class.new(Enhancement) do
+        def on_call_node_enter(call_node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+          case call_node.name
+          when :context
+            arguments = call_node.arguments&.arguments
+            first_argument = arguments&.first
+            return unless first_argument.is_a?(Prism::StringNode)
+
+            @listener.add_class(
+              "<RSpec:#{first_argument.content}>",
+              call_node.location,
+              first_argument.location,
+            )
+          when :subject
+            @listener.add_method("subject", call_node.location, [])
+          end
+        end
+
+        def on_call_node_leave(call_node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+          return unless call_node.name == :context
+
+          @listener.pop_namespace_stack
+        end
+      end
+
+      index(<<~RUBY)
+        context "does something" do
+          subject { call_whatever }
+        end
+      RUBY
+
+      refute_nil(@index.resolve_method("subject", "<RSpec:does something>"))
+    end
   end
 end

data/lib/ruby_indexer/test/index_test.rb

@@ -1672,6 +1672,38 @@ module RubyIndexer
       )
     end
 
+    def test_extend_self
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+        module Foo
+          def bar
+          end
+
+          extend self
+
+          def baz
+          end
+        end
+      RUBY
+
+      ["bar", "baz"].product(["Foo", "Foo::<Class:Foo>"]).each do |method, receiver|
+        entry = @index.resolve_method(method, receiver)&.first
+        refute_nil(entry)
+        assert_equal(method, T.must(entry).name)
+      end
+
+      assert_equal(
+        [
+          "Foo::<Class:Foo>",
+          "Foo",
+          "Module",
+          "Object",
+          "Kernel",
+          "BasicObject",
+        ],
+        @index.linearized_ancestors_of("Foo::<Class:Foo>"),
+      )
+    end
+
     def test_linearizing_singleton_ancestors
       @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
         module First
@@ -2023,5 +2055,12 @@ module RubyIndexer
         ),
       )
     end
+
+    def test_prevents_multiple_calls_to_index_all
+      # For this test class, `index_all` is already called once in `setup`.
+      assert_raises(Index::IndexNotEmptyError) do
+        @index.index_all
+      end
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -141,7 +141,7 @@ module RubyIndexer
         # The first entry points to the location of the module_function call
         assert_equal("Test", first_entry.owner.name)
         assert_instance_of(Entry::Module, first_entry.owner)
-        assert_equal(Entry::Visibility::PRIVATE, first_entry.visibility)
+        assert_predicate(first_entry, :private?)
         # The second entry points to the public singleton method
         assert_equal("Test::<Class:Test>", second_entry.owner.name)
         assert_instance_of(Entry::SingletonClass, second_entry.owner)
@@ -149,6 +149,39 @@ module RubyIndexer
       end
     end
 
+    def test_comments_documentation
+      index(<<~RUBY)
+        # Documentation for Foo
+
+        class Foo
+          # ####################
+          # Documentation for bar
+          # ####################
+          #
+          def bar
+          end
+
+          # test
+
+          # Documentation for baz
+          def baz; end
+          def ban; end
+        end
+      RUBY
+
+      foo_comment = @index["Foo"].first.comments
+      assert_equal("Documentation for Foo", foo_comment)
+
+      bar_comment = @index["bar"].first.comments
+      assert_equal("####################\nDocumentation for bar\n####################\n", bar_comment)
+
+      baz_comment = @index["baz"].first.comments
+      assert_equal("Documentation for baz", baz_comment)
+
+      ban_comment = @index["ban"].first.comments
+      assert_empty(ban_comment)
+    end
+
     def test_method_with_parameters
       index(<<~RUBY)
         class Foo

data/lib/ruby_lsp/global_state.rb

@@ -21,7 +21,7 @@ module RubyLsp
     attr_reader :encoding
 
     sig { returns(T::Boolean) }
-    attr_reader :experimental_features, :top_level_bundle
+    attr_reader :top_level_bundle
 
     sig { returns(TypeInferrer) }
     attr_reader :type_inferrer
@@ -40,7 +40,6 @@ module RubyLsp
       @has_type_checker = T.let(true, T::Boolean)
       @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
       @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
-      @experimental_features = T.let(false, T::Boolean)
       @type_inferrer = T.let(TypeInferrer.new(@index), TypeInferrer)
       @addon_settings = T.let({}, T::Hash[String, T.untyped])
       @top_level_bundle = T.let(
@@ -131,7 +130,6 @@ module RubyLsp
       end
       @index.configuration.encoding = @encoding
 
-      @experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
       @client_capabilities.apply_client_capabilities(options[:capabilities]) if options[:capabilities]
 
       addon_settings = options.dig(:initializationOptions, :addonSettings)

data/lib/ruby_lsp/internal.rb

@@ -21,6 +21,7 @@ require "prism"
 require "prism/visitor"
 require "language_server-protocol"
 require "rbs"
+require "fileutils"
 
 require "ruby-lsp"
 require "ruby_lsp/base_server"

data/lib/ruby_lsp/requests/definition.rb

@@ -118,6 +118,8 @@ module RubyLsp
           Prism::InstanceVariableWriteNode
 
           !covers_position?(target.name_loc, position)
+        when Prism::CallNode
+          !covers_position?(target.message_loc, position)
         else
           false
         end

data/lib/ruby_lsp/requests/hover.rb

@@ -103,6 +103,8 @@ module RubyLsp
           Prism::GlobalVariableOrWriteNode,
           Prism::GlobalVariableWriteNode
           !covers_position?(target.name_loc, position)
+        when Prism::CallNode
+          !covers_position?(target.message_loc, position)
         else
           false
         end

data/lib/ruby_lsp/requests/support/rubocop_runner.rb

@@ -15,6 +15,7 @@ rescue LoadError
   return
 end
 
+# Remember to update the version in the documentation (usage/dependency-compatibility section) if you change this
 # Ensure that RuboCop is at least version 1.4.0
 begin
   gem("rubocop", ">= 1.4.0")

data/lib/ruby_lsp/server.rb

@@ -216,6 +216,13 @@ module RubyLsp
         Hash.new(true)
       end
 
+      bundle_env_path = File.join(".ruby-lsp", "bundle_env")
+      bundle_env = if File.exist?(bundle_env_path)
+        env = File.readlines(bundle_env_path).to_h { |line| T.cast(line.chomp.split("=", 2), [String, String]) }
+        FileUtils.rm(bundle_env_path)
+        env
+      end
+
       document_symbol_provider = Requests::DocumentSymbol.provider if enabled_features["documentSymbols"]
       document_link_provider = Requests::DocumentLink.provider if enabled_features["documentLink"]
       code_lens_provider = Requests::CodeLens.provider if enabled_features["codeLens"]
@@ -269,6 +276,7 @@ module RubyLsp
         },
         formatter: @global_state.formatter,
         degraded_mode: !!(@install_error || @setup_error),
+        bundle_env: bundle_env,
       }
 
       send_message(Result.new(id: message[:id], response: response))
@@ -604,6 +612,11 @@ module RubyLsp
       # don't want to format it
       path = uri.to_standardized_path
       unless path.nil? || path.start_with?(@global_state.workspace_path)
+        send_log_message(<<~MESSAGE)
+          Ignoring formatting request for file outside of the workspace.
+          Workspace path was set by editor as #{@global_state.workspace_path}.
+          File path requested for formatting was #{path}
+        MESSAGE
         send_empty_response(message[:id])
         return
       end

data/lib/ruby_lsp/setup_bundler.rb

@@ -12,7 +12,7 @@ require "digest"
 require "time"
 require "uri"
 
-# This file is a script that will configure a custom bundle for the Ruby LSP. The custom bundle allows developers to use
+# This file is a script that will configure a composed bundle for the Ruby LSP. The composed bundle allows developers to use
 # the Ruby LSP without including the gem in their application's Gemfile while at the same time giving us access to the
 # exact locked versions of dependencies.
 
@@ -62,7 +62,7 @@ module RubyLsp
       @retry = T.let(false, T::Boolean)
     end
 
-    # Sets up the custom bundle and returns the `BUNDLE_GEMFILE`, `BUNDLE_PATH` and `BUNDLE_APP_CONFIG` that should be
+    # Sets up the composed bundle and returns the `BUNDLE_GEMFILE`, `BUNDLE_PATH` and `BUNDLE_APP_CONFIG` that should be
     # used for running the server
     sig { returns(T::Hash[String, String]) }
     def setup!
@@ -73,12 +73,12 @@ module RubyLsp
       ignore_file = @custom_dir + ".gitignore"
       ignore_file.write("*") unless ignore_file.exist?
 
-      # Do not set up a custom bundle if LSP dependencies are already in the Gemfile
+      # Do not set up a composed bundle if LSP dependencies are already in the Gemfile
       if @dependencies["ruby-lsp"] &&
           @dependencies["debug"] &&
           (@rails_app ? @dependencies["ruby-lsp-rails"] : true)
         $stderr.puts(
-          "Ruby LSP> Skipping custom bundle setup since LSP dependencies are already in #{@gemfile}",
+          "Ruby LSP> Skipping composed bundle setup since LSP dependencies are already in #{@gemfile}",
         )
 
         return run_bundle_install
@@ -96,7 +96,7 @@ module RubyLsp
 
       if @custom_lockfile.exist? && @lockfile_hash_path.exist? && @lockfile_hash_path.read == current_lockfile_hash
         $stderr.puts(
-          "Ruby LSP> Skipping custom bundle setup since #{@custom_lockfile} already exists and is up to date",
+          "Ruby LSP> Skipping composed bundle setup since #{@custom_lockfile} already exists and is up to date",
         )
         return run_bundle_install(@custom_gemfile)
       end
@@ -110,8 +110,8 @@ module RubyLsp
     private
 
     sig { returns(T::Hash[String, T.untyped]) }
-    def custom_bundle_dependencies
-      @custom_bundle_dependencies ||= T.let(
+    def composed_bundle_dependencies
+      @composed_bundle_dependencies ||= T.let(
         begin
           original_bundle_gemfile = ENV["BUNDLE_GEMFILE"]
 
@@ -136,8 +136,8 @@ module RubyLsp
         "",
       ]
 
-      # If there's a top level Gemfile, we want to evaluate from the custom bundle. We get the source from the top level
-      # Gemfile, so if there isn't one we need to add a default source
+      # If there's a top level Gemfile, we want to evaluate from the composed bundle. We get the source from the top
+      # level Gemfile, so if there isn't one we need to add a default source
       if @gemfile&.exist? && @lockfile&.exist?
         parts << "eval_gemfile(File.expand_path(\"../#{@gemfile_name}\", __dir__))"
       else
@@ -187,7 +187,7 @@ module RubyLsp
       env = bundler_settings_as_env
       env["BUNDLE_GEMFILE"] = bundle_gemfile.to_s
 
-      # If the user has a custom bundle path configured, we need to ensure that we will use the absolute and not
+      # If the user has a composed bundle path configured, we need to ensure that we will use the absolute and not
       # relative version of it when running `bundle install`. This is necessary to avoid installing the gems under the
       # `.ruby-lsp` folder, which is not the user's intention. For example, if the path is configured as `vendor`, we
       # want to install it in the top level `vendor` and not `.ruby-lsp/vendor`
@@ -244,7 +244,7 @@ module RubyLsp
       base_bundle = base_bundle_command(env)
 
       # If `ruby-lsp` and `debug` (and potentially `ruby-lsp-rails`) are already in the Gemfile, then we shouldn't try
-      # to upgrade them or else we'll produce undesired source control changes. If the custom bundle was just created
+      # to upgrade them or else we'll produce undesired source control changes. If the composed bundle was just created
       # and any of `ruby-lsp`, `ruby-lsp-rails` or `debug` weren't a part of the Gemfile, then we need to run `bundle
       # install` for the first time to generate the Gemfile.lock with them included or else Bundler will complain that
       # they're missing. We can only update if the custom `.ruby-lsp/Gemfile.lock` already exists and includes all gems
@@ -274,16 +274,16 @@ module RubyLsp
       command << "1>&2"
 
       # Add bundle update
-      $stderr.puts("Ruby LSP> Running bundle install for the custom bundle. This may take a while...")
+      $stderr.puts("Ruby LSP> Running bundle install for the composed bundle. This may take a while...")
       $stderr.puts("Ruby LSP> Command: #{command}")
 
-      # Try to run the bundle install or update command. If that fails, it normally means that the custom lockfile is in
-      # a bad state that no longer reflects the top level one. In that case, we can remove the whole directory, try
+      # Try to run the bundle install or update command. If that fails, it normally means that the composed lockfile is
+      # in a bad state that no longer reflects the top level one. In that case, we can remove the whole directory, try
       # another time and give up if it fails again
       if !system(env, command) && !@retry && @custom_gemfile.exist?
         @retry = true
         @custom_dir.rmtree
-        $stderr.puts("Ruby LSP> Running bundle install failed. Trying to re-generate the custom bundle from scratch")
+        $stderr.puts("Ruby LSP> Running bundle install failed. Trying to re-generate the composed bundle from scratch")
         return setup!
       end
 
@@ -330,14 +330,14 @@ module RubyLsp
       if @rails_app
         return false if @dependencies.values_at("ruby-lsp", "ruby-lsp-rails", "debug").all?
 
-        # If the custom lockfile doesn't include `ruby-lsp`, `ruby-lsp-rails` or `debug`, we need to run bundle install
-        # before updating
-        return false if custom_bundle_dependencies.values_at("ruby-lsp", "debug", "ruby-lsp-rails").any?(&:nil?)
+        # If the composed lockfile doesn't include `ruby-lsp`, `ruby-lsp-rails` or `debug`, we need to run bundle
+        # install before updating
+        return false if composed_bundle_dependencies.values_at("ruby-lsp", "debug", "ruby-lsp-rails").any?(&:nil?)
       else
         return false if @dependencies.values_at("ruby-lsp", "debug").all?
 
-        # If the custom lockfile doesn't include `ruby-lsp` or `debug`, we need to run bundle install before updating
-        return false if custom_bundle_dependencies.values_at("ruby-lsp", "debug").any?(&:nil?)
+        # If the composed lockfile doesn't include `ruby-lsp` or `debug`, we need to run bundle install before updating
+        return false if composed_bundle_dependencies.values_at("ruby-lsp", "debug").any?(&:nil?)
       end
 
       # If the last updated file doesn't exist or was updated more than 4 hours ago, we should update

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.21.3
+  version: 0.22.0
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-05 00:00:00.000000000 Z
+date: 2024-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -217,7 +217,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
+rubygems_version: 3.5.23
 signing_key:
 specification_version: 4
 summary: An opinionated language server for Ruby