ruby-lsp 0.13.4 → 0.14.1

data/lib/ruby_lsp/listeners/document_symbol.rb

@@ -3,39 +3,20 @@
 
 module RubyLsp
   module Listeners
-    class DocumentSymbol < Listener
+    class DocumentSymbol
       extend T::Sig
-      extend T::Generic
-
-      ResponseType = type_member { { fixed: T::Array[Interface::DocumentSymbol] } }
+      include Requests::Support::Common
 
       ATTR_ACCESSORS = T.let([:attr_reader, :attr_writer, :attr_accessor].freeze, T::Array[Symbol])
 
-      class SymbolHierarchyRoot
-        extend T::Sig
-
-        sig { returns(T::Array[Interface::DocumentSymbol]) }
-        attr_reader :children
-
-        sig { void }
-        def initialize
-          @children = T.let([], T::Array[Interface::DocumentSymbol])
-        end
+      sig do
+        params(
+          response_builder: ResponseBuilders::DocumentSymbol,
+          dispatcher: Prism::Dispatcher,
+        ).void
       end
-
-      sig { override.returns(T::Array[Interface::DocumentSymbol]) }
-      attr_reader :_response
-
-      sig { params(dispatcher: Prism::Dispatcher).void }
-      def initialize(dispatcher)
-        @root = T.let(SymbolHierarchyRoot.new, SymbolHierarchyRoot)
-        @_response = T.let(@root.children, T::Array[Interface::DocumentSymbol])
-        @stack = T.let(
-          [@root],
-          T::Array[T.any(SymbolHierarchyRoot, Interface::DocumentSymbol)],
-        )
-
-        super
+      def initialize(response_builder, dispatcher)
+        @response_builder = response_builder
 
         dispatcher.register(
           self,
@@ -44,6 +25,14 @@ module RubyLsp
           :on_call_node_enter,
           :on_constant_path_write_node_enter,
           :on_constant_write_node_enter,
+          :on_constant_path_or_write_node_enter,
+          :on_constant_path_operator_write_node_enter,
+          :on_constant_path_and_write_node_enter,
+          :on_constant_or_write_node_enter,
+          :on_constant_operator_write_node_enter,
+          :on_constant_and_write_node_enter,
+          :on_constant_target_node_enter,
+          :on_constant_path_target_node_enter,
           :on_def_node_enter,
           :on_def_node_leave,
           :on_module_node_enter,
@@ -52,12 +41,13 @@ module RubyLsp
           :on_class_variable_write_node_enter,
           :on_singleton_class_node_enter,
           :on_singleton_class_node_leave,
+          :on_alias_method_node_enter,
         )
       end
 
       sig { params(node: Prism::ClassNode).void }
       def on_class_node_enter(node)
-        @stack << create_document_symbol(
+        @response_builder << create_document_symbol(
           name: node.constant_path.location.slice,
           kind: Constant::SymbolKind::CLASS,
           range_location: node.location,
@@ -67,14 +57,14 @@ module RubyLsp
 
       sig { params(node: Prism::ClassNode).void }
       def on_class_node_leave(node)
-        @stack.pop
+        @response_builder.pop
       end
 
       sig { params(node: Prism::SingletonClassNode).void }
       def on_singleton_class_node_enter(node)
         expression = node.expression
 
-        @stack << create_document_symbol(
+        @response_builder << create_document_symbol(
           name: "<< #{expression.slice}",
           kind: Constant::SymbolKind::NAMESPACE,
           range_location: node.location,
@@ -84,28 +74,15 @@ module RubyLsp
 
       sig { params(node: Prism::SingletonClassNode).void }
       def on_singleton_class_node_leave(node)
-        @stack.pop
+        @response_builder.pop
       end
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
-        return unless ATTR_ACCESSORS.include?(node.name) && node.receiver.nil?
-
-        arguments = node.arguments
-        return unless arguments
-
-        arguments.arguments.each do |argument|
-          next unless argument.is_a?(Prism::SymbolNode)
-
-          name = argument.value
-          next unless name
-
-          create_document_symbol(
-            name: name,
-            kind: Constant::SymbolKind::FIELD,
-            range_location: argument.location,
-            selection_range_location: T.must(argument.value_loc),
-          )
+        if ATTR_ACCESSORS.include?(node.name)
+          handle_attr_accessor(node)
+        elsif node.name == :alias_method
+          handle_alias_method(node)
         end
       end
 
@@ -129,14 +106,94 @@ module RubyLsp
         )
       end
 
+      sig { params(node: Prism::ConstantPathAndWriteNode).void }
+      def on_constant_path_and_write_node_enter(node)
+        create_document_symbol(
+          name: node.target.location.slice,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.target.location,
+        )
+      end
+
+      sig { params(node: Prism::ConstantPathOrWriteNode).void }
+      def on_constant_path_or_write_node_enter(node)
+        create_document_symbol(
+          name: node.target.location.slice,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.target.location,
+        )
+      end
+
+      sig { params(node: Prism::ConstantPathOperatorWriteNode).void }
+      def on_constant_path_operator_write_node_enter(node)
+        create_document_symbol(
+          name: node.target.location.slice,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.target.location,
+        )
+      end
+
+      sig { params(node: Prism::ConstantOrWriteNode).void }
+      def on_constant_or_write_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.name_loc,
+        )
+      end
+
+      sig { params(node: Prism::ConstantAndWriteNode).void }
+      def on_constant_and_write_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.name_loc,
+        )
+      end
+
+      sig { params(node: Prism::ConstantOperatorWriteNode).void }
+      def on_constant_operator_write_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.name_loc,
+        )
+      end
+
+      sig { params(node: Prism::ConstantTargetNode).void }
+      def on_constant_target_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.location,
+        )
+      end
+
+      sig { params(node: Prism::ConstantPathTargetNode).void }
+      def on_constant_path_target_node_enter(node)
+        create_document_symbol(
+          name: node.slice,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.location,
+        )
+      end
+
       sig { params(node: Prism::DefNode).void }
       def on_def_node_leave(node)
-        @stack.pop
+        @response_builder.pop
       end
 
       sig { params(node: Prism::ModuleNode).void }
       def on_module_node_enter(node)
-        @stack << create_document_symbol(
+        @response_builder << create_document_symbol(
           name: node.constant_path.location.slice,
           kind: Constant::SymbolKind::MODULE,
           range_location: node.location,
@@ -147,7 +204,7 @@ module RubyLsp
       sig { params(node: Prism::DefNode).void }
       def on_def_node_enter(node)
         receiver = node.receiver
-        previous_symbol = @stack.last
+        previous_symbol = @response_builder.last
 
         if receiver.is_a?(Prism::SelfNode)
           name = "self.#{node.name}"
@@ -167,12 +224,12 @@ module RubyLsp
           selection_range_location: node.name_loc,
         )
 
-        @stack << symbol
+        @response_builder << symbol
       end
 
       sig { params(node: Prism::ModuleNode).void }
       def on_module_node_leave(node)
-        @stack.pop
+        @response_builder.pop
       end
 
       sig { params(node: Prism::InstanceVariableWriteNode).void }
@@ -195,6 +252,22 @@ module RubyLsp
         )
       end
 
+      sig { params(node: Prism::AliasMethodNode).void }
+      def on_alias_method_node_enter(node)
+        new_name_node = node.new_name
+        return unless new_name_node.is_a?(Prism::SymbolNode)
+
+        name = new_name_node.value
+        return unless name
+
+        create_document_symbol(
+          name: name,
+          kind: Constant::SymbolKind::METHOD,
+          range_location: new_name_node.location,
+          selection_range_location: T.must(new_name_node.value_loc),
+        )
+      end
+
       private
 
       sig do
@@ -214,10 +287,76 @@ module RubyLsp
           children: [],
         )
 
-        T.must(@stack.last).children << symbol
+        @response_builder.last.children << symbol
 
         symbol
       end
+
+      sig { params(node: Prism::CallNode).void }
+      def handle_attr_accessor(node)
+        receiver = node.receiver
+        return if receiver && !receiver.is_a?(Prism::SelfNode)
+
+        arguments = node.arguments
+        return unless arguments
+
+        arguments.arguments.each do |argument|
+          if argument.is_a?(Prism::SymbolNode)
+            name = argument.value
+            next unless name
+
+            create_document_symbol(
+              name: name,
+              kind: Constant::SymbolKind::FIELD,
+              range_location: argument.location,
+              selection_range_location: T.must(argument.value_loc),
+            )
+          elsif argument.is_a?(Prism::StringNode)
+            name = argument.content
+            next if name.empty?
+
+            create_document_symbol(
+              name: name,
+              kind: Constant::SymbolKind::FIELD,
+              range_location: argument.location,
+              selection_range_location: argument.content_loc,
+            )
+          end
+        end
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def handle_alias_method(node)
+        receiver = node.receiver
+        return if receiver && !receiver.is_a?(Prism::SelfNode)
+
+        arguments = node.arguments
+        return unless arguments
+
+        new_name_argument = arguments.arguments.first
+
+        if new_name_argument.is_a?(Prism::SymbolNode)
+          name = new_name_argument.value
+          return unless name
+
+          create_document_symbol(
+            name: name,
+            kind: Constant::SymbolKind::METHOD,
+            range_location: new_name_argument.location,
+            selection_range_location: T.must(new_name_argument.value_loc),
+          )
+        elsif new_name_argument.is_a?(Prism::StringNode)
+          name = new_name_argument.content
+          return if name.empty?
+
+          create_document_symbol(
+            name: name,
+            kind: Constant::SymbolKind::METHOD,
+            range_location: new_name_argument.location,
+            selection_range_location: new_name_argument.content_loc,
+          )
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp/listeners/folding_ranges.rb

@@ -3,19 +3,20 @@
 
 module RubyLsp
   module Listeners
-    class FoldingRanges < Listener
+    class FoldingRanges
       extend T::Sig
-      extend T::Generic
-
-      ResponseType = type_member { { fixed: T::Array[Interface::FoldingRange] } }
-
-      sig { params(comments: T::Array[Prism::Comment], dispatcher: Prism::Dispatcher).void }
-      def initialize(comments, dispatcher)
-        super(dispatcher)
-
-        @_response = T.let([], ResponseType)
+      include Requests::Support::Common
+
+      sig do
+        params(
+          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange],
+          comments: T::Array[Prism::Comment],
+          dispatcher: Prism::Dispatcher,
+        ).void
+      end
+      def initialize(response_builder, comments, dispatcher)
+        @response_builder = response_builder
         @requires = T.let([], T::Array[Prism::CallNode])
-        @finalized_response = T.let(false, T::Boolean)
         @comments = comments
 
         dispatcher.register(
@@ -46,15 +47,10 @@ module RubyLsp
         )
       end
 
-      sig { override.returns(ResponseType) }
-      def _response
-        unless @finalized_response
-          push_comment_ranges
-          emit_requires_range
-          @finalized_response = true
-        end
-
-        @_response
+      sig { void }
+      def finalize_response!
+        push_comment_ranges
+        emit_requires_range
       end
 
       sig { params(node: Prism::IfNode).void }
@@ -203,7 +199,7 @@ module RubyLsp
         end.each do |chunk|
           next if chunk.length == 1
 
-          @_response << Interface::FoldingRange.new(
+          @response_builder << Interface::FoldingRange.new(
             start_line: T.must(chunk.first).location.start_line - 1,
             end_line: T.must(chunk.last).location.end_line - 1,
             kind: "comment",
@@ -214,7 +210,7 @@ module RubyLsp
       sig { void }
       def emit_requires_range
         if @requires.length > 1
-          @_response << Interface::FoldingRange.new(
+          @response_builder << Interface::FoldingRange.new(
             start_line: T.must(@requires.first).location.start_line - 1,
             end_line: T.must(@requires.last).location.end_line - 1,
             kind: "imports",
@@ -260,7 +256,7 @@ module RubyLsp
         emit_requires_range
         return if start_line >= end_line
 
-        @_response << Interface::FoldingRange.new(
+        @response_builder << Interface::FoldingRange.new(
           start_line: start_line - 1,
           end_line: end_line - 1,
           kind: "region",

data/lib/ruby_lsp/listeners/hover.rb

@@ -3,11 +3,9 @@
 
 module RubyLsp
   module Listeners
-    class Hover < Listener
+    class Hover
       extend T::Sig
-      extend T::Generic
-
-      ResponseType = type_member { { fixed: T.nilable(Interface::Hover) } }
+      include Requests::Support::Common
 
       ALLOWED_TARGETS = T.let(
         [
@@ -19,11 +17,17 @@ module RubyLsp
         T::Array[T.class_of(Prism::Node)],
       )
 
-      sig { override.returns(ResponseType) }
-      attr_reader :_response
+      ALLOWED_REMOTE_PROVIDERS = T.let(
+        [
+          "https://github.com",
+          "https://gitlab.com",
+        ].freeze,
+        T::Array[String],
+      )
 
       sig do
         params(
+          response_builder: ResponseBuilders::Hover,
           uri: URI::Generic,
           nesting: T::Array[String],
           index: RubyIndexer::Index,
@@ -31,14 +35,13 @@ 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
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         @nesting = nesting
         @index = index
         @typechecker_enabled = typechecker_enabled
-        @_response = T.let(nil, ResponseType)
 
-        super(dispatcher)
         dispatcher.register(
           self,
           :on_constant_read_node_enter,
@@ -52,7 +55,10 @@ module RubyLsp
       def on_constant_read_node_enter(node)
         return if @typechecker_enabled
 
-        generate_hover(node.slice, node.location)
+        name = constant_name(node)
+        return if name.nil?
+
+        generate_hover(name, node.location)
       end
 
       sig { params(node: Prism::ConstantWriteNode).void }
@@ -66,7 +72,10 @@ module RubyLsp
       def on_constant_path_node_enter(node)
         return if DependencyDetector.instance.typechecker
 
-        generate_hover(node.slice, node.location)
+        name = constant_name(node)
+        return if name.nil?
+
+        generate_hover(name, node.location)
       end
 
       sig { params(node: Prism::CallNode).void }
@@ -83,15 +92,12 @@ module RubyLsp
         message = node.message
         return unless message
 
-        target_method = @index.resolve_method(message, @nesting.join("::"))
-        return unless target_method
-
-        location = target_method.location
+        methods = @index.resolve_method(message, @nesting.join("::"))
+        return unless methods
 
-        @_response = Interface::Hover.new(
-          range: range_from_location(location),
-          contents: markdown_from_index_entries(message, target_method),
-        )
+        categorized_markdown_from_index_entries(message, methods).each do |category, content|
+          @response_builder.push(content, category: category)
+        end
       end
 
       private
@@ -106,10 +112,9 @@ module RubyLsp
         first_entry = T.must(entries.first)
         return if first_entry.visibility == :private && first_entry.name != "#{@nesting.join("::")}::#{name}"
 
-        @_response = Interface::Hover.new(
-          range: range_from_location(location),
-          contents: markdown_from_index_entries(name, entries),
-        )
+        categorized_markdown_from_index_entries(name, entries).each do |category, content|
+          @response_builder.push(content, category: category)
+        end
       end
 
       sig { params(node: Prism::CallNode).void }
@@ -132,18 +137,15 @@ module RubyLsp
         # Remove leading whitespace if a heredoc was used for the summary or description
         info = info.gsub(/^ +/, "")
 
-        markdown = <<~MARKDOWN
-          **#{spec.name}** (#{spec.version})
-          #{info}
-        MARKDOWN
-
-        @_response = Interface::Hover.new(
-          range: range_from_location(node.location),
-          contents: Interface::MarkupContent.new(
-            kind: Constant::MarkupKind::MARKDOWN,
-            value: markdown,
-          ),
+        remote_url = [spec.homepage, spec.metadata["source_code_uri"]].compact.find do |page|
+          page.start_with?(*ALLOWED_REMOTE_PROVIDERS)
+        end
+
+        @response_builder.push(
+          "**#{spec.name}** (#{spec.version}) #{remote_url && " - [open remote](#{remote_url})"}",
+          category: :title,
         )
+        @response_builder.push(info, category: :documentation)
       rescue Gem::MissingSpecError
         # Do nothing if the spec cannot be found
       end

data/lib/ruby_lsp/listeners/inlay_hints.rb

@@ -3,28 +3,22 @@
 
 module RubyLsp
   module Listeners
-    class InlayHints < Listener
+    class InlayHints
       extend T::Sig
-      extend T::Generic
-
-      ResponseType = type_member { { fixed: T::Array[Interface::InlayHint] } }
+      include Requests::Support::Common
 
       RESCUE_STRING_LENGTH = T.let("rescue".length, Integer)
 
-      sig { override.returns(ResponseType) }
-      attr_reader :_response
-
       sig do
         params(
+          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint],
           range: T::Range[Integer],
           hints_configuration: RequestConfig,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(range, hints_configuration, dispatcher)
-        super(dispatcher)
-
-        @_response = T.let([], ResponseType)
+      def initialize(response_builder, range, hints_configuration, dispatcher)
+        @response_builder = response_builder
         @range = range
         @hints_configuration = hints_configuration
 
@@ -39,7 +33,7 @@ module RubyLsp
         loc = node.location
         return unless visible?(node, @range)
 
-        @_response << Interface::InlayHint.new(
+        @response_builder << Interface::InlayHint.new(
           position: { line: loc.start_line - 1, character: loc.start_column + RESCUE_STRING_LENGTH },
           label: "StandardError",
           padding_left: true,
@@ -68,7 +62,7 @@ module RubyLsp
           tooltip = "This is a local variable: #{node_name}"
         end
 
-        @_response << Interface::InlayHint.new(
+        @response_builder << Interface::InlayHint.new(
           position: { line: loc.start_line - 1, character: loc.start_column + node_name.length + 1 },
           label: node_name,
           padding_left: true,