ruby-lsp 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65db08cd80bfe40116f70065b717ad88d1b1fd4fd86c6fcf1de2d5be9636ddce
-  data.tar.gz: 84a483aef0e88650a0b2bdbd0db0c3a5c1cd1cfff1e87508a09d7d4d8a616f36
+  metadata.gz: '0812eed9a874fa78fbe75cf2e8dc2bd58c2dfb67a61353f732aaba965ae9d66f'
+  data.tar.gz: 6d9a567aa54c95f5fd7ada3756d4b5575f068bee90f19f99f83f485d91de83a0
 SHA512:
-  metadata.gz: 1ff522bae2c2d469c1fb5817c1b9ed65867ad19d64e00c0b14d4faa6b38bd62321c3109292f1021174766e2da240bd17faea1f8185672164307d2dafe88845bb
-  data.tar.gz: 7e89c4c38b833269e9d9a09f55333d32f6e1ef4872174d92e7b92a048cf51f62a837b7d9d4c217f3cccb9a196bb6d3b004439e4de8cc9e588c9b445a2f0c46e8
+  metadata.gz: 53311978b0c6d32a34e1e69ddeea1d4b154ee0e2bc1cd426fd7e4db6ab46eeb7a5dff7d0516b5c2c722f95f05a0c5051fe7caf874e14740b5023b5f0e79da962
+  data.tar.gz: ce04150602707622dd0d463a35a2a9c94fe7b24b1e376dbeeae4e45f4487438219f8ab48056658946e9f7cc56136714496fdfbddf7513b77fea334aac2687ae3

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.4.1

data/lib/ruby_lsp/document.rb

@@ -21,9 +21,10 @@ module RubyLsp
       @encoding = T.let(encoding, String)
       @source = T.let(source, String)
       @unparsed_edits = T.let([], T::Array[EditShape])
+      @syntax_error = T.let(false, T::Boolean)
       @tree = T.let(SyntaxTree.parse(@source), T.nilable(SyntaxTree::Node))
     rescue SyntaxTree::Parser::ParseError
-      # Do not raise if we failed to parse
+      @syntax_error = true
     end
 
     sig { params(other: Document).returns(T::Boolean) }
@@ -68,14 +69,15 @@ module RubyLsp
       return if @unparsed_edits.empty?
 
       @tree = SyntaxTree.parse(@source)
+      @syntax_error = false
       @unparsed_edits.clear
     rescue SyntaxTree::Parser::ParseError
-      # Do nothing if we fail parse
+      @syntax_error = true
     end
 
     sig { returns(T::Boolean) }
     def syntax_error?
-      @unparsed_edits.any?
+      @syntax_error
     end
 
     sig { returns(T::Boolean) }

data/lib/ruby_lsp/executor.rb

@@ -37,6 +37,9 @@ module RubyLsp
       case request[:method]
       when "initialize"
         initialize_request(request.dig(:params))
+      when "initialized"
+        warn("Ruby LSP is ready")
+        VOID
       when "textDocument/didOpen"
         text_document_did_open(uri, request.dig(:params, :textDocument, :text))
       when "textDocument/didClose"
@@ -84,6 +87,8 @@ module RubyLsp
         inlay_hint(uri, request.dig(:params, :range))
       when "textDocument/codeAction"
         code_action(uri, request.dig(:params, :range), request.dig(:params, :context))
+      when "codeAction/resolve"
+        code_action_resolve(request.dig(:params))
       when "textDocument/diagnostic"
         begin
           diagnostic(uri)
@@ -233,11 +238,30 @@ module RubyLsp
       ).returns(T.nilable(T::Array[Interface::CodeAction]))
     end
     def code_action(uri, range, context)
-      start_line = range.dig(:start, :line)
-      end_line = range.dig(:end, :line)
       document = @store.get(uri)
 
-      Requests::CodeActions.new(uri, document, start_line..end_line, context).run
+      Requests::CodeActions.new(uri, document, range, context).run
+    end
+
+    sig { params(params: T::Hash[Symbol, T.untyped]).returns(Interface::CodeAction) }
+    def code_action_resolve(params)
+      uri = params.dig(:data, :uri)
+      document = @store.get(uri)
+      result = Requests::CodeActionResolve.new(document, params).run
+
+      case result
+      when Requests::CodeActionResolve::Error::EmptySelection
+        @notifications << Notification.new(
+          message: "window/showMessage",
+          params: Interface::ShowMessageParams.new(
+            type: Constant::MessageType::ERROR,
+            message: "Invalid selection for Extract Variable refactor",
+          ),
+        )
+        raise Requests::CodeActionResolve::CodeActionError
+      else
+        result
+      end
     end
 
     sig { params(uri: String).returns(T.nilable(Interface::FullDocumentDiagnosticReport)) }
@@ -325,6 +349,10 @@ module RubyLsp
         )
       end
 
+      code_action_provider = if enabled_features.include?("codeActions")
+        Interface::CodeActionOptions.new(resolve_provider: true)
+      end
+
       inlay_hint_provider = if enabled_features.include?("inlayHint")
         Interface::InlayHintOptions.new(resolve_provider: false)
       end
@@ -350,7 +378,7 @@ module RubyLsp
           semantic_tokens_provider: semantic_tokens_provider,
           document_formatting_provider: enabled_features.include?("formatting"),
           document_highlight_provider: enabled_features.include?("documentHighlights"),
-          code_action_provider: enabled_features.include?("codeActions"),
+          code_action_provider: code_action_provider,
           document_on_type_formatting_provider: on_type_formatting_provider,
           diagnostic_provider: diagnostics_provider,
           inlay_hint_provider: inlay_hint_provider,

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -0,0 +1,100 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Code action resolve demo](../../misc/code_action_resolve.gif)
+    #
+    # The [code action resolve](https://microsoft.github.io/language-server-protocol/specification#codeAction_resolve)
+    # request is used to to resolve the edit field for a given code action, if it is not already provided in the
+    # textDocument/codeAction response. We can use it for scenarios that require more computation such as refactoring.
+    #
+    # # Example: Extract to variable
+    #
+    # ```ruby
+    # # Before:
+    # 1 + 1 # Select the text and use Refactor: Extract Variable
+    #
+    # # After:
+    # new_variable = 1 + 1
+    # new_variable
+    #
+    # ```
+    #
+    class CodeActionResolve < BaseRequest
+      extend T::Sig
+      NEW_VARIABLE_NAME = "new_variable"
+
+      class CodeActionError < StandardError; end
+
+      class Error < ::T::Enum
+        enums do
+          EmptySelection = new
+        end
+      end
+
+      sig { params(document: Document, code_action: T::Hash[Symbol, T.untyped]).void }
+      def initialize(document, code_action)
+        super(document)
+
+        @code_action = code_action
+      end
+
+      sig { override.returns(T.any(Interface::CodeAction, Error)) }
+      def run
+        source_range = @code_action.dig(:data, :range)
+        return Error::EmptySelection if source_range[:start] == source_range[:end]
+
+        scanner = @document.create_scanner
+        start_index = scanner.find_char_position(source_range[:start])
+        end_index = scanner.find_char_position(source_range[:end])
+        extraction_source = T.must(@document.source[start_index...end_index])
+        source_line_indentation = T.must(T.must(@document.source.lines[source_range.dig(:start, :line)])[/\A */]).size
+
+        Interface::CodeAction.new(
+          title: "Refactor: Extract Variable",
+          edit: Interface::WorkspaceEdit.new(
+            document_changes: [
+              Interface::TextDocumentEdit.new(
+                text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: @code_action.dig(:data, :uri),
+                  version: nil,
+                ),
+                edits: edits_to_extract_variable(source_range, extraction_source, source_line_indentation),
+              ),
+            ],
+          ),
+        )
+      end
+
+      private
+
+      sig do
+        params(range: Document::RangeShape, source: String, indentation: Integer)
+          .returns(T::Array[Interface::TextEdit])
+      end
+      def edits_to_extract_variable(range, source, indentation)
+        target_range = {
+          start: { line: range.dig(:start, :line), character: indentation },
+          end: { line: range.dig(:start, :line), character: indentation },
+        }
+
+        [
+          create_text_edit(range, NEW_VARIABLE_NAME),
+          create_text_edit(target_range, "#{NEW_VARIABLE_NAME} = #{source}\n#{" " * indentation}"),
+        ]
+      end
+
+      sig { params(range: Document::RangeShape, new_text: String).returns(Interface::TextEdit) }
+      def create_text_edit(range, new_text)
+        Interface::TextEdit.new(
+          range: Interface::Range.new(
+            start: Interface::Position.new(line: range.dig(:start, :line), character: range.dig(:start, :character)),
+            end: Interface::Position.new(line: range.dig(:end, :line), character: range.dig(:end, :character)),
+          ),
+          new_text: new_text,
+        )
+      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: Document::RangeShape,
           context: T::Hash[Symbol, T.untyped],
         ).void
       end
@@ -38,9 +38,8 @@ module RubyLsp
       sig { override.returns(T.nilable(T.all(T::Array[Interface::CodeAction], Object))) }
       def run
         diagnostics = @context[:diagnostics]
-        return if diagnostics.nil? || diagnostics.empty?
 
-        diagnostics.filter_map do |diagnostic|
+        code_actions = diagnostics.filter_map do |diagnostic|
           code_action = diagnostic.dig(:data, :code_action)
           next if code_action.nil?
 
@@ -49,13 +48,30 @@ module RubyLsp
           range = code_action.dig(:edit, :documentChanges, 0, :edits, 0, :range)
           code_action if diagnostic.dig(:data, :correctable) && cover?(range)
         end
+
+        code_actions << refactor_code_action(@range, @uri)
       end
 
       private
 
       sig { params(range: T.nilable(Document::RangeShape)).returns(T::Boolean) }
       def cover?(range)
-        range.nil? || @range.cover?(range.dig(:start, :line)..range.dig(:end, :line))
+        range.nil? ||
+          ((@range.dig(:start, :line))..(@range.dig(:end, :line))).cover?(
+            (range.dig(:start, :line))..(range.dig(:end, :line)),
+          )
+      end
+
+      sig { params(range: Document::RangeShape, uri: String).returns(Interface::CodeAction) }
+      def refactor_code_action(range, uri)
+        Interface::CodeAction.new(
+          title: "Refactor: Extract Variable",
+          kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
+          data: {
+            range: range,
+            uri: uri,
+          },
+        )
       end
     end
   end

data/lib/ruby_lsp/requests/formatting.rb

@@ -37,6 +37,8 @@ module RubyLsp
         # Don't try to format files outside the current working directory
         return unless @uri.sub("file://", "").start_with?(Dir.pwd)
 
+        return if @document.syntax_error?
+
         formatted_text = formatted_file
         return unless formatted_text
 

data/lib/ruby_lsp/requests/path_completion.rb

@@ -21,17 +21,20 @@ module RubyLsp
         super(document)
 
         @tree = T.let(Support::PrefixTree.new(collect_load_path_files), Support::PrefixTree)
-
-        char_position = document.create_scanner.find_char_position(position)
-        @target = T.let(find(char_position), T.nilable(SyntaxTree::TStringContent))
+        @position = position
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::CompletionItem], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::CompletionItem], Object)) }
       def run
-        # no @target means the we are not inside a `require` call
-        return [] unless @target
+        # We can't verify if we're inside a require when there are syntax errors
+        return [] if @document.syntax_error?
+
+        char_position = @document.create_scanner.find_char_position(@position)
+        target = T.let(find(char_position), T.nilable(SyntaxTree::TStringContent))
+        # no target means the we are not inside a `require` call
+        return [] unless target
 
-        text = @target.value
+        text = target.value
         @tree.search(text).sort.map! do |path|
           build_completion(path, path.delete_prefix(text))
         end
@@ -73,14 +76,18 @@ module RubyLsp
         end
       end
 
-      sig do
-        params(label: String, insert_text: String).returns(LanguageServer::Protocol::Interface::CompletionItem)
-      end
+      sig { params(label: String, insert_text: String).returns(Interface::CompletionItem) }
       def build_completion(label, insert_text)
-        LanguageServer::Protocol::Interface::CompletionItem.new(
+        Interface::CompletionItem.new(
           label: label,
-          insert_text: insert_text,
-          kind: LanguageServer::Protocol::Constant::CompletionItemKind::REFERENCE,
+          text_edit: Interface::TextEdit.new(
+            range: Interface::Range.new(
+              start: @position,
+              end: @position,
+            ),
+            new_text: insert_text,
+          ),
+          kind: Constant::CompletionItemKind::REFERENCE,
         )
       end
     end

data/lib/ruby_lsp/requests.rb

@@ -14,6 +14,7 @@ module RubyLsp
   # - {RubyLsp::Requests::OnTypeFormatting}
   # - {RubyLsp::Requests::Diagnostics}
   # - {RubyLsp::Requests::CodeActions}
+  # - {RubyLsp::Requests::CodeActionResolve}
   # - {RubyLsp::Requests::DocumentHighlight}
   # - {RubyLsp::Requests::InlayHints}
   # - {RubyLsp::Requests::PathCompletion}
@@ -30,6 +31,7 @@ module RubyLsp
     autoload :OnTypeFormatting, "ruby_lsp/requests/on_type_formatting"
     autoload :Diagnostics, "ruby_lsp/requests/diagnostics"
     autoload :CodeActions, "ruby_lsp/requests/code_actions"
+    autoload :CodeActionResolve, "ruby_lsp/requests/code_action_resolve"
     autoload :DocumentHighlight, "ruby_lsp/requests/document_highlight"
     autoload :InlayHints, "ruby_lsp/requests/inlay_hints"
     autoload :PathCompletion, "ruby_lsp/requests/path_completion"

data/lib/ruby_lsp/server.rb

@@ -33,7 +33,7 @@ module RubyLsp
       # fall under the else branch which just pushes requests to the queue
       @reader.read do |request|
         case request[:method]
-        when "initialize", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
+        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
           result = Executor.new(@store).execute(request)
           finalize_request(result, request)
         when "$/cancelRequest"
@@ -56,6 +56,7 @@ module RubyLsp
           # We return zero if shutdown has already been received or one otherwise as per the recommendation in the spec
           # https://microsoft.github.io/language-server-protocol/specification/#exit
           status = @store.empty? ? 0 : 1
+          warn("Shutdown complete with status #{status}")
           exit(status)
         else
           # Default case: push the request to the queue to be executed by the worker

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-02-15 00:00:00.000000000 Z
+date: 2023-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -76,6 +76,7 @@ files:
 - lib/ruby_lsp/internal.rb
 - lib/ruby_lsp/requests.rb
 - lib/ruby_lsp/requests/base_request.rb
+- lib/ruby_lsp/requests/code_action_resolve.rb
 - lib/ruby_lsp/requests/code_actions.rb
 - lib/ruby_lsp/requests/diagnostics.rb
 - lib/ruby_lsp/requests/document_highlight.rb