ruby-lsp 0.26.2 → 0.26.9

data/lib/ruby_lsp/global_state.rb

@@ -2,6 +2,21 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  # Holds the detected value and the reason for detection
+  class DetectionResult
+    #: String
+    attr_reader :value
+
+    #: String
+    attr_reader :reason
+
+    #: (String value, String reason) -> void
+    def initialize(value, reason)
+      @value = value
+      @reason = reason
+    end
+  end
+
   class GlobalState
     #: String
     attr_reader :test_library
@@ -122,8 +137,11 @@ module RubyLsp
       end
 
       if @formatter == "auto"
-        @formatter = detect_formatter(direct_dependencies, all_dependencies)
-        notifications << Notification.window_log_message("Auto detected formatter: #{@formatter}")
+        formatter_result = detect_formatter(direct_dependencies, all_dependencies)
+        @formatter = formatter_result.value
+        notifications << Notification.window_log_message(
+          "Auto detected formatter: #{@formatter} (#{formatter_result.reason})",
+        )
       end
 
       specified_linters = options.dig(:initializationOptions, :linters)
@@ -144,21 +162,28 @@ module RubyLsp
         specified_linters << "rubocop_internal"
       end
 
-      @linters = specified_linters || detect_linters(direct_dependencies, all_dependencies)
-
-      notifications << if specified_linters
-        Notification.window_log_message("Using linters specified by user: #{@linters.join(", ")}")
+      if specified_linters
+        @linters = specified_linters
+        notifications << Notification.window_log_message("Using linters specified by user: #{@linters.join(", ")}")
       else
-        Notification.window_log_message("Auto detected linters: #{@linters.join(", ")}")
+        linter_results = detect_linters(direct_dependencies, all_dependencies)
+        @linters = linter_results.map(&:value)
+        linter_messages = linter_results.map { |r| "#{r.value} (#{r.reason})" }
+        notifications << Notification.window_log_message("Auto detected linters: #{linter_messages.join(", ")}")
       end
 
-      @test_library = detect_test_library(direct_dependencies)
-      notifications << Notification.window_log_message("Detected test library: #{@test_library}")
+      test_library_result = detect_test_library(direct_dependencies)
+      @test_library = test_library_result.value
+      notifications << Notification.window_log_message(
+        "Detected test library: #{@test_library} (#{test_library_result.reason})",
+      )
 
-      @has_type_checker = detect_typechecker(all_dependencies)
-      if @has_type_checker
+      typechecker_result = detect_typechecker(all_dependencies)
+      @has_type_checker = !typechecker_result.nil?
+      if typechecker_result
         notifications << Notification.window_log_message(
-          "Ruby LSP detected this is a Sorbet project and will defer to the Sorbet LSP for some functionality",
+          "Ruby LSP detected this is a Sorbet project (#{typechecker_result.reason}) and will defer to the " \
+            "Sorbet LSP for some functionality",
         )
       end
 
@@ -228,60 +253,67 @@ module RubyLsp
 
     private
 
-    #: (Array[String] direct_dependencies, Array[String] all_dependencies) -> String
+    #: (Array[String] direct_dependencies, Array[String] all_dependencies) -> DetectionResult
     def detect_formatter(direct_dependencies, all_dependencies)
       # NOTE: Intentionally no $ at end, since we want to match rubocop-shopify, etc.
-      return "rubocop_internal" if direct_dependencies.any?(/^rubocop/)
+      if direct_dependencies.any?(/^rubocop/)
+        return DetectionResult.new("rubocop_internal", "direct dependency matching /^rubocop/")
+      end
 
-      syntax_tree_is_direct_dependency = direct_dependencies.include?("syntax_tree")
-      return "syntax_tree" if syntax_tree_is_direct_dependency
+      if direct_dependencies.include?("syntax_tree")
+        return DetectionResult.new("syntax_tree", "direct dependency")
+      end
 
-      rubocop_is_transitive_dependency = all_dependencies.include?("rubocop")
-      return "rubocop_internal" if dot_rubocop_yml_present && rubocop_is_transitive_dependency
+      if all_dependencies.include?("rubocop") && dot_rubocop_yml_present
+        return DetectionResult.new("rubocop_internal", "transitive dependency with .rubocop.yml present")
+      end
 
-      "none"
+      DetectionResult.new("none", "no formatter detected")
     end
 
     # Try to detect if there are linters in the project's dependencies. For auto-detection, we always only consider a
     # single linter. To have multiple linters running, the user must configure them manually
-    #: (Array[String] dependencies, Array[String] all_dependencies) -> Array[String]
+    #: (Array[String] dependencies, Array[String] all_dependencies) -> Array[DetectionResult]
     def detect_linters(dependencies, all_dependencies)
-      linters = []
+      linters = [] #: Array[DetectionResult]
 
-      if dependencies.any?(/^rubocop/) || (all_dependencies.include?("rubocop") && dot_rubocop_yml_present)
-        linters << "rubocop_internal"
+      if dependencies.any?(/^rubocop/)
+        linters << DetectionResult.new("rubocop_internal", "direct dependency matching /^rubocop/")
+      elsif all_dependencies.include?("rubocop") && dot_rubocop_yml_present
+        linters << DetectionResult.new("rubocop_internal", "transitive dependency with .rubocop.yml present")
       end
 
       linters
     end
 
-    #: (Array[String] dependencies) -> String
+    #: (Array[String] dependencies) -> DetectionResult
     def detect_test_library(dependencies)
       if dependencies.any?(/^rspec/)
-        "rspec"
+        DetectionResult.new("rspec", "direct dependency matching /^rspec/")
       # A Rails app may have a dependency on minitest, but we would instead want to use the Rails test runner provided
       # by ruby-lsp-rails. A Rails app doesn't need to depend on the rails gem itself, individual components like
       # activestorage may be added to the gemfile so that other components aren't downloaded. Check for the presence
       #  of bin/rails to support these cases.
       elsif bin_rails_present
-        "rails"
+        DetectionResult.new("rails", "bin/rails present")
       # NOTE: Intentionally ends with $ to avoid mis-matching minitest-reporters, etc. in a Rails app.
       elsif dependencies.any?(/^minitest$/)
-        "minitest"
+        DetectionResult.new("minitest", "direct dependency matching /^minitest$/")
       elsif dependencies.any?(/^test-unit/)
-        "test-unit"
+        DetectionResult.new("test-unit", "direct dependency matching /^test-unit/")
       else
-        "unknown"
+        DetectionResult.new("unknown", "no test library detected")
       end
     end
 
-    #: (Array[String] dependencies) -> bool
+    #: (Array[String] dependencies) -> DetectionResult?
     def detect_typechecker(dependencies)
-      return false if ENV["RUBY_LSP_BYPASS_TYPECHECKER"]
+      return if ENV["RUBY_LSP_BYPASS_TYPECHECKER"]
+      return if dependencies.none?(/^sorbet-static/)
 
-      dependencies.any?(/^sorbet-static/)
+      DetectionResult.new("sorbet", "sorbet-static in dependencies")
     rescue Bundler::GemfileNotFound
-      false
+      nil
     end
 
     #: -> bool

data/lib/ruby_lsp/listeners/definition.rb

@@ -71,24 +71,26 @@ module RubyLsp
 
       #: (Prism::StringNode node) -> 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)
+        with_enclosing_call(node) do |enclosing_call, name|
+          case name
+          when :require, :require_relative
+            handle_require_definition(node, name)
+          when :send, :public_send
+            handle_send_or_public_send_definition(enclosing_call, node) { node.content }
+          end
+        end
       end
 
       #: (Prism::SymbolNode node) -> void
       def on_symbol_node_enter(node)
-        enclosing_call = @node_context.call_node
-        return unless enclosing_call
-
-        name = enclosing_call.name
-        return unless name == :autoload
-
-        handle_autoload_definition(enclosing_call)
+        with_enclosing_call(node) do |enclosing_call, name|
+          case name
+          when :autoload
+            handle_autoload_definition(enclosing_call)
+          when :send, :public_send
+            handle_send_or_public_send_definition(enclosing_call, node) { node.unescaped }
+          end
+        end
       end
 
       #: (Prism::BlockArgumentNode node) -> void
@@ -220,6 +222,24 @@ module RubyLsp
 
       private
 
+      #: (Prism::Node node) { (Prism::CallNode, Symbol) -> void } -> void
+      def with_enclosing_call(node, &block)
+        enclosing_call = @node_context.call_node
+        return unless enclosing_call
+
+        block.call(enclosing_call, enclosing_call.name)
+      end
+
+      #: (Prism::CallNode enclosing_call, Prism::Node node) { -> String } -> void
+      def handle_send_or_public_send_definition(enclosing_call, node, &block)
+        first_argument = enclosing_call.arguments&.arguments&.first
+        return unless first_argument.eql?(node)
+
+        method_name = block.call
+
+        handle_method_definition(method_name, nil)
+      end
+
       #: -> void
       def handle_super_node_definition
         # Sorbet can handle super hover on typed true or higher

data/lib/ruby_lsp/listeners/document_link.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "ruby_lsp/requests/support/source_uri"
+require "ruby_lsp/requests/support/package_url"
 
 module RubyLsp
   module Listeners
@@ -59,6 +60,7 @@ module RubyLsp
         @lines_to_comments = comments.to_h do |comment|
           [comment.location.end_line, comment]
         end #: Hash[Integer, Prism::Comment]
+        @sig_comments = {} #: Hash[Integer, Prism::Comment]
 
         dispatcher.register(
           self,
@@ -67,9 +69,20 @@ module RubyLsp
           :on_module_node_enter,
           :on_constant_write_node_enter,
           :on_constant_path_write_node_enter,
+          :on_call_node_enter,
         )
       end
 
+      #: (Prism::CallNode node) -> void
+      def on_call_node_enter(node)
+        return unless node.name == :sig
+
+        comment = @lines_to_comments[node.location.start_line - 1]
+        return unless comment
+
+        @sig_comments[node.location.end_line] = comment
+      end
+
       #: (Prism::DefNode node) -> void
       def on_def_node_enter(node)
         extract_document_link(node)
@@ -99,55 +112,81 @@ module RubyLsp
 
       #: (Prism::Node node) -> void
       def extract_document_link(node)
-        comment = @lines_to_comments[node.location.start_line - 1]
+        comment = @lines_to_comments[node.location.start_line - 1] || @sig_comments[node.location.start_line - 1]
         return unless comment
 
-        match = comment.location.slice.match(%r{source://.*#\d+$})
+        match = comment.location.slice.match(%r{(source://.*#\d+|pkg:gem/.*#.*)$})
         return unless match
 
-        uri =  begin
-          URI(
-            match[0], #: as !nil
-          )
+        uri_string = match[0] #: as !nil
+
+        file_path, line_number = if uri_string.start_with?("pkg:gem/")
+          parse_package_url(uri_string)
+        else
+          parse_source_uri(uri_string)
+        end
+
+        return unless file_path
+
+        @response_builder << Interface::DocumentLink.new(
+          range: range_from_location(comment.location),
+          target: "file://#{file_path}##{line_number}",
+          tooltip: "Jump to #{file_path}##{line_number}",
+        )
+      end
+
+      #: (String uri_string) -> [String, String]?
+      def parse_package_url(uri_string)
+        purl = PackageURL.parse(uri_string) #: as PackageURL?
+        return unless purl
+
+        gem_version = resolve_version(purl.version, purl.name)
+        return if gem_version.nil?
+
+        path, line_number = purl.subpath.split(":", 2)
+        return unless path
+
+        gem_name = purl.name
+        file_path = self.class.gem_paths.dig(gem_name, gem_version, CGI.unescape(path))
+        return if file_path.nil?
+
+        [file_path, line_number]
+      rescue PackageURL::InvalidPackageURL
+        nil
+      end
+
+      #: (String uri_string) -> [String, String]?
+      def parse_source_uri(uri_string)
+        uri = begin
+          URI(uri_string)
         rescue URI::Error
           nil
         end #: as URI::Source?
         return unless uri
 
-        gem_version = resolve_version(uri)
+        gem_version = resolve_version(uri.gem_version, uri.gem_name)
         return if gem_version.nil?
 
         path = uri.path
         return unless path
 
-        gem_name = uri.gem_name
-        return unless gem_name
-
-        file_path = self.class.gem_paths.dig(gem_name, gem_version, CGI.unescape(path))
+        file_path = self.class.gem_paths.dig(uri.gem_name, gem_version, CGI.unescape(path))
         return if file_path.nil?
 
-        @response_builder << Interface::DocumentLink.new(
-          range: range_from_location(comment.location),
-          target: "file://#{file_path}##{uri.line_number}",
-          tooltip: "Jump to #{file_path}##{uri.line_number}",
-        )
+        [file_path, uri.line_number || "0"]
       end
 
       # Try to figure out the gem version for a source:// link. The order of precedence is:
       # 1. The version in the URI
       # 2. The version in the RBI file name
       # 3. The version from the gemspec
-      #: (URI::Source uri) -> String?
-      def resolve_version(uri)
-        version = uri.gem_version
+      #: (String? version, String? gem_name) -> String?
+      def resolve_version(version, gem_name)
         return version unless version.nil? || version.empty?
 
         return @gem_version unless @gem_version.nil? || @gem_version.empty?
 
-        gem_name = uri.gem_name
-        return unless gem_name
-
-        GEM_TO_VERSION_MAP[gem_name]
+        GEM_TO_VERSION_MAP[gem_name.to_s]
       end
     end
   end

data/lib/ruby_lsp/listeners/hover.rb

@@ -283,10 +283,10 @@ module RubyLsp
         content = KEYWORD_DOCS[keyword]
         return unless content
 
-        doc_path = File.join(STATIC_DOCS_PATH, "#{keyword}.md")
+        doc_uri = URI::Generic.from_path(path: File.join(STATIC_DOCS_PATH, "#{keyword}.md"))
 
         @response_builder.push("```ruby\n#{keyword}\n```", category: :title)
-        @response_builder.push("[Read more](#{doc_path})", category: :links)
+        @response_builder.push("[Read more](#{doc_uri})", category: :links)
         @response_builder.push(content, category: :documentation)
       end
 

data/lib/ruby_lsp/listeners/semantic_highlighting.rb

@@ -94,7 +94,7 @@ module RubyLsp
 
       #: (Prism::MatchWriteNode node) -> void
       def on_match_write_node_leave(node)
-        @inside_regex_capture = true if node.call.message == "=~"
+        @inside_regex_capture = false if node.call.message == "=~"
       end
 
       #: (Prism::DefNode node) -> void
@@ -162,7 +162,7 @@ module RubyLsp
 
       #: (Prism::SelfNode node) -> void
       def on_self_node_enter(node)
-        @response_builder.add_token(node.location, :variable, [:default_library])
+        @response_builder.add_token(node.location, :variable, [:defaultLibrary])
       end
 
       #: (Prism::LocalVariableWriteNode node) -> void

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -51,20 +51,42 @@ module RubyLsp
       #: -> (Interface::CodeAction)
       def switch_block_style
         source_range = @code_action.dig(:data, :range)
-        raise EmptySelectionError, "Invalid selection for refactor" if source_range[:start] == source_range[:end]
+        if source_range[:start] == source_range[:end]
+          block_context = @document.locate_node(
+            source_range[:start],
+            node_types: [Prism::BlockNode],
+          )
+          node = block_context.node
+          unless node.is_a?(Prism::BlockNode)
+            raise InvalidTargetRangeError, "Cursor is not inside a block"
+          end
 
-        target = @document.locate_first_within_range(
-          @code_action.dig(:data, :range),
-          node_types: [Prism::CallNode],
-        )
+          # Find the call node at the block node's start position.
+          # This should be the call node whose block the cursor is inside of.
+          call_context = RubyDocument.locate(
+            @document.ast,
+            node.location.cached_start_code_units_offset(@document.code_units_cache),
+            node_types: [Prism::CallNode],
+            code_units_cache: @document.code_units_cache,
+          )
+          target = call_context.node
+          unless target.is_a?(Prism::CallNode) && target.block == node
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
+        else
+          target = @document.locate_first_within_range(
+            @code_action.dig(:data, :range),
+            node_types: [Prism::CallNode],
+          )
 
-        unless target.is_a?(Prism::CallNode)
-          raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
-        end
+          unless target.is_a?(Prism::CallNode)
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
 
-        node = target.block
-        unless node.is_a?(Prism::BlockNode)
-          raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          node = target.block
+          unless node.is_a?(Prism::BlockNode)
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
         end
 
         indentation = " " * target.location.start_column unless node.opening_loc.slice == "do"

data/lib/ruby_lsp/requests/code_actions.rb

@@ -63,12 +63,8 @@ module RubyLsp
             kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
             data: { range: @range, uri: @uri.to_s },
           )
-          code_actions << Interface::CodeAction.new(
-            title: TOGGLE_BLOCK_STYLE_TITLE,
-            kind: Constant::CodeActionKind::REFACTOR_REWRITE,
-            data: { range: @range, uri: @uri.to_s },
-          )
         end
+        code_actions.concat(toggle_block_style_action)
         code_actions.concat(attribute_actions)
 
         code_actions
@@ -113,6 +109,25 @@ module RubyLsp
           ),
         ]
       end
+
+      #: -> Array[Interface::CodeAction]
+      def toggle_block_style_action
+        if @range[:start] == @range[:end]
+          block_context = @document.locate_node(
+            @range[:start],
+            node_types: [Prism::BlockNode],
+          )
+          return [] unless block_context.node.is_a?(Prism::BlockNode)
+        end
+
+        [
+          Interface::CodeAction.new(
+            title: TOGGLE_BLOCK_STYLE_TITLE,
+            kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+            data: { range: @range, uri: @uri.to_s },
+          ),
+        ]
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -68,10 +68,12 @@ module RubyLsp
           "[Learn more about guessed types](#{GUESSED_TYPES_URL})"
         end
 
-        @item[:documentation] = Interface::MarkupContent.new(
-          kind: "markdown",
-          value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES, extra_links: extra_links),
-        )
+        unless @item[:kind] == Constant::CompletionItemKind::FILE
+          @item[:documentation] = Interface::MarkupContent.new(
+            kind: "markdown",
+            value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES, extra_links: extra_links),
+          )
+        end
 
         @item
       end
@@ -84,7 +86,7 @@ module RubyLsp
         content = KEYWORD_DOCS[keyword]
 
         if content
-          doc_path = File.join(STATIC_DOCS_PATH, "#{keyword}.md")
+          doc_uri = URI::Generic.from_path(path: File.join(STATIC_DOCS_PATH, "#{keyword}.md"))
 
           @item[:documentation] = Interface::MarkupContent.new(
             kind: "markdown",
@@ -93,7 +95,7 @@ module RubyLsp
               #{keyword}
               ```
 
-              [Read more](#{doc_path})
+              [Read more](#{doc_uri})
 
               #{content}
             MARKDOWN