ruby-lsp 0.13.2 → 0.13.3

data/lib/ruby_lsp/requests/document_link.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "ruby_lsp/requests/support/source_uri"
+require "ruby_lsp/listeners/document_link"
 
 module RubyLsp
   module Requests
@@ -18,62 +18,20 @@ module RubyLsp
     # def format(source, maxwidth = T.unsafe(nil))
     # end
     # ```
-    class DocumentLink < Listener
+    class DocumentLink < Request
       extend T::Sig
       extend T::Generic
 
-      ResponseType = type_member { { fixed: T::Array[Interface::DocumentLink] } }
-
-      GEM_TO_VERSION_MAP = T.let(
-        [*::Gem::Specification.default_stubs, *::Gem::Specification.stubs].map! do |s|
-          [s.name, s.version.to_s]
-        end.to_h.freeze,
-        T::Hash[String, String],
-      )
-
       class << self
         extend T::Sig
 
-        sig { returns(T::Hash[String, T::Hash[String, T::Hash[String, String]]]) }
-        def gem_paths
-          @gem_paths ||= T.let(
-            begin
-              lookup = {}
-
-              Gem::Specification.stubs.each do |stub|
-                spec = stub.to_spec
-                lookup[spec.name] = {}
-                lookup[spec.name][spec.version.to_s] = {}
-
-                Dir.glob("**/*.rb", base: "#{spec.full_gem_path}/").each do |path|
-                  lookup[spec.name][spec.version.to_s][path] = "#{spec.full_gem_path}/#{path}"
-                end
-              end
-
-              Gem::Specification.default_stubs.each do |stub|
-                spec = stub.to_spec
-                lookup[spec.name] = {}
-                lookup[spec.name][spec.version.to_s] = {}
-                prefix_matchers = Regexp.union(spec.require_paths.map do |rp|
-                                                 Regexp.new("^#{rp}/")
-                                               end)
-                prefix_matcher = Regexp.union(prefix_matchers, //)
-
-                spec.files.each do |file|
-                  path = file.sub(prefix_matcher, "")
-                  lookup[spec.name][spec.version.to_s][path] = "#{RbConfig::CONFIG["rubylibdir"]}/#{path}"
-                end
-              end
-
-              lookup
-            end,
-            T.nilable(T::Hash[String, T::Hash[String, T::Hash[String, String]]]),
-          )
+        sig { returns(Interface::DocumentLinkOptions) }
+        def provider
+          Interface::DocumentLinkOptions.new(resolve_provider: false)
         end
       end
 
-      sig { override.returns(ResponseType) }
-      attr_reader :_response
+      ResponseType = type_member { { fixed: T::Array[Interface::DocumentLink] } }
 
       sig do
         params(
@@ -83,92 +41,13 @@ module RubyLsp
         ).void
       end
       def initialize(uri, comments, dispatcher)
-        super(dispatcher)
-
-        # Match the version based on the version in the RBI file name. Notice that the `@` symbol is sanitized to `%40`
-        # in the URI
-        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]
-          end,
-          T::Hash[Integer, Prism::Comment],
-        )
-
-        dispatcher.register(
-          self,
-          :on_def_node_enter,
-          :on_class_node_enter,
-          :on_module_node_enter,
-          :on_constant_write_node_enter,
-          :on_constant_path_write_node_enter,
-        )
-      end
-
-      sig { params(node: Prism::DefNode).void }
-      def on_def_node_enter(node)
-        extract_document_link(node)
-      end
-
-      sig { params(node: Prism::ClassNode).void }
-      def on_class_node_enter(node)
-        extract_document_link(node)
+        super()
+        @listener = T.let(Listeners::DocumentLink.new(uri, comments, dispatcher), Listener[ResponseType])
       end
 
-      sig { params(node: Prism::ModuleNode).void }
-      def on_module_node_enter(node)
-        extract_document_link(node)
-      end
-
-      sig { params(node: Prism::ConstantWriteNode).void }
-      def on_constant_write_node_enter(node)
-        extract_document_link(node)
-      end
-
-      sig { params(node: Prism::ConstantPathWriteNode).void }
-      def on_constant_path_write_node_enter(node)
-        extract_document_link(node)
-      end
-
-      private
-
-      sig { params(node: Prism::Node).void }
-      def extract_document_link(node)
-        comment = @lines_to_comments[node.location.start_line - 1]
-        return unless comment
-
-        match = comment.location.slice.match(%r{source://.*#\d+$})
-        return unless match
-
-        uri = T.cast(URI(T.must(match[0])), URI::Source)
-        gem_version = resolve_version(uri)
-        return if gem_version.nil?
-
-        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(
-          range: range_from_location(comment.location),
-          target: "file://#{file_path}##{uri.line_number}",
-          tooltip: "Jump to #{file_path}##{uri.line_number}",
-        )
-      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
-      sig { params(uri: URI::Source).returns(T.nilable(String)) }
-      def resolve_version(uri)
-        version = uri.gem_version
-        return version unless version.nil? || version.empty?
-
-        return @gem_version unless @gem_version.nil? || @gem_version.empty?
-
-        GEM_TO_VERSION_MAP[uri.gem_name]
+      sig { override.returns(ResponseType) }
+      def perform
+        @listener.response
       end
     end
   end

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "ruby_lsp/listeners/document_symbol"
+
 module RubyLsp
   module Requests
     # ![Document symbol demo](../../document_symbol.gif)
@@ -26,232 +28,43 @@ module RubyLsp
     #   end
     # end
     # ```
-    class DocumentSymbol < ExtensibleListener
+    class DocumentSymbol < Request
       extend T::Sig
       extend T::Generic
 
-      ResponseType = type_member { { fixed: T::Array[Interface::DocumentSymbol] } }
-
-      ATTR_ACCESSORS = T.let([:attr_reader, :attr_writer, :attr_accessor].freeze, T::Array[Symbol])
-
-      class SymbolHierarchyRoot
+      class << self
         extend T::Sig
 
-        sig { returns(T::Array[Interface::DocumentSymbol]) }
-        attr_reader :children
-
-        sig { void }
-        def initialize
-          @children = T.let([], T::Array[Interface::DocumentSymbol])
+        sig { returns(Interface::DocumentSymbolClientCapabilities) }
+        def provider
+          Interface::DocumentSymbolClientCapabilities.new(
+            hierarchical_document_symbol_support: true,
+            symbol_kind: {
+              value_set: (Constant::SymbolKind::FILE..Constant::SymbolKind::TYPE_PARAMETER).to_a,
+            },
+          )
         end
       end
 
-      sig { override.returns(T::Array[Interface::DocumentSymbol]) }
-      attr_reader :_response
+      ResponseType = type_member { { fixed: T::Array[Interface::DocumentSymbol] } }
 
       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
-
-        dispatcher.register(
-          self,
-          :on_class_node_enter,
-          :on_class_node_leave,
-          :on_call_node_enter,
-          :on_constant_path_write_node_enter,
-          :on_constant_write_node_enter,
-          :on_def_node_enter,
-          :on_def_node_leave,
-          :on_module_node_enter,
-          :on_module_node_leave,
-          :on_instance_variable_write_node_enter,
-          :on_class_variable_write_node_enter,
-          :on_singleton_class_node_enter,
-          :on_singleton_class_node_leave,
-        )
-      end
-
-      sig { override.params(addon: Addon).returns(T.nilable(Listener[ResponseType])) }
-      def initialize_external_listener(addon)
-        addon.create_document_symbol_listener(@dispatcher)
-      end
-
-      # Merges responses from other listeners
-      sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
-      def merge_response!(other)
-        @_response.concat(other.response)
-        self
-      end
-
-      sig { params(node: Prism::ClassNode).void }
-      def on_class_node_enter(node)
-        @stack << create_document_symbol(
-          name: node.constant_path.location.slice,
-          kind: Constant::SymbolKind::CLASS,
-          range_location: node.location,
-          selection_range_location: node.constant_path.location,
-        )
-      end
-
-      sig { params(node: Prism::ClassNode).void }
-      def on_class_node_leave(node)
-        @stack.pop
-      end
-
-      sig { params(node: Prism::SingletonClassNode).void }
-      def on_singleton_class_node_enter(node)
-        expression = node.expression
-
-        @stack << create_document_symbol(
-          name: "<< #{expression.slice}",
-          kind: Constant::SymbolKind::NAMESPACE,
-          range_location: node.location,
-          selection_range_location: expression.location,
-        )
-      end
-
-      sig { params(node: Prism::SingletonClassNode).void }
-      def on_singleton_class_node_leave(node)
-        @stack.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),
-          )
-        end
-      end
-
-      sig { params(node: Prism::ConstantPathWriteNode).void }
-      def on_constant_path_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::ConstantWriteNode).void }
-      def on_constant_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,
+        super()
+        @listeners = T.let(
+          [Listeners::DocumentSymbol.new(dispatcher)],
+          T::Array[Listener[ResponseType]],
         )
-      end
-
-      sig { params(node: Prism::DefNode).void }
-      def on_def_node_leave(node)
-        @stack.pop
-      end
-
-      sig { params(node: Prism::ModuleNode).void }
-      def on_module_node_enter(node)
-        @stack << create_document_symbol(
-          name: node.constant_path.location.slice,
-          kind: Constant::SymbolKind::MODULE,
-          range_location: node.location,
-          selection_range_location: node.constant_path.location,
-        )
-      end
 
-      sig { params(node: Prism::DefNode).void }
-      def on_def_node_enter(node)
-        receiver = node.receiver
-        previous_symbol = @stack.last
-
-        if receiver.is_a?(Prism::SelfNode)
-          name = "self.#{node.name}"
-          kind = Constant::SymbolKind::FUNCTION
-        elsif previous_symbol.is_a?(Interface::DocumentSymbol) && previous_symbol.name.start_with?("<<")
-          name = node.name.to_s
-          kind = Constant::SymbolKind::FUNCTION
-        else
-          name = node.name.to_s
-          kind = name == "initialize" ? Constant::SymbolKind::CONSTRUCTOR : Constant::SymbolKind::METHOD
+        Addon.addons.each do |addon|
+          addon_listener = addon.create_document_symbol_listener(dispatcher)
+          @listeners << addon_listener if addon_listener
         end
-
-        symbol = create_document_symbol(
-          name: name,
-          kind: kind,
-          range_location: node.location,
-          selection_range_location: node.name_loc,
-        )
-
-        @stack << symbol
-      end
-
-      sig { params(node: Prism::ModuleNode).void }
-      def on_module_node_leave(node)
-        @stack.pop
       end
 
-      sig { params(node: Prism::InstanceVariableWriteNode).void }
-      def on_instance_variable_write_node_enter(node)
-        create_document_symbol(
-          name: node.name.to_s,
-          kind: Constant::SymbolKind::VARIABLE,
-          range_location: node.name_loc,
-          selection_range_location: node.name_loc,
-        )
-      end
-
-      sig { params(node: Prism::ClassVariableWriteNode).void }
-      def on_class_variable_write_node_enter(node)
-        create_document_symbol(
-          name: node.name.to_s,
-          kind: Constant::SymbolKind::VARIABLE,
-          range_location: node.name_loc,
-          selection_range_location: node.name_loc,
-        )
-      end
-
-      private
-
-      sig do
-        params(
-          name: String,
-          kind: Integer,
-          range_location: Prism::Location,
-          selection_range_location: Prism::Location,
-        ).returns(Interface::DocumentSymbol)
-      end
-      def create_document_symbol(name:, kind:, range_location:, selection_range_location:)
-        symbol = Interface::DocumentSymbol.new(
-          name: name,
-          kind: kind,
-          range: range_from_location(range_location),
-          selection_range: range_from_location(selection_range_location),
-          children: [],
-        )
-
-        T.must(@stack.last).children << symbol
-
-        symbol
+      sig { override.returns(ResponseType) }
+      def perform
+        @listeners.flat_map(&:response).compact
       end
     end
   end