ruby-lsp 0.17.1 → 0.17.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61194ff211ddd14d6598752e0a60409c16c2c5460c4d007ac1e1bc7e56b50116
-  data.tar.gz: 29ed28f4392929f09a4ba4ea6a19612f9dfc3e2c0b2641c551627ac69a32b3c0
+  metadata.gz: 595a062d747f467d33b204523cfc6173b450f1b570616888b292109d0390a980
+  data.tar.gz: 97d1ed5a7a69521c427207a971684054eb7d35ddb6cd9e315e5fdb470c01d4d8
 SHA512:
-  metadata.gz: 56420391d81fe9e9c06a7fda2a04b1f99ac6fbb10211f064bfd65f36dd9148658d47743be437eb40240d5522786ec0566d0cea763b964630fb5ea67fe552687b
-  data.tar.gz: f760fad5d7abf0d0071badf6dd04f82e2266a64b0122d3a08cd5c3c799be15e377c94da93a4e8164e1f6ae04350e5ca05b16afbb7a8e341a8e80590053728ed7
+  metadata.gz: 445852ced0242742544611c8ee39574eb09ca33f1a2b9b27ce53c8c33514256716313db4723ce7ce0a8e2ad6bd29ee47c75f68afc65150c243cbf1a0254dad2e
+  data.tar.gz: cb462f49c28c52ff92fa392790e030f3bdac3efeacfab865bf5892cb0b62494f7ee7c46c61a8e667867ed06f9abcd037786054e49567f982c974cd777da82551

data/VERSION

@@ -1 +1 @@
-0.17.1
+0.17.2

data/lib/ruby_lsp/document.rb

@@ -128,6 +128,7 @@ module RubyLsp
       closest = node
       parent = T.let(nil, T.nilable(Prism::Node))
       nesting = T.let([], T::Array[T.any(Prism::ClassNode, Prism::ModuleNode)])
+      call_node = T.let(nil, T.nilable(Prism::CallNode))
 
       until queue.empty?
         candidate = queue.shift
@@ -159,6 +160,15 @@ module RubyLsp
           nesting << candidate
         end
 
+        if candidate.is_a?(Prism::CallNode)
+          arg_loc = candidate.arguments&.location
+          blk_loc = candidate.block&.location
+          if (arg_loc && (arg_loc.start_offset...arg_loc.end_offset).cover?(char_position)) ||
+              (blk_loc && (blk_loc.start_offset...blk_loc.end_offset).cover?(char_position))
+            call_node = candidate
+          end
+        end
+
         # If there are node types to filter by, and the current node is not one of those types, then skip it
         next if node_types.any? && node_types.none? { |type| candidate.class == type }
 
@@ -170,7 +180,20 @@ module RubyLsp
         end
       end
 
-      NodeContext.new(closest, parent, nesting.map { |n| n.constant_path.location.slice })
+      # When targeting the constant part of a class/module definition, we do not want the nesting to be duplicated. That
+      # is, when targeting Bar in the following example:
+      #
+      # ```ruby
+      #   class Foo::Bar; end
+      # ```
+      # The correct target is `Foo::Bar` with an empty nesting. `Foo::Bar` should not appear in the nesting stack, even
+      # though the class/module node does indeed enclose the target, because it would lead to incorrect behavior
+      if closest.is_a?(Prism::ConstantReadNode) || closest.is_a?(Prism::ConstantPathNode)
+        last_level = nesting.last
+        nesting.pop if last_level && last_level.constant_path == closest
+      end
+
+      NodeContext.new(closest, parent, nesting.map { |n| n.constant_path.location.slice }, call_node)
     end
 
     sig { returns(T::Boolean) }

data/lib/ruby_lsp/listeners/definition.rb

@@ -39,18 +39,27 @@ module RubyLsp
           :on_instance_variable_operator_write_node_enter,
           :on_instance_variable_or_write_node_enter,
           :on_instance_variable_target_node_enter,
+          :on_string_node_enter,
         )
       end
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
-        message = node.name
+        message = node.message
+        return unless message
 
-        if message == :require || message == :require_relative
-          handle_require_definition(node)
-        else
-          handle_method_definition(message.to_s, self_receiver?(node))
-        end
+        handle_method_definition(message, self_receiver?(node))
+      end
+
+      sig { params(node: Prism::StringNode).void }
+      def on_string_node_enter(node)
+        enclosing_call = @node_context.call_node
+        return unless enclosing_call
+
+        name = enclosing_call.name
+        return unless name == :require || name == :require_relative
+
+        handle_require_definition(node, name)
       end
 
       sig { params(node: Prism::BlockArgumentNode).void }
@@ -159,19 +168,12 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::CallNode).void }
-      def handle_require_definition(node)
-        message = node.name
-        arguments = node.arguments
-        return unless arguments
-
-        argument = arguments.arguments.first
-        return unless argument.is_a?(Prism::StringNode)
-
+      sig { params(node: Prism::StringNode, message: Symbol).void }
+      def handle_require_definition(node, message)
         case message
         when :require
-          entry = @index.search_require_paths(argument.content).find do |indexable_path|
-            indexable_path.require_path == argument.content
+          entry = @index.search_require_paths(node.content).find do |indexable_path|
+            indexable_path.require_path == node.content
           end
 
           if entry
@@ -186,7 +188,7 @@ module RubyLsp
             )
           end
         when :require_relative
-          required_file = "#{argument.content}.rb"
+          required_file = "#{node.content}.rb"
           path = @uri.to_standardized_path
           current_folder = path ? Pathname.new(CGI.unescape(path)).dirname : Dir.pwd
           candidate = File.expand_path(File.join(current_folder, required_file))

data/lib/ruby_lsp/listeners/hover.rb

@@ -19,6 +19,8 @@ module RubyLsp
           Prism::InstanceVariableOrWriteNode,
           Prism::InstanceVariableTargetNode,
           Prism::InstanceVariableWriteNode,
+          Prism::SymbolNode,
+          Prism::StringNode,
         ],
         T::Array[T.class_of(Prism::Node)],
       )

data/lib/ruby_lsp/node_context.rb

@@ -2,8 +2,8 @@
 # frozen_string_literal: true
 
 module RubyLsp
-  # This class allows listeners to access contextual information about a node in the AST, such as its parent
-  # and its namespace nesting.
+  # This class allows listeners to access contextual information about a node in the AST, such as its parent,
+  # its namespace nesting, and the surrounding CallNode (e.g. a method call).
   class NodeContext
     extend T::Sig
 
@@ -13,11 +13,22 @@ module RubyLsp
     sig { returns(T::Array[String]) }
     attr_reader :nesting
 
-    sig { params(node: T.nilable(Prism::Node), parent: T.nilable(Prism::Node), nesting: T::Array[String]).void }
-    def initialize(node, parent, nesting)
+    sig { returns(T.nilable(Prism::CallNode)) }
+    attr_reader :call_node
+
+    sig do
+      params(
+        node: T.nilable(Prism::Node),
+        parent: T.nilable(Prism::Node),
+        nesting: T::Array[String],
+        call_node: T.nilable(Prism::CallNode),
+      ).void
+    end
+    def initialize(node, parent, nesting, call_node)
       @node = node
       @parent = parent
       @nesting = nesting
+      @call_node = call_node
     end
 
     sig { returns(String) }

data/lib/ruby_lsp/requests/definition.rb

@@ -60,6 +60,8 @@ module RubyLsp
             Prism::InstanceVariableOrWriteNode,
             Prism::InstanceVariableTargetNode,
             Prism::InstanceVariableWriteNode,
+            Prism::SymbolNode,
+            Prism::StringNode,
           ],
         )
 
@@ -79,6 +81,9 @@ module RubyLsp
           # If the target is a method call, we need to ensure that the requested position is exactly on top of the
           # method identifier. Otherwise, we risk showing definitions for unrelated things
           target = nil
+        # For methods with block arguments using symbol-to-proc
+        elsif target.is_a?(Prism::SymbolNode) && parent.is_a?(Prism::BlockArgumentNode)
+          target = parent
         end
 
         if target

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

@@ -19,6 +19,16 @@ module RubyLsp
           T::Hash[Symbol, Integer],
         )
 
+        ENHANCED_DOC_URL = T.let(
+          begin
+            gem("rubocop", ">= 1.64.0")
+            true
+          rescue LoadError
+            false
+          end,
+          T::Boolean,
+        )
+
         # TODO: avoid passing document once we have alternative ways to get at
         # encoding and file source
         sig { params(document: Document, offense: RuboCop::Cop::Offense, uri: URI::Generic).void }
@@ -38,8 +48,8 @@ module RubyLsp
           code_actions
         end
 
-        sig { returns(Interface::Diagnostic) }
-        def to_lsp_diagnostic
+        sig { params(config: RuboCop::Config).returns(Interface::Diagnostic) }
+        def to_lsp_diagnostic(config)
           # highlighted_area contains the begin and end position of the first line
           # This ensures that multiline offenses don't clutter the editor
           highlighted = @offense.highlighted_area
@@ -47,7 +57,7 @@ module RubyLsp
             message: message,
             source: "RuboCop",
             code: @offense.cop_name,
-            code_description: code_description,
+            code_description: code_description(config),
             severity: severity,
             range: Interface::Range.new(
               start: Interface::Position.new(
@@ -80,9 +90,16 @@ module RubyLsp
           RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
         end
 
-        sig { returns(T.nilable(Interface::CodeDescription)) }
-        def code_description
-          doc_url = RuboCopRunner.find_cop_by_name(@offense.cop_name)&.documentation_url
+        sig { params(config: RuboCop::Config).returns(T.nilable(Interface::CodeDescription)) }
+        def code_description(config)
+          cop = RuboCopRunner.find_cop_by_name(@offense.cop_name)
+          return unless cop
+
+          doc_url = if ENHANCED_DOC_URL
+            cop.documentation_url(config)
+          else
+            cop.documentation_url
+          end
           Interface::CodeDescription.new(href: doc_url) if doc_url
         end
 

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

@@ -38,7 +38,11 @@ module RubyLsp
           @diagnostic_runner.run(filename, document.source)
 
           @diagnostic_runner.offenses.map do |offense|
-            Support::RuboCopDiagnostic.new(document, offense, uri).to_lsp_diagnostic
+            Support::RuboCopDiagnostic.new(
+              document,
+              offense,
+              uri,
+            ).to_lsp_diagnostic(@diagnostic_runner.config_for_working_directory)
           end
         end
       end

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

@@ -50,6 +50,9 @@ module RubyLsp
         sig { returns(T::Array[RuboCop::Cop::Offense]) }
         attr_reader :offenses
 
+        sig { returns(::RuboCop::Config) }
+        attr_reader :config_for_working_directory
+
         DEFAULT_ARGS = T.let(
           [
             "--stderr", # Print any output to stderr so that our stdout does not get polluted
@@ -78,6 +81,7 @@ module RubyLsp
           args += DEFAULT_ARGS
           rubocop_options = ::RuboCop::Options.new.parse(args).first
           config_store = ::RuboCop::ConfigStore.new
+          @config_for_working_directory = T.let(config_store.for_pwd, ::RuboCop::Config)
 
           super(rubocop_options, config_store)
         end

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -33,10 +33,11 @@ module RubyLsp
       sig { override.returns(T::Array[Interface::WorkspaceSymbol]) }
       def perform
         @index.fuzzy_search(@query).filter_map do |entry|
-          # If the project is using Sorbet, we let Sorbet handle symbols defined inside the project itself and RBIs, but
-          # we still return entries defined in gems to allow developers to jump directly to the source
           file_path = entry.file_path
-          next if @global_state.typechecker && not_in_dependencies?(file_path)
+
+          # We only show symbols declared in the workspace
+          in_dependencies = !not_in_dependencies?(file_path)
+          next if in_dependencies
 
           # We should never show private symbols when searching the entire workspace
           next if entry.private?

data/lib/ruby_lsp/server.rb

@@ -175,7 +175,7 @@ module RubyLsp
           completion_provider: completion_provider,
           code_lens_provider: code_lens_provider,
           definition_provider: enabled_features["definition"],
-          workspace_symbol_provider: enabled_features["workspaceSymbol"],
+          workspace_symbol_provider: enabled_features["workspaceSymbol"] && !@global_state.typechecker,
           signature_help_provider: signature_help_provider,
         ),
         serverInfo: {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.17.1
+  version: 0.17.2
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-05-31 00:00:00.000000000 Z
+date: 2024-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -180,7 +180,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.10
+rubygems_version: 3.5.11
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby