ruby-lsp 0.17.11 → 0.17.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13815c41a1b7509782277cb5dac09481130e18efc4253a01cede31ca41b335a7
-  data.tar.gz: 40e6584ff6ff743ea1e62a29d6090d80bf318ae3dd5d90808de1b35723bea063
+  metadata.gz: 34cae8b53cfb0811cb26d3b3dd4198a72585d1f15a98a7d8f656fd1676886630
+  data.tar.gz: f4868222c46c4cbad9a099fce69562838b5dda567f1666a82752f45fe3f501c5
 SHA512:
-  metadata.gz: 74da4b254b598cd4b10701b65c49d045cc33be83330399e67602f8e43597c9e54567715343a67fa720b31084de540e498cc3d5525e64679500d52b4842e44cf7
-  data.tar.gz: 313695187e34ceb34c50d320bbe0abe0bda18d99157e8f4710faf8f72bc5028abd813511665fd4eac274dd73606eebb1c901b949fa307a8f925c2bfaa39b0c45
+  metadata.gz: db8e991497aa6e9388b2778fb9a417adbef07c6bb29165ff9a1718ab7cf1db6d2a6586453320d72adf0cffe78b846b553c3a0ba24b63807c52170f02f1b7d2e3
+  data.tar.gz: 80aac045ca6aaf7dbb9344f947a9b1419eaac4711448d997c902f0fb9da68e7c2338e0a5b1d81a30c0a2609defe1b656457d1a4a23b0ba5288162d142cf7c9e9

data/VERSION

@@ -1 +1 @@
-0.17.11
+0.17.12

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

@@ -8,12 +8,22 @@ module RubyIndexer
     OBJECT_NESTING = T.let(["Object"].freeze, T::Array[String])
     BASIC_OBJECT_NESTING = T.let(["BasicObject"].freeze, T::Array[String])
 
+    sig { returns(T::Array[String]) }
+    attr_reader :indexing_errors
+
     sig do
-      params(index: Index, dispatcher: Prism::Dispatcher, parse_result: Prism::ParseResult, file_path: String).void
+      params(
+        index: Index,
+        dispatcher: Prism::Dispatcher,
+        parse_result: Prism::ParseResult,
+        file_path: String,
+        enhancements: T::Array[Enhancement],
+      ).void
     end
-    def initialize(index, dispatcher, parse_result, file_path)
+    def initialize(index, dispatcher, parse_result, file_path, enhancements: [])
       @index = index
       @file_path = file_path
+      @enhancements = enhancements
       @visibility_stack = T.let([Entry::Visibility::PUBLIC], T::Array[Entry::Visibility])
       @comments_by_line = T.let(
         parse_result.comments.to_h do |c|
@@ -29,6 +39,7 @@ module RubyIndexer
 
       # A stack of namespace entries that represent where we currently are. Used to properly assign methods to an owner
       @owner_stack = T.let([], T::Array[Entry::Namespace])
+      @indexing_errors = T.let([], T::Array[String])
 
       dispatcher.register(
         self,
@@ -279,6 +290,12 @@ module RubyIndexer
       when :private
         @visibility_stack.push(Entry::Visibility::PRIVATE)
       end
+
+      @enhancements.each do |enhancement|
+        enhancement.on_call_node(@index, @owner_stack.last, node, @file_path)
+      rescue StandardError => e
+        @indexing_errors << "Indexing error in #{@file_path} with '#{enhancement.class.name}' enhancement: #{e.message}"
+      end
     end
 
     sig { params(node: Prism::CallNode).void }

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

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyIndexer
+  module Enhancement
+    extend T::Sig
+    extend T::Helpers
+
+    interface!
+
+    requires_ancestor { Object }
+
+    # 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
+      abstract.params(
+        index: Index,
+        owner: T.nilable(Entry::Namespace),
+        node: Prism::CallNode,
+        file_path: String,
+      ).void
+    end
+    def on_call_node(index, owner, node, file_path); end
+  end
+end

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -342,6 +342,19 @@ module RubyIndexer
 
         "(#{first_signature.format})"
       end
+
+      sig { returns(String) }
+      def formatted_signatures
+        overloads_count = signatures.size
+        case overloads_count
+        when 1
+          ""
+        when 2
+          "\n(+1 overload)"
+        else
+          "\n(+#{overloads_count - 1} overloads)"
+        end
+      end
     end
 
     class Accessor < Member
@@ -542,6 +555,16 @@ module RubyIndexer
       def decorated_parameters
         @target.decorated_parameters
       end
+
+      sig { returns(String) }
+      def formatted_signatures
+        @target.formatted_signatures
+      end
+
+      sig { returns(T::Array[Signature]) }
+      def signatures
+        @target.signatures
+      end
     end
 
     # Ruby doesn't support method overloading, so a method will have only one signature.

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

@@ -35,6 +35,27 @@ 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(
+        {},
+        T::Hash[String, T::Array[T.proc.params(index: Index, base: Entry::Namespace).void]],
+      )
+    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)
+      (@included_hooks[module_name] ||= []) << hook
     end
 
     sig { params(indexable: IndexablePath).void }
@@ -296,11 +317,25 @@ module RubyIndexer
       dispatcher = Prism::Dispatcher.new
 
       result = Prism.parse(content)
-      DeclarationListener.new(self, dispatcher, result, indexable_path.full_path)
+      listener = DeclarationListener.new(
+        self,
+        dispatcher,
+        result,
+        indexable_path.full_path,
+        enhancements: @enhancements,
+      )
       dispatcher.dispatch(result.value)
 
+      indexing_errors = listener.indexing_errors.uniq
+
       require_path = indexable_path.require_path
       @require_paths_tree.insert(require_path, indexable_path) if require_path
+
+      if indexing_errors.any?
+        indexing_errors.each do |error|
+          $stderr.puts error
+        end
+      end
     rescue Errno::EISDIR, Errno::ENOENT
       # If `path` is a directory, just ignore it and continue indexing. If the file doesn't exist, then we also ignore
       # it
@@ -457,6 +492,12 @@ module RubyIndexer
         end
       end
 
+      # We only need to run included hooks when linearizing singleton classes. Included hooks are typically used to add
+      # new singleton methods or to extend a module through an include. There's no need to support instance methods, the
+      # inclusion of another module or the prepending of another module, because those features are already a part of
+      # Ruby and can be used directly without any metaprogramming
+      run_included_hooks(attached_class_name, nesting) if singleton_levels > 0
+
       linearize_mixins(ancestors, namespaces, nesting)
       linearize_superclass(
         ancestors,
@@ -570,6 +611,34 @@ module RubyIndexer
 
     private
 
+    # Runs the registered included hooks
+    sig { params(fully_qualified_name: String, nesting: T::Array[String]).void }
+    def run_included_hooks(fully_qualified_name, nesting)
+      return if @included_hooks.empty?
+
+      namespaces = self[fully_qualified_name]&.grep(Entry::Namespace)
+      return unless namespaces
+
+      namespaces.each do |namespace|
+        namespace.mixin_operations.each do |operation|
+          next unless operation.is_a?(Entry::Include)
+
+          # First we resolve the include name, so that we know the actual module being referred to in the include
+          resolved_modules = resolve(operation.module_name, nesting)
+          next unless resolved_modules
+
+          module_name = T.must(resolved_modules.first).name
+
+          # Then we grab any hooks registered for that module
+          hooks = @included_hooks[module_name]
+          next unless hooks
+
+          # We invoke the hooks with the index and the namespace that included the module
+          hooks.each { |hook| hook.call(self, namespace) }
+        end
+      end
+    end
+
     # Linearize mixins for an array of namespace entries. This method will mutate the `ancestors` array with the
     # linearized ancestors of the mixins
     sig do

data/lib/ruby_indexer/ruby_indexer.rb

@@ -6,6 +6,7 @@ require "did_you_mean"
 
 require "ruby_indexer/lib/ruby_indexer/indexable_path"
 require "ruby_indexer/lib/ruby_indexer/declaration_listener"
+require "ruby_indexer/lib/ruby_indexer/enhancement"
 require "ruby_indexer/lib/ruby_indexer/index"
 require "ruby_indexer/lib/ruby_indexer/entry"
 require "ruby_indexer/lib/ruby_indexer/configuration"

data/lib/ruby_indexer/test/enhancements_test.rb

@@ -0,0 +1,197 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "test_case"
+
+module RubyIndexer
+  class EnhancementTest < TestCase
+    def test_enhancing_indexing_included_hook
+      enhancement_class = Class.new do
+        include Enhancement
+
+        def on_call_node(index, owner, node, file_path)
+          return unless owner
+          return unless node.name == :extend
+
+          arguments = node.arguments&.arguments
+          return unless arguments
+
+          location = node.location
+
+          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|
+              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
+
+            index.add(Entry::Method.new(
+              "new_method",
+              file_path,
+              location,
+              location,
+              [],
+              [Entry::Signature.new([Entry::RequiredParameter.new(name: :a)])],
+              Entry::Visibility::PUBLIC,
+              owner,
+            ))
+          rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
+                 Prism::ConstantPathNode::MissingNodesInConstantPathError
+            # Do nothing
+          end
+        end
+      end
+
+      @index.register_enhancement(enhancement_class.new)
+      index(<<~RUBY)
+        module ActiveSupport
+          module Concern
+            def self.extended(base)
+              base.class_eval("def new_method(a); end")
+            end
+          end
+        end
+
+        module ActiveRecord
+          module Associations
+            extend ActiveSupport::Concern
+
+            module ClassMethods
+              def belongs_to(something); end
+            end
+          end
+
+          class Base
+            include Associations
+          end
+        end
+
+        class User < ActiveRecord::Base
+        end
+      RUBY
+
+      assert_equal(
+        [
+          "User::<Class:User>",
+          "ActiveRecord::Base::<Class:Base>",
+          "ActiveRecord::Associations::ClassMethods",
+          "Object::<Class:Object>",
+          "BasicObject::<Class:BasicObject>",
+          "Class",
+          "Module",
+          "Object",
+          "Kernel",
+          "BasicObject",
+        ],
+        @index.linearized_ancestors_of("User::<Class:User>"),
+      )
+
+      assert_entry("new_method", Entry::Method, "/fake/path/foo.rb:10-4:10-33")
+    end
+
+    def test_enhancing_indexing_configuration_dsl
+      enhancement_class = Class.new do
+        include Enhancement
+
+        def on_call_node(index, owner, node, file_path)
+          return unless owner
+
+          name = node.name
+          return unless name == :has_many
+
+          arguments = node.arguments&.arguments
+          return unless arguments
+
+          association_name = arguments.first
+          return unless association_name.is_a?(Prism::SymbolNode)
+
+          location = association_name.location
+
+          index.add(Entry::Method.new(
+            T.must(association_name.value),
+            file_path,
+            location,
+            location,
+            [],
+            [],
+            Entry::Visibility::PUBLIC,
+            owner,
+          ))
+        end
+      end
+
+      @index.register_enhancement(enhancement_class.new)
+      index(<<~RUBY)
+        module ActiveSupport
+          module Concern
+            def self.extended(base)
+              base.class_eval("def new_method(a); end")
+            end
+          end
+        end
+
+        module ActiveRecord
+          module Associations
+            extend ActiveSupport::Concern
+
+            module ClassMethods
+              def belongs_to(something); end
+            end
+          end
+
+          class Base
+            include Associations
+          end
+        end
+
+        class User < ActiveRecord::Base
+          has_many :posts
+        end
+      RUBY
+
+      assert_entry("posts", Entry::Method, "/fake/path/foo.rb:23-11:23-17")
+    end
+
+    def test_error_handling_in_enhancement
+      enhancement_class = Class.new do
+        include Enhancement
+
+        def on_call_node(index, owner, node, file_path)
+          raise "Error"
+        end
+
+        class << self
+          def name
+            "TestEnhancement"
+          end
+        end
+      end
+
+      @index.register_enhancement(enhancement_class.new)
+
+      _stdout, stderr = capture_io do
+        index(<<~RUBY)
+          module ActiveSupport
+            module Concern
+              def self.extended(base)
+                base.class_eval("def new_method(a); end")
+              end
+            end
+          end
+        RUBY
+      end
+
+      assert_match(%r{Indexing error in /fake/path/foo\.rb with 'TestEnhancement' enhancement}, stderr)
+      # The module should still be indexed
+      assert_entry("ActiveSupport::Concern", Entry::Module, "/fake/path/foo.rb:1-2:5-5")
+    end
+  end
+end

data/lib/ruby_lsp/document.rb

@@ -223,6 +223,40 @@ module RubyLsp
       NodeContext.new(closest, parent, nesting_nodes, call_node)
     end
 
+    sig do
+      params(
+        range: T::Hash[Symbol, T.untyped],
+        node_types: T::Array[T.class_of(Prism::Node)],
+      ).returns(T.nilable(Prism::Node))
+    end
+    def locate_first_within_range(range, node_types: [])
+      scanner = create_scanner
+      start_position = scanner.find_char_position(range[:start])
+      end_position = scanner.find_char_position(range[:end])
+      desired_range = (start_position...end_position)
+      queue = T.let(@parse_result.value.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
+
+      until queue.empty?
+        candidate = queue.shift
+
+        # Skip nil child nodes
+        next if candidate.nil?
+
+        # Add the next child_nodes to the queue to be processed. The order here is important! We want to move in the
+        # same order as the visiting mechanism, which means searching the child nodes before moving on to the next
+        # sibling
+        T.unsafe(queue).unshift(*candidate.child_nodes)
+
+        # Skip if the current node doesn't cover the desired position
+        loc = candidate.location
+
+        if desired_range.cover?(loc.start_offset...loc.end_offset) &&
+            (node_types.empty? || node_types.any? { |type| candidate.class == type })
+          return candidate
+        end
+      end
+    end
+
     sig { returns(SorbetLevel) }
     def sorbet_level
       sigil = parse_result.magic_comments.find do |comment|

data/lib/ruby_lsp/listeners/hover.rb

@@ -174,7 +174,10 @@ module RubyLsp
         methods = @index.resolve_method(message, type.name, inherited_only: inherited_only)
         return unless methods
 
-        title = "#{message}#{T.must(methods.first).decorated_parameters}"
+        first_method = T.must(methods.first)
+
+        title = "#{message}#{first_method.decorated_parameters}"
+        title << first_method.formatted_signatures
 
         if type.is_a?(TypeInferrer::GuessedType)
           title << "\n\nGuessed receiver: #{type.name}"

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -23,6 +23,8 @@ module RubyLsp
     #
     class CodeActionResolve < Request
       extend T::Sig
+      include Support::Common
+
       NEW_VARIABLE_NAME = "new_variable"
       NEW_METHOD_NAME = "new_method"
 
@@ -45,20 +47,62 @@ module RubyLsp
 
       sig { override.returns(T.any(Interface::CodeAction, Error)) }
       def perform
+        return Error::EmptySelection if @document.source.empty?
+
         case @code_action[:title]
         when CodeActions::EXTRACT_TO_VARIABLE_TITLE
           refactor_variable
         when CodeActions::EXTRACT_TO_METHOD_TITLE
           refactor_method
+        when CodeActions::SWITCH_BLOCK_STYLE_TITLE
+          switch_block_style
         else
           Error::UnknownCodeAction
         end
       end
 
+      private
+
       sig { returns(T.any(Interface::CodeAction, Error)) }
-      def refactor_variable
-        return Error::EmptySelection if @document.source.empty?
+      def switch_block_style
+        source_range = @code_action.dig(:data, :range)
+        return Error::EmptySelection if source_range[:start] == source_range[:end]
+
+        target = @document.locate_first_within_range(
+          @code_action.dig(:data, :range),
+          node_types: [Prism::CallNode],
+        )
+
+        return Error::InvalidTargetRange unless target.is_a?(Prism::CallNode)
+
+        node = target.block
+        return Error::InvalidTargetRange unless node.is_a?(Prism::BlockNode)
 
+        indentation = " " * target.location.start_column unless node.opening_loc.slice == "do"
+
+        Interface::CodeAction.new(
+          title: CodeActions::SWITCH_BLOCK_STYLE_TITLE,
+          edit: Interface::WorkspaceEdit.new(
+            document_changes: [
+              Interface::TextDocumentEdit.new(
+                text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: @code_action.dig(:data, :uri),
+                  version: nil,
+                ),
+                edits: [
+                  Interface::TextEdit.new(
+                    range: range_from_location(node.location),
+                    new_text: recursively_switch_nested_block_styles(node, indentation),
+                  ),
+                ],
+              ),
+            ],
+          ),
+        )
+      end
+
+      sig { returns(T.any(Interface::CodeAction, Error)) }
+      def refactor_variable
         source_range = @code_action.dig(:data, :range)
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
@@ -153,8 +197,6 @@ module RubyLsp
 
       sig { returns(T.any(Interface::CodeAction, Error)) }
       def refactor_method
-        return Error::EmptySelection if @document.source.empty?
-
         source_range = @code_action.dig(:data, :range)
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
@@ -206,8 +248,6 @@ module RubyLsp
         )
       end
 
-      private
-
       sig { params(range: T::Hash[Symbol, T.untyped], new_text: String).returns(Interface::TextEdit) }
       def create_text_edit(range, new_text)
         Interface::TextEdit.new(
@@ -218,6 +258,64 @@ module RubyLsp
           new_text: new_text,
         )
       end
+
+      sig { params(node: Prism::BlockNode, indentation: T.nilable(String)).returns(String) }
+      def recursively_switch_nested_block_styles(node, indentation)
+        parameters = node.parameters
+        body = node.body
+
+        # We use the indentation to differentiate between do...end and brace style blocks because only the do...end
+        # style requires the indentation to build the edit.
+        #
+        # If the block is using `do...end` style, we change it to a single line brace block. Newlines are turned into
+        # semi colons, so that the result is valid Ruby code and still a one liner. If the block is using brace style,
+        # we do the opposite and turn it into a `do...end` block, making all semi colons into newlines.
+        source = +""
+
+        if indentation
+          source << "do"
+          source << " #{parameters.slice}" if parameters
+          source << "\n#{indentation}  "
+          source << switch_block_body(body, indentation) if body
+          source << "\n#{indentation}end"
+        else
+          source << "{ "
+          source << "#{parameters.slice} " if parameters
+          source << switch_block_body(body, nil) if body
+          source << "}"
+        end
+
+        source
+      end
+
+      sig { params(body: Prism::Node, indentation: T.nilable(String)).returns(String) }
+      def switch_block_body(body, indentation)
+        # Check if there are any nested blocks inside of the current block
+        body_loc = body.location
+        nested_block = @document.locate_first_within_range(
+          {
+            start: { line: body_loc.start_line - 1, character: body_loc.start_column },
+            end: { line: body_loc.end_line - 1, character: body_loc.end_column },
+          },
+          node_types: [Prism::BlockNode],
+        )
+
+        body_content = body.slice.dup
+
+        # If there are nested blocks, then we change their style too and we have to mutate the string using the
+        # relative position in respect to the beginning of the body
+        if nested_block.is_a?(Prism::BlockNode)
+          location = nested_block.location
+          correction_start = location.start_offset - body_loc.start_offset
+          correction_end = location.end_offset - body_loc.start_offset
+          next_indentation = indentation ? "#{indentation}  " : nil
+
+          body_content[correction_start...correction_end] =
+            recursively_switch_nested_block_styles(nested_block, next_indentation)
+        end
+
+        indentation ? body_content.gsub(";", "\n") : "#{body_content.gsub("\n", ";")} "
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/code_actions.rb

@@ -21,6 +21,7 @@ module RubyLsp
 
       EXTRACT_TO_VARIABLE_TITLE = "Refactor: Extract Variable"
       EXTRACT_TO_METHOD_TITLE = "Refactor: Extract Method"
+      SWITCH_BLOCK_STYLE_TITLE = "Refactor: Switch block style"
 
       class << self
         extend T::Sig
@@ -69,6 +70,11 @@ module RubyLsp
             kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
             data: { range: @range, uri: @uri.to_s },
           )
+          code_actions << Interface::CodeAction.new(
+            title: SWITCH_BLOCK_STYLE_TITLE,
+            kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+            data: { range: @range, uri: @uri.to_s },
+          )
         end
 
         code_actions

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -63,6 +63,7 @@ module RubyLsp
 
         if first_entry.is_a?(RubyIndexer::Entry::Member)
           label = +"#{label}#{first_entry.decorated_parameters}"
+          label << first_entry.formatted_signatures
         end
 
         guessed_type = @item.dig(:data, :guessed_type)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.17.11
+  version: 0.17.12
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-02 00:00:00.000000000 Z
+date: 2024-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -98,6 +98,7 @@ files:
 - lib/ruby-lsp.rb
 - lib/ruby_indexer/lib/ruby_indexer/configuration.rb
 - lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb
+- lib/ruby_indexer/lib/ruby_indexer/enhancement.rb
 - lib/ruby_indexer/lib/ruby_indexer/entry.rb
 - lib/ruby_indexer/lib/ruby_indexer/index.rb
 - lib/ruby_indexer/lib/ruby_indexer/indexable_path.rb
@@ -108,6 +109,7 @@ files:
 - lib/ruby_indexer/test/classes_and_modules_test.rb
 - lib/ruby_indexer/test/configuration_test.rb
 - lib/ruby_indexer/test/constant_test.rb
+- lib/ruby_indexer/test/enhancements_test.rb
 - lib/ruby_indexer/test/index_test.rb
 - lib/ruby_indexer/test/instance_variables_test.rb
 - lib/ruby_indexer/test/method_test.rb