ruby-lsp 0.3.2 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e09a85000549c0b7b7dd2886b49d44ca2e32b830616a4af7181a2d7952f948f
-  data.tar.gz: f19b017ebffce3a090d9fe9c39c94cb0dad75a7a74856c099443839524d513f3
+  metadata.gz: 9a8db1decbd8a8d3a05226ececbd13ba54aa2a0b5e727fd9a752ccda5b52322d
+  data.tar.gz: 4f49ca2d80313dcd41e0410a1583ddc3f0c913305b4c3347611181a752561265
 SHA512:
-  metadata.gz: e0b75fa95c43a4a15a46e3cd663b5dd637c9288497116b356eb69dc3f831cfdbb3e167c1c578b68feee715e85c72d26c7d63236e3250552ddbf0f2db334e8f46
-  data.tar.gz: c80518dba77375f07f9944f0401f6836ca69bba60ba6723677e33e366104dd69b70832e8ce76c05312b47c3a032a5308711505e88be2ce69f3f837bec2db3c21
+  metadata.gz: 510bd7ef4da254c79da9af3437403ffe70a054718e9b0a33efc52b1bb49f93cf9c951729e6528ad4cbcf7d383fa7904835f8e0496482611c3891c3ed12ba784c
+  data.tar.gz: 2df5df95106e85a37c834c4ff77a5a19609e1946326ca86828292abb4440787b0eb8f38c9fd8f6f3cd2eb5460e8c27d0c41bb1c025d317f01502ab21afad4161

data/VERSION

@@ -1 +1 @@
-0.3.2
+0.3.4

data/lib/ruby_lsp/document.rb

@@ -24,6 +24,7 @@ module RubyLsp
       @syntax_error_edits = T.let([], T::Array[EditShape])
       @source = T.let(source, String)
       @parsable_source = T.let(source.dup, String)
+      @unparsed_edits = T.let([], T::Array[EditShape])
       @tree = T.let(SyntaxTree.parse(@source), T.nilable(SyntaxTree::Node))
     rescue SyntaxTree::Parser::ParseError
       # Do not raise if we failed to parse
@@ -38,7 +39,7 @@ module RubyLsp
       type_parameters(:T)
         .params(
           request_name: Symbol,
-          block: T.proc.params(document: Document).returns(T.type_parameter(:T))
+          block: T.proc.params(document: Document).returns(T.type_parameter(:T)),
         ).returns(T.type_parameter(:T))
     end
     def cache_fetch(request_name, &block)
@@ -55,13 +56,21 @@ module RubyLsp
       # Apply the edits on the real source
       edits.each { |edit| apply_edit(@source, edit[:range], edit[:text]) }
 
+      @unparsed_edits.concat(edits)
       @cache.clear
+    end
+
+    sig { void }
+    def parse
+      return if @unparsed_edits.empty?
+
       @tree = SyntaxTree.parse(@source)
       @syntax_error_edits.clear
+      @unparsed_edits.clear
       @parsable_source = @source.dup
-      nil
     rescue SyntaxTree::Parser::ParseError
-      update_parsable_source(edits)
+      @syntax_error_edits = @unparsed_edits
+      update_parsable_source(@unparsed_edits)
     end
 
     sig { returns(T::Boolean) }
@@ -81,7 +90,6 @@ module RubyLsp
       # If the new edits caused a syntax error, make all edits blank spaces and line breaks to adjust the line and
       # column numbers. This is attempt to make the document parsable while partial edits are being applied
       edits.each do |edit|
-        @syntax_error_edits << edit
         next if edit[:text].empty? # skip deletions, since they may have caused the syntax error
 
         apply_edit(@parsable_source, edit[:range], edit[:text].gsub(/[^\r\n]/, " "))

data/lib/ruby_lsp/handler.rb

@@ -26,7 +26,7 @@ module RubyLsp
       # for displaying window messages on errors
       sig do
         params(
-          block: T.proc.bind(Handler).params(error: Exception, request: T::Hash[Symbol, T.untyped]).void
+          block: T.proc.bind(Handler).params(error: Exception, request: T::Hash[Symbol, T.untyped]).void,
         ).void
       end
       def on_error(&block)
@@ -85,7 +85,7 @@ module RubyLsp
       params(
         msg: String,
         parallel: T::Boolean,
-        blk: T.proc.bind(Handler).params(request: T::Hash[Symbol, T.untyped]).returns(T.untyped)
+        blk: T.proc.bind(Handler).params(request: T::Hash[Symbol, T.untyped]).returns(T.untyped),
       ).returns(RequestHandler)
     end
     def on(msg, parallel: false, &blk)
@@ -103,7 +103,7 @@ module RubyLsp
     def clear_diagnostics(uri)
       @writer.write(
         method: "textDocument/publishDiagnostics",
-        params: Interface::PublishDiagnosticsParams.new(uri: uri, diagnostics: [])
+        params: Interface::PublishDiagnosticsParams.new(uri: uri, diagnostics: []),
       )
     end
 
@@ -111,7 +111,7 @@ module RubyLsp
     def show_message(type, message)
       @writer.write(
         method: "window/showMessage",
-        params: Interface::ShowMessageParams.new(type: type, message: message)
+        params: Interface::ShowMessageParams.new(type: type, message: message),
       )
     end
   end

data/lib/ruby_lsp/queue.rb

@@ -28,7 +28,7 @@ module RubyLsp
     sig do
       params(
         writer: LanguageServer::Protocol::Transport::Stdio::Writer,
-        handlers: T::Hash[String, Handler::RequestHandler]
+        handlers: T::Hash[String, Handler::RequestHandler],
       ).void
     end
     def initialize(writer, handlers)
@@ -94,7 +94,7 @@ module RubyLsp
     sig do
       params(
         result: Result,
-        request: T::Hash[Symbol, T.untyped]
+        request: T::Hash[Symbol, T.untyped],
       ).void
     end
     def finalize_request(result, request)
@@ -107,7 +107,7 @@ module RubyLsp
             id: request[:id],
             error: {
               code: LanguageServer::Protocol::Constant::ErrorCodes::INTERNAL_ERROR,
-              message: result.error.inspect,
+              message: error.inspect,
               data: request.to_json,
             },
           )
@@ -117,7 +117,7 @@ module RubyLsp
 
         request_time = result.request_time
         if request_time
-          @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, result.error))
+          @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, error))
         end
       end
     end
@@ -152,7 +152,7 @@ module RubyLsp
       params(
         request: T::Hash[Symbol, T.untyped],
         request_time: Float,
-        error: T.nilable(Exception)
+        error: T.nilable(Exception),
       ).returns(T::Hash[Symbol, T.any(String, Float)])
     end
     def telemetry_params(request, request_time, error)
@@ -167,6 +167,12 @@ module RubyLsp
       if error
         params[:errorClass] = error.class.name
         params[:errorMessage] = error.message
+
+        log_params = request[:params]&.reject { |k, _| k == :textDocument }
+        params[:params] = log_params.to_json if log_params&.any?
+
+        backtrace = error.backtrace
+        params[:backtrace] = backtrace.map { |bt| bt.sub(/^#{Dir.home}/, "~") }.join("\n") if backtrace
       end
 
       params[:uri] = uri.sub(%r{.*://#{Dir.home}}, "~") if uri

data/lib/ruby_lsp/requests/base_request.rb

@@ -14,6 +14,10 @@ module RubyLsp
       def initialize(document)
         @document = document
 
+        # Parsing the document here means we're taking a lazy approach by only doing it when the first feature request
+        # is received by the server. This happens because {Document#parse} remembers if there are new edits to be parsed
+        @document.parse
+
         super()
       end
 
@@ -30,6 +34,51 @@ module RubyLsp
           end: LanguageServer::Protocol::Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
         )
       end
+
+      sig { params(node: SyntaxTree::ConstPathRef).returns(String) }
+      def full_constant_name(node)
+        name = +node.constant.value
+        constant = T.let(node, SyntaxTree::Node)
+
+        while constant.is_a?(SyntaxTree::ConstPathRef)
+          constant = constant.parent
+
+          case constant
+          when SyntaxTree::ConstPathRef
+            name.prepend("#{constant.constant.value}::")
+          when SyntaxTree::VarRef
+            name.prepend("#{constant.value.value}::")
+          end
+        end
+
+        name
+      end
+
+      sig do
+        params(
+          parent: SyntaxTree::Node,
+          target_nodes: T::Array[T.class_of(SyntaxTree::Node)],
+          position: Integer,
+        ).returns(T::Array[SyntaxTree::Node])
+      end
+      def locate_node_and_parent(parent, target_nodes, position)
+        matched = parent.child_nodes.compact.bsearch do |child|
+          if (child.location.start_char...child.location.end_char).cover?(position)
+            0
+          else
+            position <=> child.location.start_char
+          end
+        end
+
+        case matched
+        when *target_nodes
+          [matched, parent]
+        when SyntaxTree::Node
+          locate_node_and_parent(matched, target_nodes, position)
+        else
+          []
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/code_actions.rb

@@ -23,7 +23,7 @@ module RubyLsp
         params(
           uri: String,
           document: Document,
-          range: T::Range[Integer]
+          range: T::Range[Integer],
         ).void
       end
       def initialize(uri, document, range)

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -33,7 +33,7 @@ module RubyLsp
           T.any(
             T.all(T::Array[Support::RuboCopDiagnostic], Object),
             T.all(T::Array[Support::SyntaxErrorDiagnostic], Object),
-          )
+          ),
         )
       end
       def run

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -37,13 +37,11 @@ module RubyLsp
       sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentHighlight], Object)) }
       def run
         # no @target means the target is not highlightable
-        return [] unless @target
-
-        visit(@document.tree)
+        visit(@document.tree) if @document.parsed? && @target
         @highlights
       end
 
-      sig { params(node: T.nilable(SyntaxTree::Node)).void }
+      sig { override.params(node: T.nilable(SyntaxTree::Node)).void }
       def visit(node)
         return if node.nil?
 
@@ -55,6 +53,14 @@ module RubyLsp
 
       private
 
+      DIRECT_HIGHLIGHTS = T.let([
+        SyntaxTree::GVar,
+        SyntaxTree::IVar,
+        SyntaxTree::Const,
+        SyntaxTree::CVar,
+        SyntaxTree::VarField,
+      ], T::Array[T.class_of(SyntaxTree::Node)])
+
       sig do
         params(
           node: SyntaxTree::Node,
@@ -62,27 +68,16 @@ module RubyLsp
         ).returns(T.nilable(Support::HighlightTarget))
       end
       def find(node, position)
-        matched =
-          node.child_nodes.compact.bsearch do |child|
-            if (child.location.start_char...child.location.end_char).cover?(position)
-              0
-            else
-              position <=> child.location.start_char
-            end
-          end
+        matched, parent = locate_node_and_parent(node, DIRECT_HIGHLIGHTS + [SyntaxTree::Ident], position)
+
+        return unless matched && parent
 
         case matched
-        when SyntaxTree::GVar,
-             SyntaxTree::IVar,
-             SyntaxTree::Const,
-             SyntaxTree::CVar,
-             SyntaxTree::VarField
+        when *DIRECT_HIGHLIGHTS
           Support::HighlightTarget.new(matched)
         when SyntaxTree::Ident
-          relevant_node = node.is_a?(SyntaxTree::Params) ? matched : node
+          relevant_node = parent.is_a?(SyntaxTree::Params) ? matched : parent
           Support::HighlightTarget.new(relevant_node)
-        when SyntaxTree::Node
-          find(matched, position)
         end
       end
 

data/lib/ruby_lsp/requests/document_link.rb

@@ -25,7 +25,7 @@ module RubyLsp
         [*::Gem::Specification.default_stubs, *::Gem::Specification.stubs].map! do |s|
           [s.name, s.version.to_s]
         end.to_h.freeze,
-        T::Hash[String, String]
+        T::Hash[String, String],
       )
 
       class << self
@@ -78,11 +78,11 @@ module RubyLsp
 
       sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentLink], Object)) }
       def run
-        visit(@document.tree)
+        visit(@document.tree) if @document.parsed?
         @links
       end
 
-      sig { params(node: SyntaxTree::Comment).void }
+      sig { override.params(node: SyntaxTree::Comment).void }
       def visit_comment(node)
         match = node.value.match(%r{source://.*#\d+$})
         return unless match
@@ -95,7 +95,7 @@ module RubyLsp
         @links << LanguageServer::Protocol::Interface::DocumentLink.new(
           range: range_from_syntax_tree_node(node),
           target: "file://#{file_path}##{uri.line_number}",
-          tooltip: "Jump to #{file_path}##{uri.line_number}"
+          tooltip: "Jump to #{file_path}##{uri.line_number}",
         )
       end
 

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -79,23 +79,23 @@ module RubyLsp
         @root = T.let(SymbolHierarchyRoot.new, SymbolHierarchyRoot)
         @stack = T.let(
           [@root],
-          T::Array[T.any(SymbolHierarchyRoot, LanguageServer::Protocol::Interface::DocumentSymbol)]
+          T::Array[T.any(SymbolHierarchyRoot, LanguageServer::Protocol::Interface::DocumentSymbol)],
         )
       end
 
       sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol], Object)) }
       def run
-        visit(@document.tree)
+        visit(@document.tree) if @document.parsed?
         @root.children
       end
 
-      sig { params(node: SyntaxTree::ClassDeclaration).void }
+      sig { override.params(node: SyntaxTree::ClassDeclaration).void }
       def visit_class(node)
         symbol = create_document_symbol(
           name: fully_qualified_name(node),
           kind: :class,
           range_node: node,
-          selection_range_node: node.constant
+          selection_range_node: node.constant,
         )
 
         @stack << symbol
@@ -103,7 +103,7 @@ module RubyLsp
         @stack.pop
       end
 
-      sig { params(node: SyntaxTree::Command).void }
+      sig { override.params(node: SyntaxTree::Command).void }
       def visit_command(node)
         return unless ATTR_ACCESSORS.include?(node.message.value)
 
@@ -114,22 +114,22 @@ module RubyLsp
             name: argument.value.value,
             kind: :field,
             range_node: argument,
-            selection_range_node: argument.value
+            selection_range_node: argument.value,
           )
         end
       end
 
-      sig { params(node: SyntaxTree::ConstPathField).void }
+      sig { override.params(node: SyntaxTree::ConstPathField).void }
       def visit_const_path_field(node)
         create_document_symbol(
           name: node.constant.value,
           kind: :constant,
           range_node: node,
-          selection_range_node: node.constant
+          selection_range_node: node.constant,
         )
       end
 
-      sig { params(node: SyntaxTree::Def).void }
+      sig { override.params(node: SyntaxTree::Def).void }
       def visit_def(node)
         name = node.name.value
 
@@ -137,7 +137,7 @@ module RubyLsp
           name: name,
           kind: name == "initialize" ? :constructor : :method,
           range_node: node,
-          selection_range_node: node.name
+          selection_range_node: node.name,
         )
 
         @stack << symbol
@@ -145,7 +145,7 @@ module RubyLsp
         @stack.pop
       end
 
-      sig { params(node: SyntaxTree::DefEndless).void }
+      sig { override.params(node: SyntaxTree::DefEndless).void }
       def visit_def_endless(node)
         name = node.name.value
 
@@ -153,7 +153,7 @@ module RubyLsp
           name: name,
           kind: name == "initialize" ? :constructor : :method,
           range_node: node,
-          selection_range_node: node.name
+          selection_range_node: node.name,
         )
 
         @stack << symbol
@@ -161,13 +161,13 @@ module RubyLsp
         @stack.pop
       end
 
-      sig { params(node: SyntaxTree::Defs).void }
+      sig { override.params(node: SyntaxTree::Defs).void }
       def visit_defs(node)
         symbol = create_document_symbol(
           name: "self.#{node.name.value}",
           kind: :method,
           range_node: node,
-          selection_range_node: node.name
+          selection_range_node: node.name,
         )
 
         @stack << symbol
@@ -175,13 +175,13 @@ module RubyLsp
         @stack.pop
       end
 
-      sig { params(node: SyntaxTree::ModuleDeclaration).void }
+      sig { override.params(node: SyntaxTree::ModuleDeclaration).void }
       def visit_module(node)
         symbol = create_document_symbol(
           name: fully_qualified_name(node),
           kind: :module,
           range_node: node,
-          selection_range_node: node.constant
+          selection_range_node: node.constant,
         )
 
         @stack << symbol
@@ -189,17 +189,17 @@ module RubyLsp
         @stack.pop
       end
 
-      sig { params(node: SyntaxTree::TopConstField).void }
+      sig { override.params(node: SyntaxTree::TopConstField).void }
       def visit_top_const_field(node)
         create_document_symbol(
           name: node.constant.value,
           kind: :constant,
           range_node: node,
-          selection_range_node: node.constant
+          selection_range_node: node.constant,
         )
       end
 
-      sig { params(node: SyntaxTree::VarField).void }
+      sig { override.params(node: SyntaxTree::VarField).void }
       def visit_var_field(node)
         kind = case node.value
         when SyntaxTree::Const
@@ -214,7 +214,7 @@ module RubyLsp
           name: node.value.value,
           kind: kind,
           range_node: node,
-          selection_range_node: node.value
+          selection_range_node: node.value,
         )
       end
 
@@ -225,7 +225,7 @@ module RubyLsp
           name: String,
           kind: Symbol,
           range_node: SyntaxTree::Node,
-          selection_range_node: SyntaxTree::Node
+          selection_range_node: SyntaxTree::Node,
         ).returns(LanguageServer::Protocol::Interface::DocumentSymbol)
       end
       def create_document_symbol(name:, kind:, range_node:, selection_range_node:)

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -66,14 +66,17 @@ module RubyLsp
 
       sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::FoldingRange], Object)) }
       def run
-        visit(@document.tree)
-        emit_partial_range
+        if @document.parsed?
+          visit(@document.tree)
+          emit_partial_range
+        end
+
         @ranges
       end
 
       private
 
-      sig { params(node: T.nilable(SyntaxTree::Node)).void }
+      sig { override.params(node: T.nilable(SyntaxTree::Node)).void }
       def visit(node)
         return unless handle_partial_range(node)
 
@@ -137,7 +140,7 @@ module RubyLsp
           LanguageServer::Protocol::Interface::FoldingRange.new(
             start_line: @start_line,
             end_line: @end_line,
-            kind: @kind
+            kind: @kind,
           )
         end
 
@@ -248,7 +251,7 @@ module RubyLsp
         @ranges << LanguageServer::Protocol::Interface::FoldingRange.new(
           start_line: start_line - 1,
           end_line: end_line - 1,
-          kind: "region"
+          kind: "region",
         )
       end
     end

data/lib/ruby_lsp/requests/formatting.rb

@@ -42,9 +42,9 @@ module RubyLsp
           LanguageServer::Protocol::Interface::TextEdit.new(
             range: LanguageServer::Protocol::Interface::Range.new(
               start: LanguageServer::Protocol::Interface::Position.new(line: 0, character: 0),
-              end: LanguageServer::Protocol::Interface::Position.new(line: size, character: size)
+              end: LanguageServer::Protocol::Interface::Position.new(line: size, character: size),
             ),
-            new_text: formatted_text
+            new_text: formatted_text,
           ),
         ]
       end

data/lib/ruby_lsp/requests/hover.rb

@@ -0,0 +1,74 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "ruby_lsp/requests/support/rails_document_client"
+
+module RubyLsp
+  module Requests
+    # ![Hover demo](../../misc/rails_document_link_hover.gif)
+    #
+    # The [hover request](https://microsoft.github.io/language-server-protocol/specification#textDocument_hover)
+    # renders a clickable link to the code's official documentation.
+    # It currently only supports Rails' documentation: when hovering over Rails DSLs/constants under certain paths,
+    # like `before_save :callback` in `models/post.rb`, it generates a link to `before_save`'s API documentation.
+    #
+    # # Example
+    #
+    # ```ruby
+    # class Post < ApplicationRecord
+    #   before_save :do_something # when hovering on before_save, the link will be rendered
+    # end
+    # ```
+    class Hover < BaseRequest
+      extend T::Sig
+
+      sig { params(document: Document, position: Document::PositionShape).void }
+      def initialize(document, position)
+        super(document)
+
+        @position = T.let(Document::Scanner.new(document.source).find_position(position), Integer)
+      end
+
+      sig { override.returns(T.nilable(LanguageServer::Protocol::Interface::Hover)) }
+      def run
+        return unless @document.parsed?
+
+        target, _ = locate_node_and_parent(
+          T.must(@document.tree), [SyntaxTree::Command, SyntaxTree::FCall, SyntaxTree::ConstPathRef], @position
+        )
+
+        case target
+        when SyntaxTree::Command
+          message = target.message
+          generate_rails_document_link_hover(message.value, message)
+        when SyntaxTree::FCall
+          message = target.value
+          generate_rails_document_link_hover(message.value, message)
+        when SyntaxTree::ConstPathRef
+          constant_name = full_constant_name(target)
+          generate_rails_document_link_hover(constant_name, target)
+        end
+      end
+
+      private
+
+      sig do
+        params(name: String, node: SyntaxTree::Node).returns(T.nilable(LanguageServer::Protocol::Interface::Hover))
+      end
+      def generate_rails_document_link_hover(name, node)
+        urls = Support::RailsDocumentClient.generate_rails_document_urls(name)
+
+        return if urls.empty?
+
+        contents = LanguageServer::Protocol::Interface::MarkupContent.new(
+          kind: "markdown",
+          value: urls.join("\n\n"),
+        )
+        LanguageServer::Protocol::Interface::Hover.new(
+          range: range_from_syntax_tree_node(node),
+          contents: contents,
+        )
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -0,0 +1,56 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Inlay hint demo](../../misc/inlay_hint.gif)
+    #
+    # [Inlay hints](https://microsoft.github.io/language-server-protocol/specification#textDocument_inlayHint)
+    # are labels added directly in the code that explicitly show the user something that might
+    # otherwise just be implied.
+    #
+    # # Example
+    #
+    # ```ruby
+    # begin
+    #   puts "do something that might raise"
+    # rescue # Label "StandardError" goes here as a bare rescue implies rescuing StandardError
+    #   puts "handle some rescue"
+    # end
+    # ```
+    class InlayHints < BaseRequest
+      RESCUE_STRING_LENGTH = T.let("rescue".length, Integer)
+
+      sig { params(document: Document, range: T::Range[Integer]).void }
+      def initialize(document, range)
+        super(document)
+
+        @hints = T.let([], T::Array[LanguageServer::Protocol::Interface::InlayHint])
+        @range = range
+      end
+
+      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::InlayHint], Object)) }
+      def run
+        visit(@document.tree) if @document.parsed?
+        @hints
+      end
+
+      sig { override.params(node: SyntaxTree::Rescue).void }
+      def visit_rescue(node)
+        return unless node.exception.nil?
+
+        loc = node.location
+        return unless @range.cover?(loc.start_line - 1) && @range.cover?(loc.end_line - 1)
+
+        @hints << LanguageServer::Protocol::Interface::InlayHint.new(
+          position: { line: loc.start_line - 1, character: loc.start_column + RESCUE_STRING_LENGTH },
+          label: "StandardError",
+          padding_left: true,
+          tooltip: "StandardError is implied in a bare rescue",
+        )
+
+        super
+      end
+    end
+  end
+end