ruby-lsp 0.13.1 → 0.13.3

data/lib/ruby_lsp/listeners/document_link.rb

@@ -0,0 +1,162 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "ruby_lsp/requests/support/source_uri"
+
+module RubyLsp
+  module Listeners
+    class DocumentLink < Listener
+      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]]]),
+          )
+        end
+      end
+
+      sig { override.returns(ResponseType) }
+      attr_reader :_response
+
+      sig do
+        params(
+          uri: URI::Generic,
+          comments: T::Array[Prism::Comment],
+          dispatcher: Prism::Dispatcher,
+        ).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)
+      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]
+      end
+    end
+  end
+end

data/lib/ruby_lsp/listeners/document_symbol.rb

@@ -0,0 +1,223 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Listeners
+    class DocumentSymbol < Listener
+      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
+        extend T::Sig
+
+        sig { returns(T::Array[Interface::DocumentSymbol]) }
+        attr_reader :children
+
+        sig { void }
+        def initialize
+          @children = T.let([], T::Array[Interface::DocumentSymbol])
+        end
+      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
+
+        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 { 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,
+        )
+      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
+        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
+      end
+    end
+  end
+end

data/lib/ruby_lsp/listeners/folding_ranges.rb

@@ -0,0 +1,271 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Listeners
+    class FoldingRanges < Listener
+      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)
+        @requires = T.let([], T::Array[Prism::CallNode])
+        @finalized_response = T.let(false, T::Boolean)
+        @comments = comments
+
+        dispatcher.register(
+          self,
+          :on_if_node_enter,
+          :on_in_node_enter,
+          :on_rescue_node_enter,
+          :on_when_node_enter,
+          :on_interpolated_string_node_enter,
+          :on_array_node_enter,
+          :on_block_node_enter,
+          :on_case_node_enter,
+          :on_case_match_node_enter,
+          :on_class_node_enter,
+          :on_module_node_enter,
+          :on_for_node_enter,
+          :on_hash_node_enter,
+          :on_singleton_class_node_enter,
+          :on_unless_node_enter,
+          :on_until_node_enter,
+          :on_while_node_enter,
+          :on_else_node_enter,
+          :on_ensure_node_enter,
+          :on_begin_node_enter,
+          :on_def_node_enter,
+          :on_call_node_enter,
+          :on_lambda_node_enter,
+        )
+      end
+
+      sig { override.returns(ResponseType) }
+      def _response
+        unless @finalized_response
+          push_comment_ranges
+          emit_requires_range
+          @finalized_response = true
+        end
+
+        @_response
+      end
+
+      sig { params(node: Prism::IfNode).void }
+      def on_if_node_enter(node)
+        add_statements_range(node)
+      end
+
+      sig { params(node: Prism::InNode).void }
+      def on_in_node_enter(node)
+        add_statements_range(node)
+      end
+
+      sig { params(node: Prism::RescueNode).void }
+      def on_rescue_node_enter(node)
+        add_statements_range(node)
+      end
+
+      sig { params(node: Prism::WhenNode).void }
+      def on_when_node_enter(node)
+        add_statements_range(node)
+      end
+
+      sig { params(node: Prism::InterpolatedStringNode).void }
+      def on_interpolated_string_node_enter(node)
+        opening_loc = node.opening_loc || node.location
+        closing_loc = node.closing_loc || node.parts.last&.location || node.location
+
+        add_lines_range(opening_loc.start_line, closing_loc.start_line - 1)
+      end
+
+      sig { params(node: Prism::ArrayNode).void }
+      def on_array_node_enter(node)
+        add_simple_range(node)
+      end
+
+      sig { params(node: Prism::BlockNode).void }
+      def on_block_node_enter(node)
+        add_simple_range(node)
+      end
+
+      sig { params(node: Prism::CaseNode).void }
+      def on_case_node_enter(node)
+        add_simple_range(node)
+      end
+
+      sig { params(node: Prism::CaseMatchNode).void }
+      def on_case_match_node_enter(node)
+        add_simple_range(node)
+      end
+
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_enter(node)
+        add_simple_range(node)
+      end
+
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_enter(node)
+        add_simple_range(node)
+      end
+
+      sig { params(node: Prism::ForNode).void }
+      def on_for_node_enter(node)
+        add_simple_range(node)
+      end
+
+      sig { params(node: Prism::HashNode).void }
+      def on_hash_node_enter(node)
+        add_simple_range(node)
+      end
+
+      sig { params(node: Prism::SingletonClassNode).void }
+      def on_singleton_class_node_enter(node)
+        add_simple_range(node)
+      end
+
+      sig { params(node: Prism::UnlessNode).void }
+      def on_unless_node_enter(node)
+        add_simple_range(node)
+      end
+
+      sig { params(node: Prism::UntilNode).void }
+      def on_until_node_enter(node)
+        add_simple_range(node)
+      end
+
+      sig { params(node: Prism::WhileNode).void }
+      def on_while_node_enter(node)
+        add_simple_range(node)
+      end
+
+      sig { params(node: Prism::ElseNode).void }
+      def on_else_node_enter(node)
+        add_simple_range(node)
+      end
+
+      sig { params(node: Prism::EnsureNode).void }
+      def on_ensure_node_enter(node)
+        add_simple_range(node)
+      end
+
+      sig { params(node: Prism::BeginNode).void }
+      def on_begin_node_enter(node)
+        add_simple_range(node)
+      end
+
+      sig { params(node: Prism::DefNode).void }
+      def on_def_node_enter(node)
+        params = node.parameters
+        parameter_loc = params&.location
+        location = node.location
+
+        if params && parameter_loc.end_line > location.start_line
+          # Multiline parameters
+          add_lines_range(location.start_line, parameter_loc.end_line)
+          add_lines_range(parameter_loc.end_line + 1, location.end_line - 1)
+        else
+          add_lines_range(location.start_line, location.end_line - 1)
+        end
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
+        # If we find a require, don't visit the child nodes (prevent `super`), so that we can keep accumulating into
+        # the `@requires` array and then push the range whenever we find a node that isn't a CallNode
+        if require?(node)
+          @requires << node
+          return
+        end
+
+        location = node.location
+        add_lines_range(location.start_line, location.end_line - 1)
+      end
+
+      sig { params(node: Prism::LambdaNode).void }
+      def on_lambda_node_enter(node)
+        add_simple_range(node)
+      end
+
+      private
+
+      sig { void }
+      def push_comment_ranges
+        # Group comments that are on consecutive lines and then push ranges for each group that has at least 2 comments
+        @comments.chunk_while do |this, other|
+          this.location.end_line + 1 == other.location.start_line
+        end.each do |chunk|
+          next if chunk.length == 1
+
+          @_response << 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",
+          )
+        end
+      end
+
+      sig { void }
+      def emit_requires_range
+        if @requires.length > 1
+          @_response << 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",
+          )
+        end
+
+        @requires.clear
+      end
+
+      sig { params(node: Prism::CallNode).returns(T::Boolean) }
+      def require?(node)
+        message = node.message
+        return false unless message == "require" || message == "require_relative"
+
+        receiver = node.receiver
+        return false unless receiver.nil? || receiver.slice == "Kernel"
+
+        arguments = node.arguments&.arguments
+        return false unless arguments
+
+        arguments.length == 1 && arguments.first.is_a?(Prism::StringNode)
+      end
+
+      sig { params(node: T.any(Prism::IfNode, Prism::InNode, Prism::RescueNode, Prism::WhenNode)).void }
+      def add_statements_range(node)
+        statements = node.statements
+        return unless statements
+
+        body = statements.body
+        return if body.empty?
+
+        add_lines_range(node.location.start_line, T.must(body.last).location.end_line)
+      end
+
+      sig { params(node: Prism::Node).void }
+      def add_simple_range(node)
+        location = node.location
+        add_lines_range(location.start_line, location.end_line - 1)
+      end
+
+      sig { params(start_line: Integer, end_line: Integer).void }
+      def add_lines_range(start_line, end_line)
+        emit_requires_range
+        return if start_line >= end_line
+
+        @_response << Interface::FoldingRange.new(
+          start_line: start_line - 1,
+          end_line: end_line - 1,
+          kind: "region",
+        )
+      end
+    end
+  end
+end