ruby-lsp 0.13.4 → 0.14.1

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -2,13 +2,12 @@
 # frozen_string_literal: true
 
 require "shellwords"
-require_relative "../listener"
 
 module RubyLsp
   module Listeners
-    class CodeLens < Listener
+    class CodeLens
       extend T::Sig
-      extend T::Generic
+      include Requests::Support::Common
 
       BASE_COMMAND = T.let(
         begin
@@ -21,31 +20,25 @@ module RubyLsp
       )
       ACCESS_MODIFIERS = T.let([:public, :private, :protected], T::Array[Symbol])
       SUPPORTED_TEST_LIBRARIES = T.let(["minitest", "test-unit"], T::Array[String])
-
-      ResponseType = type_member { { fixed: T::Array[Interface::CodeLens] } }
-
-      sig { override.returns(ResponseType) }
-      attr_reader :_response
+      DESCRIBE_KEYWORD = T.let(:describe, Symbol)
+      IT_KEYWORD = T.let(:it, Symbol)
 
       sig do
         params(
+          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
           uri: URI::Generic,
-          lenses_configuration: RequestConfig,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(uri, lenses_configuration, dispatcher)
+      def initialize(response_builder, uri, dispatcher)
+        @response_builder = response_builder
         @uri = T.let(uri, URI::Generic)
-        @_response = T.let([], ResponseType)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         # visibility_stack is a stack of [current_visibility, previous_visibility]
         @visibility_stack = T.let([[:public, :public]], T::Array[T::Array[T.nilable(Symbol)]])
-        @class_stack = T.let([], T::Array[String])
+        @group_stack = T.let([], T::Array[String])
         @group_id = T.let(1, Integer)
         @group_id_stack = T.let([], T::Array[Integer])
-        @lenses_configuration = lenses_configuration
-
-        super(dispatcher)
 
         dispatcher.register(
           self,
@@ -61,13 +54,13 @@ module RubyLsp
       def on_class_node_enter(node)
         @visibility_stack.push([:public, :public])
         class_name = node.constant_path.slice
-        @class_stack.push(class_name)
+        @group_stack.push(class_name)
 
         if @path && class_name.end_with?("Test")
           add_test_code_lens(
             node,
             name: class_name,
-            command: generate_test_command(class_name: class_name),
+            command: generate_test_command(group_name: class_name),
             kind: :group,
           )
         end
@@ -79,13 +72,13 @@ module RubyLsp
       sig { params(node: Prism::ClassNode).void }
       def on_class_node_leave(node)
         @visibility_stack.pop
-        @class_stack.pop
+        @group_stack.pop
         @group_id_stack.pop
       end
 
       sig { params(node: Prism::DefNode).void }
       def on_def_node_enter(node)
-        class_name = @class_stack.last
+        class_name = @group_stack.last
         return unless class_name&.end_with?("Test")
 
         visibility, _ = @visibility_stack.last
@@ -95,7 +88,7 @@ module RubyLsp
             add_test_code_lens(
               node,
               name: method_name,
-              command: generate_test_command(method_name: method_name, class_name: class_name),
+              command: generate_test_command(method_name: method_name, group_name: class_name),
               kind: :example,
             )
           end
@@ -120,16 +113,15 @@ module RubyLsp
           return
         end
 
-        if @path&.include?(GEMFILE_NAME) && name == :gem && arguments
-          return unless @lenses_configuration.enabled?(:gemfileLinks)
-
-          first_argument = arguments.arguments.first
-          return unless first_argument.is_a?(Prism::StringNode)
-
-          remote = resolve_gem_remote(first_argument)
-          return unless remote
-
-          add_open_gem_remote_code_lens(node, remote)
+        if [DESCRIBE_KEYWORD, IT_KEYWORD].include?(name)
+          case name
+          when DESCRIBE_KEYWORD
+            add_spec_code_lens(node, kind: :group)
+            @group_id_stack.push(@group_id)
+            @group_id += 1
+          when IT_KEYWORD
+            add_spec_code_lens(node, kind: :example)
+          end
         end
       end
 
@@ -137,6 +129,9 @@ module RubyLsp
       def on_call_node_leave(node)
         _, prev_visibility = @visibility_stack.pop
         @visibility_stack.push([prev_visibility, prev_visibility])
+        if node.name == DESCRIBE_KEYWORD
+          @group_id_stack.pop
+        end
       end
 
       private
@@ -161,7 +156,7 @@ module RubyLsp
         grouping_data = { group_id: @group_id_stack.last, kind: kind }
         grouping_data[:id] = @group_id if kind == :group
 
-        @_response << create_code_lens(
+        @response_builder << create_code_lens(
           node,
           title: "Run",
           command_name: "rubyLsp.runTest",
@@ -169,7 +164,7 @@ module RubyLsp
           data: { type: "test", **grouping_data },
         )
 
-        @_response << create_code_lens(
+        @response_builder << create_code_lens(
           node,
           title: "Run In Terminal",
           command_name: "rubyLsp.runTestInTerminal",
@@ -177,7 +172,7 @@ module RubyLsp
           data: { type: "test_in_terminal", **grouping_data },
         )
 
-        @_response << create_code_lens(
+        @response_builder << create_code_lens(
           node,
           title: "Debug",
           command_name: "rubyLsp.debugTest",
@@ -186,29 +181,19 @@ module RubyLsp
         )
       end
 
-      sig { params(gem_name: Prism::StringNode).returns(T.nilable(String)) }
-      def resolve_gem_remote(gem_name)
-        spec = Gem::Specification.stubs.find { |gem| gem.name == gem_name.content }&.to_spec
-        return if spec.nil?
-
-        [spec.homepage, spec.metadata["source_code_uri"]].compact.find do |page|
-          page.start_with?("https://github.com", "https://gitlab.com")
-        end
-      end
-
-      sig { params(class_name: String, method_name: T.nilable(String)).returns(String) }
-      def generate_test_command(class_name:, method_name: nil)
+      sig { params(group_name: String, method_name: T.nilable(String)).returns(String) }
+      def generate_test_command(group_name:, method_name: nil)
         command = BASE_COMMAND + T.must(@path)
 
         case DependencyDetector.instance.detected_test_library
         when "minitest"
           command += if method_name
-            " --name " + "/#{Shellwords.escape(class_name + "#" + method_name)}/"
+            " --name " + "/#{Shellwords.escape(group_name + "#" + method_name)}/"
           else
-            " --name " + "/#{Shellwords.escape(class_name)}/"
+            " --name " + "/#{Shellwords.escape(group_name)}/"
           end
         when "test-unit"
-          command += " --testcase " + "/#{Shellwords.escape(class_name)}/"
+          command += " --testcase " + "/#{Shellwords.escape(group_name)}/"
 
           if method_name
             command += " --name " + Shellwords.escape(method_name)
@@ -218,14 +203,28 @@ module RubyLsp
         command
       end
 
-      sig { params(node: Prism::CallNode, remote: String).void }
-      def add_open_gem_remote_code_lens(node, remote)
-        @_response << create_code_lens(
+      sig { params(node: Prism::CallNode, kind: Symbol).void }
+      def add_spec_code_lens(node, kind:)
+        arguments = node.arguments
+        return unless arguments
+
+        first_argument = arguments.arguments.first
+        return unless first_argument
+
+        name = case first_argument
+        when Prism::StringNode
+          first_argument.content
+        when Prism::ConstantReadNode
+          first_argument.full_name
+        end
+
+        return unless name
+
+        add_test_code_lens(
           node,
-          title: "Open remote",
-          command_name: "rubyLsp.openLink",
-          arguments: [remote],
-          data: { type: "link" },
+          name: name,
+          command: generate_test_command(group_name: name),
+          kind: kind,
         )
       end
     end

data/lib/ruby_lsp/listeners/completion.rb

@@ -3,26 +3,21 @@
 
 module RubyLsp
   module Listeners
-    class Completion < Listener
+    class Completion
       extend T::Sig
-      extend T::Generic
-
-      ResponseType = type_member { { fixed: T::Array[Interface::CompletionItem] } }
-
-      sig { override.returns(ResponseType) }
-      attr_reader :_response
+      include Requests::Support::Common
 
       sig do
         params(
+          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
           index: RubyIndexer::Index,
           nesting: T::Array[String],
           typechecker_enabled: T::Boolean,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(index, nesting, typechecker_enabled, dispatcher)
-        super(dispatcher)
-        @_response = T.let([], ResponseType)
+      def initialize(response_builder, index, nesting, typechecker_enabled, dispatcher)
+        @response_builder = response_builder
         @index = index
         @nesting = nesting
         @typechecker_enabled = typechecker_enabled
@@ -39,7 +34,7 @@ module RubyLsp
       sig { params(node: Prism::StringNode).void }
       def on_string_node_enter(node)
         @index.search_require_paths(node.content).map!(&:require_path).sort!.each do |path|
-          @_response << build_completion(T.must(path), node)
+          @response_builder << build_completion(T.must(path), node)
         end
       end
 
@@ -48,11 +43,13 @@ module RubyLsp
       def on_constant_read_node_enter(node)
         return if DependencyDetector.instance.typechecker
 
-        name = node.slice
+        name = constant_name(node)
+        return if name.nil?
+
         candidates = @index.prefix_search(name, @nesting)
         candidates.each do |entries|
           complete_name = T.must(entries.first).name
-          @_response << build_entry_completion(
+          @response_builder << build_entry_completion(
             complete_name,
             name,
             node,
@@ -67,7 +64,8 @@ module RubyLsp
       def on_constant_path_node_enter(node)
         return if DependencyDetector.instance.typechecker
 
-        name = node.slice
+        name = constant_name(node)
+        return if name.nil?
 
         top_level_reference = if name.start_with?("::")
           name = name.delete_prefix("::")
@@ -96,7 +94,7 @@ module RubyLsp
 
           full_name = aliased_namespace.empty? ? constant_name : "#{aliased_namespace}::#{constant_name}"
 
-          @_response << build_entry_completion(
+          @response_builder << build_entry_completion(
             full_name,
             name,
             node,
@@ -123,7 +121,7 @@ module RubyLsp
           entry = entries.find { |e| e.is_a?(RubyIndexer::Entry::Member) && e.owner&.name == receiver.name }
           next unless entry
 
-          @_response << build_method_completion(T.cast(entry, RubyIndexer::Entry::Member), node)
+          @response_builder << build_method_completion(T.cast(entry, RubyIndexer::Entry::Member), node)
         end
       end
 
@@ -147,7 +145,10 @@ module RubyLsp
             detail: "(#{entry.parameters.map(&:decorated_name).join(", ")})",
             description: entry.file_name,
           ),
-          documentation: markdown_from_index_entries(name, entry),
+          documentation: Interface::MarkupContent.new(
+            kind: "markdown",
+            value: markdown_from_index_entries(name, entry),
+          ),
         )
       end
 
@@ -240,7 +241,10 @@ module RubyLsp
           label_details: Interface::CompletionItemLabelDetails.new(
             description: entries.map(&:file_name).join(","),
           ),
-          documentation: markdown_from_index_entries(real_name, entries),
+          documentation: Interface::MarkupContent.new(
+            kind: "markdown",
+            value: markdown_from_index_entries(real_name, entries),
+          ),
         )
       end
 

data/lib/ruby_lsp/listeners/definition.rb

@@ -3,17 +3,13 @@
 
 module RubyLsp
   module Listeners
-    class Definition < Listener
+    class Definition
       extend T::Sig
-      extend T::Generic
-
-      ResponseType = type_member { { fixed: T.nilable(T.any(T::Array[Interface::Location], Interface::Location)) } }
-
-      sig { override.returns(ResponseType) }
-      attr_reader :_response
+      include Requests::Support::Common
 
       sig do
         params(
+          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
           uri: URI::Generic,
           nesting: T::Array[String],
           index: RubyIndexer::Index,
@@ -21,14 +17,12 @@ module RubyLsp
           typechecker_enabled: T::Boolean,
         ).void
       end
-      def initialize(uri, nesting, index, dispatcher, typechecker_enabled)
+      def initialize(response_builder, uri, nesting, index, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
+        @response_builder = response_builder
         @uri = uri
         @nesting = nesting
         @index = index
         @typechecker_enabled = typechecker_enabled
-        @_response = T.let(nil, ResponseType)
-
-        super(dispatcher)
 
         dispatcher.register(
           self,
@@ -51,12 +45,18 @@ module RubyLsp
 
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
-        find_in_index(node.slice)
+        name = constant_name(node)
+        return if name.nil?
+
+        find_in_index(name)
       end
 
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
-        find_in_index(node.slice)
+        name = constant_name(node)
+        return if name.nil?
+
+        find_in_index(name)
       end
 
       private
@@ -68,20 +68,22 @@ module RubyLsp
         message = node.message
         return unless message
 
-        target_method = @index.resolve_method(message, @nesting.join("::"))
-        return unless target_method
+        methods = @index.resolve_method(message, @nesting.join("::"))
+        return unless methods
 
-        location = target_method.location
-        file_path = target_method.file_path
-        return if @typechecker_enabled && not_in_dependencies?(file_path)
+        methods.each do |target_method|
+          location = target_method.location
+          file_path = target_method.file_path
+          next if @typechecker_enabled && not_in_dependencies?(file_path)
 
-        @_response = Interface::Location.new(
-          uri: URI::Generic.from_path(path: file_path).to_s,
-          range: Interface::Range.new(
-            start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
-            end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
-          ),
-        )
+          @response_builder << Interface::Location.new(
+            uri: URI::Generic.from_path(path: file_path).to_s,
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
+              end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
+            ),
+          )
+        end
       end
 
       sig { params(node: Prism::CallNode).void }
@@ -102,7 +104,7 @@ module RubyLsp
           if entry
             candidate = entry.full_path
 
-            @_response = Interface::Location.new(
+            @response_builder << Interface::Location.new(
               uri: URI::Generic.from_path(path: candidate).to_s,
               range: Interface::Range.new(
                 start: Interface::Position.new(line: 0, character: 0),
@@ -116,7 +118,7 @@ module RubyLsp
           current_folder = path ? Pathname.new(CGI.unescape(path)).dirname : Dir.pwd
           candidate = File.expand_path(File.join(current_folder, required_file))
 
-          @_response = Interface::Location.new(
+          @response_builder << Interface::Location.new(
             uri: URI::Generic.from_path(path: candidate).to_s,
             range: Interface::Range.new(
               start: Interface::Position.new(line: 0, character: 0),
@@ -136,7 +138,7 @@ module RubyLsp
         first_entry = T.must(entries.first)
         return if first_entry.visibility == :private && first_entry.name != "#{@nesting.join("::")}::#{value}"
 
-        @_response = entries.filter_map do |entry|
+        entries.each do |entry|
           location = entry.location
           # If the project has Sorbet, then we only want to handle go to definition for constants defined in gems, as an
           # additional behavior on top of jumping to RBIs. Sorbet can already handle go to definition for all constants
@@ -144,7 +146,7 @@ module RubyLsp
           file_path = entry.file_path
           next if @typechecker_enabled && not_in_dependencies?(file_path)
 
-          Interface::Location.new(
+          @response_builder << Interface::Location.new(
             uri: URI::Generic.from_path(path: file_path).to_s,
             range: Interface::Range.new(
               start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),

data/lib/ruby_lsp/listeners/document_highlight.rb

@@ -3,10 +3,9 @@
 
 module RubyLsp
   module Listeners
-    class DocumentHighlight < Listener
+    class DocumentHighlight
       extend T::Sig
-
-      ResponseType = type_member { { fixed: T::Array[Interface::DocumentHighlight] } }
+      include Requests::Support::Common
 
       GLOBAL_VARIABLE_NODES = T.let(
         [
@@ -87,20 +86,16 @@ module RubyLsp
         T::Array[T.class_of(Prism::Node)],
       )
 
-      sig { override.returns(ResponseType) }
-      attr_reader :_response
-
       sig do
         params(
+          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight],
           target: T.nilable(Prism::Node),
           parent: T.nilable(Prism::Node),
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(target, parent, dispatcher)
-        super(dispatcher)
-
-        @_response = T.let([], T::Array[Interface::DocumentHighlight])
+      def initialize(response_builder, target, parent, dispatcher)
+        @response_builder = response_builder
 
         return unless target && parent
 
@@ -521,7 +516,7 @@ module RubyLsp
 
       sig { params(kind: Integer, location: Prism::Location).void }
       def add_highlight(kind, location)
-        @_response << Interface::DocumentHighlight.new(range: range_from_location(location), kind: kind)
+        @response_builder << Interface::DocumentHighlight.new(range: range_from_location(location), kind: kind)
       end
 
       sig { params(node: T.nilable(Prism::Node)).returns(T.nilable(String)) }

data/lib/ruby_lsp/listeners/document_link.rb

@@ -5,11 +5,9 @@ require "ruby_lsp/requests/support/source_uri"
 
 module RubyLsp
   module Listeners
-    class DocumentLink < Listener
+    class DocumentLink
       extend T::Sig
-      extend T::Generic
-
-      ResponseType = type_member { { fixed: T::Array[Interface::DocumentLink] } }
+      include Requests::Support::Common
 
       GEM_TO_VERSION_MAP = T.let(
         [*::Gem::Specification.default_stubs, *::Gem::Specification.stubs].map! do |s|
@@ -59,25 +57,21 @@ module RubyLsp
         end
       end
 
-      sig { override.returns(ResponseType) }
-      attr_reader :_response
-
       sig do
         params(
+          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink],
           uri: URI::Generic,
           comments: T::Array[Prism::Comment],
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(uri, comments, dispatcher)
-        super(dispatcher)
-
+      def initialize(response_builder, uri, comments, dispatcher)
         # Match the version based on the version in the RBI file name. Notice that the `@` symbol is sanitized to `%40`
         # in the URI
+        @response_builder = response_builder
         path = uri.to_standardized_path
         version_match = path ? /(?<=%40)[\d.]+(?=\.rbi$)/.match(path) : nil
         @gem_version = T.let(version_match && version_match[0], T.nilable(String))
-        @_response = T.let([], T::Array[Interface::DocumentLink])
         @lines_to_comments = T.let(
           comments.to_h do |comment|
             [comment.location.end_line, comment]
@@ -137,7 +131,7 @@ module RubyLsp
         file_path = self.class.gem_paths.dig(uri.gem_name, gem_version, CGI.unescape(uri.path))
         return if file_path.nil?
 
-        @_response << Interface::DocumentLink.new(
+        @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}",