ruby-lsp 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65db08cd80bfe40116f70065b717ad88d1b1fd4fd86c6fcf1de2d5be9636ddce
-  data.tar.gz: 84a483aef0e88650a0b2bdbd0db0c3a5c1cd1cfff1e87508a09d7d4d8a616f36
+  metadata.gz: c5d9c6b487aab55ce25eb2741fff92afa8ca0ee544f21374debacce7f887cc50
+  data.tar.gz: 8da9da85900753306f5e8558bc1a42f25b7173ffe1087ea70612c10ef5558e27
 SHA512:
-  metadata.gz: 1ff522bae2c2d469c1fb5817c1b9ed65867ad19d64e00c0b14d4faa6b38bd62321c3109292f1021174766e2da240bd17faea1f8185672164307d2dafe88845bb
-  data.tar.gz: 7e89c4c38b833269e9d9a09f55333d32f6e1ef4872174d92e7b92a048cf51f62a837b7d9d4c217f3cccb9a196bb6d3b004439e4de8cc9e588c9b445a2f0c46e8
+  metadata.gz: 3dca630b9cae262f1af8d0aef0300ab7399dafd348db5f578ed7fdffb22a7afd48fe9467aa65e467fb50e16663f8fad32f1d0cc46b30819b06a6b7472700dcc0
+  data.tar.gz: f048c6c9fe14d20edefeca7ac504942af34c61699163f0d09ec54f4d80e7469e1bb1762757b96aa3d8d06a6e8168473dacfc932112b2d31ca4b380748eef8899

data/README.md

@@ -45,8 +45,9 @@ group :development do
 end
 ```
 
-If using VS Code, install the [Ruby LSP extension](https://github.com/Shopify/vscode-ruby-lsp) to get the extra features in
-the editor.
+If using VS Code, install the [Ruby LSP extension](https://github.com/Shopify/vscode-ruby-lsp) to get the extra features
+in the editor. See [editors](https://github.com/Shopify/ruby-lsp/blob/main/EDITORS.md) for community instructions on
+setting up the Ruby LSP in different editors.
 
 See the [documentation](https://shopify.github.io/ruby-lsp) for more in-depth details about the
 [supported features](https://shopify.github.io/ruby-lsp/RubyLsp/Requests.html).
@@ -114,27 +115,25 @@ To add a new expectations test runner for a new request handler:
 
 ## Debugging
 
-### Tracing LSP requests and responses
-
-LSP server tracing can be controlled through the `ruby lsp.trace.server` config key in the `.vscode/settings.json` config file.
-
-Possible values are:
-
-* `off`: no tracing
-* `messages`: display requests and responses notifications
-* `verbose`: display each request and response as JSON
-
-### Debugging using VS Code
-
-The `launch.json` contains a 'Minitest - current file' configuration for the debugger.
-
-1. Add a breakpoint using the VS Code UI.
-1. Open the relevant test file.
-1. Open the **Run and Debug** panel on the sidebar.
-1. Ensure `Minitest - current file` is selected in the top dropdown.
-1. Press `F5` OR click the green triangle next to the top dropdown. VS Code will then run the test file with debugger activated.
-1. When the breakpoint is triggered, the process will pause and VS Code will connect to the debugger and activate the debugger UI.
-1. Open the Debug Console view to use the debugger's REPL.
+### Debugging Tests
+
+1. Open the test file.
+2. Set a breakpoint(s) on lines by clicking next to their numbers.
+3. Open VS Code's `Run and Debug` panel.
+4. At the top of the panel, select `Minitset - current file` and click the green triangle (or press F5).
+
+### Debugging Running Ruby LSP Process
+
+1. Open the `vscode-ruby-lsp` project in VS Code.
+2. [`vscode-ruby-lsp`] Open VS Code's `Run and Debug` panel.
+3. [`vscode-ruby-lsp`] Select `Run Extension` and click the green triangle (or press F5).
+4. [`vscode-ruby-lsp`] Now VS Code will:
+    - Open another workspace as the `Extension Development Host`.
+    - Run `vscode-ruby-lsp` extension in debug mode, which will start a new `ruby-lsp` process with the `--debug` flag.
+5. Open `ruby-lsp` in VS Code.
+6. [`ruby-lsp`] Run `bin/rdbg -A` to connect to the running `ruby-lsp` process.
+7. [`ruby-lsp`] Use commands like `b <file>:<line>` or `b Class#method` to set breakpoints and type `c` to continue the process.
+8. In your `Extension Development Host` project (e.g. [`Tapioca`](https://github.com/Shopify/tapioca)), trigger the request that will hit the breakpoint.
 
 ## Spell Checking
 

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.4.2

data/exe/ruby-lsp

@@ -19,4 +19,16 @@ rescue
 end
 
 require_relative "../lib/ruby_lsp/internal"
+
+if ARGV.include?("--debug")
+  sockets_dir = "/tmp/ruby-lsp-debug-sockets"
+  Dir.mkdir(sockets_dir) unless Dir.exist?(sockets_dir)
+  # ruby-debug-ENV["USER"] is an implicit naming pattern in ruby/debug
+  # if it's not present, rdbg will not find the socket
+  socket_identifier = "ruby-debug-#{ENV["USER"]}-#{File.basename(Dir.pwd)}.sock"
+  ENV["RUBY_DEBUG_SOCK_PATH"] = "#{sockets_dir}/#{socket_identifier}"
+
+  require "debug/open_nonstop"
+end
+
 RubyLsp::Server.new.start

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"
@@ -63,6 +66,16 @@ module RubyLsp
       when "textDocument/formatting"
         begin
           formatting(uri)
+        rescue Requests::Formatting::InvalidFormatter => error
+          @notifications << Notification.new(
+            message: "window/showMessage",
+            params: Interface::ShowMessageParams.new(
+              type: Constant::MessageType::ERROR,
+              message: "Configuration error: #{error.message}",
+            ),
+          )
+
+          nil
         rescue StandardError => error
           @notifications << Notification.new(
             message: "window/showMessage",
@@ -84,6 +97,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)
@@ -192,7 +207,7 @@ module RubyLsp
 
     sig { params(uri: String).returns(T.nilable(T::Array[Interface::TextEdit])) }
     def formatting(uri)
-      Requests::Formatting.new(uri, @store.get(uri)).run
+      Requests::Formatting.new(uri, @store.get(uri), formatter: @store.formatter).run
     end
 
     sig do
@@ -233,11 +248,39 @@ 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
+      when Requests::CodeActionResolve::Error::InvalidTargetRange
+        @notifications << Notification.new(
+          message: "window/showMessage",
+          params: Interface::ShowMessageParams.new(
+            type: Constant::MessageType::ERROR,
+            message: "Couldn't find an appropriate location to place extracted refactor",
+          ),
+        )
+        raise Requests::CodeActionResolve::CodeActionError
+      else
+        result
+      end
     end
 
     sig { params(uri: String).returns(T.nilable(Interface::FullDocumentDiagnosticReport)) }
@@ -276,9 +319,26 @@ module RubyLsp
     def initialize_request(options)
       @store.clear
       @store.encoding = options.dig(:capabilities, :general, :positionEncodings)
-      enabled_features = options.dig(:initializationOptions, :enabledFeatures) || []
+      formatter = options.dig(:initializationOptions, :formatter)
+      @store.formatter = formatter unless formatter.nil?
+
+      configured_features = options.dig(:initializationOptions, :enabledFeatures)
+
+      enabled_features = case configured_features
+      when Array
+        # If the configuration is using an array, then absent features are disabled and present ones are enabled. That's
+        # why we use `false` as the default value
+        Hash.new(false).merge!(configured_features.to_h { |feature| [feature, true] })
+      when Hash
+        # If the configuration is already a hash, merge it with a default value of `true`. That way clients don't have
+        # to opt-in to every single feature
+        Hash.new(true).merge!(configured_features)
+      else
+        # If no configuration was passed by the client, just enable every feature
+        Hash.new(true)
+      end
 
-      document_symbol_provider = if enabled_features.include?("documentSymbols")
+      document_symbol_provider = if enabled_features["documentSymbols"]
         Interface::DocumentSymbolClientCapabilities.new(
           hierarchical_document_symbol_support: true,
           symbol_kind: {
@@ -287,19 +347,19 @@ module RubyLsp
         )
       end
 
-      document_link_provider = if enabled_features.include?("documentLink")
+      document_link_provider = if enabled_features["documentLink"]
         Interface::DocumentLinkOptions.new(resolve_provider: false)
       end
 
-      hover_provider = if enabled_features.include?("hover")
+      hover_provider = if enabled_features["hover"]
         Interface::HoverClientCapabilities.new(dynamic_registration: false)
       end
 
-      folding_ranges_provider = if enabled_features.include?("foldingRanges")
+      folding_ranges_provider = if enabled_features["foldingRanges"]
         Interface::FoldingRangeClientCapabilities.new(line_folding_only: true)
       end
 
-      semantic_tokens_provider = if enabled_features.include?("semanticHighlighting")
+      semantic_tokens_provider = if enabled_features["semanticHighlighting"]
         Interface::SemanticTokensRegistrationOptions.new(
           document_selector: { scheme: "file", language: "ruby" },
           legend: Interface::SemanticTokensLegend.new(
@@ -311,25 +371,29 @@ module RubyLsp
         )
       end
 
-      diagnostics_provider = if enabled_features.include?("diagnostics")
+      diagnostics_provider = if enabled_features["diagnostics"]
         {
           interFileDependencies: false,
           workspaceDiagnostics: false,
         }
       end
 
-      on_type_formatting_provider = if enabled_features.include?("onTypeFormatting")
+      on_type_formatting_provider = if enabled_features["onTypeFormatting"]
         Interface::DocumentOnTypeFormattingOptions.new(
           first_trigger_character: "{",
           more_trigger_character: ["\n", "|"],
         )
       end
 
-      inlay_hint_provider = if enabled_features.include?("inlayHint")
+      code_action_provider = if enabled_features["codeActions"]
+        Interface::CodeActionOptions.new(resolve_provider: true)
+      end
+
+      inlay_hint_provider = if enabled_features["inlayHint"]
         Interface::InlayHintOptions.new(resolve_provider: false)
       end
 
-      completion_provider = if enabled_features.include?("completion")
+      completion_provider = if enabled_features["completion"]
         Interface::CompletionOptions.new(
           resolve_provider: false,
           trigger_characters: ["/"],
@@ -342,15 +406,15 @@ module RubyLsp
             change: Constant::TextDocumentSyncKind::INCREMENTAL,
             open_close: true,
           ),
-          selection_range_provider: enabled_features.include?("selectionRanges"),
+          selection_range_provider: enabled_features["selectionRanges"],
           hover_provider: hover_provider,
           document_symbol_provider: document_symbol_provider,
           document_link_provider: document_link_provider,
           folding_range_provider: folding_ranges_provider,
           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"),
+          document_formatting_provider: enabled_features["formatting"] && formatter != "none",
+          document_highlight_provider: enabled_features["documentHighlights"],
+          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/internal.rb

@@ -5,6 +5,7 @@ require "sorbet-runtime"
 require "syntax_tree"
 require "language_server-protocol"
 require "benchmark"
+require "bundler"
 
 require "ruby-lsp"
 require "ruby_lsp/utils"

data/lib/ruby_lsp/requests/base_request.rb

@@ -28,6 +28,14 @@ module RubyLsp
       sig { abstract.returns(Object) }
       def run; end
 
+      # Syntax Tree implements `visit_all` using `map` instead of `each` for users who want to use the pattern
+      # `result = visitor.visit(tree)`. However, we don't use that pattern and should avoid producing a new array for
+      # every single node visited
+      sig { params(nodes: T::Array[SyntaxTree::Node]).void }
+      def visit_all(nodes)
+        nodes.each { |node| visit(node) }
+      end
+
       sig { params(node: SyntaxTree::Node).returns(LanguageServer::Protocol::Interface::Range) }
       def range_from_syntax_tree_node(node)
         loc = node.location
@@ -89,14 +97,15 @@ module RubyLsp
           # If the node's start character is already past the position, then we should've found the closest node already
           break if position < loc.start_char
 
+          # If there are node types to filter by, and the current node is not one of those types, then skip it
+          next if node_types.any? && node_types.none? { |type| candidate.is_a?(type) }
+
           # If the current node is narrower than or equal to the previous closest node, then it is more precise
           closest_loc = closest.location
           if loc.end_char - loc.start_char <= closest_loc.end_char - closest_loc.start_char
             parent = T.let(closest, SyntaxTree::Node)
             closest = candidate
           end
-
-          break if node_types.any? { |type| candidate.is_a?(type) }
         end
 
         [closest, parent]

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -0,0 +1,121 @@
+# 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
+          InvalidTargetRange = 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]
+
+        return Error::InvalidTargetRange if @document.syntax_error?
+
+        scanner = @document.create_scanner
+        start_index = scanner.find_char_position(source_range[:start])
+        end_index = scanner.find_char_position(source_range[:end])
+        extracted_source = T.must(@document.source[start_index...end_index])
+
+        # Find the closest statements node, so that we place the refactor in a valid position
+        closest_statements = locate(T.must(@document.tree), start_index, node_types: [SyntaxTree::Statements]).first
+        return Error::InvalidTargetRange if closest_statements.nil?
+
+        # Find the node with the end line closest to the requested position, so that we can place the refactor
+        # immediately after that closest node
+        closest_node = closest_statements.child_nodes.compact.min_by do |node|
+          distance = source_range.dig(:start, :line) - (node.location.end_line - 1)
+          distance <= 0 ? Float::INFINITY : distance
+        end
+
+        # When trying to extract the first node inside of a statements block, then we can just select one line above it
+        target_line = if closest_node == closest_statements.child_nodes.first
+          closest_node.location.start_line - 1
+        else
+          closest_node.location.end_line
+        end
+
+        lines = @document.source.lines
+        indentation = T.must(T.must(lines[target_line - 1])[/\A */]).size
+
+        target_range = {
+          start: { line: target_line, character: indentation },
+          end: { line: target_line, character: indentation },
+        }
+
+        variable_source = if T.must(lines[target_line]).strip.empty?
+          "\n#{" " * indentation}#{NEW_VARIABLE_NAME} = #{extracted_source}"
+        else
+          "#{NEW_VARIABLE_NAME} = #{extracted_source}\n#{" " * indentation}"
+        end
+
+        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: [
+                  create_text_edit(source_range, NEW_VARIABLE_NAME),
+                  create_text_edit(target_range, variable_source),
+                ],
+              ),
+            ],
+          ),
+        )
+      end
+
+      private
+
+      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/diagnostics.rb

@@ -34,7 +34,7 @@ module RubyLsp
         return unless defined?(Support::RuboCopDiagnosticsRunner)
 
         # Don't try to run RuboCop diagnostics for files outside the current working directory
-        return unless @uri.sub("file://", "").start_with?(Dir.pwd)
+        return unless @uri.start_with?(WORKSPACE_URI)
 
         Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document)
       end

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -108,7 +108,7 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::Command).void }
       def visit_command(node)
-        return unless ATTR_ACCESSORS.include?(node.message.value)
+        return visit(node.arguments) unless ATTR_ACCESSORS.include?(node.message.value)
 
         node.arguments.parts.each do |argument|
           next unless argument.is_a?(SyntaxTree::SymbolLiteral)

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -24,7 +24,6 @@ module RubyLsp
           SyntaxTree::BlockNode,
           SyntaxTree::Case,
           SyntaxTree::ClassDeclaration,
-          SyntaxTree::Command,
           SyntaxTree::For,
           SyntaxTree::HashLiteral,
           SyntaxTree::Heredoc,
@@ -100,6 +99,11 @@ module RubyLsp
             add_call_range(node)
             return
           end
+        when SyntaxTree::Command
+          unless same_lines_for_command_and_block?(node)
+            location = node.location
+            add_lines_range(location.start_line, location.end_line - 1)
+          end
         when SyntaxTree::DefNode
           add_def_range(node)
         when SyntaxTree::StringConcat
@@ -110,6 +114,17 @@ module RubyLsp
         super
       end
 
+      # This is to prevent duplicate ranges
+      sig { params(node: T.any(SyntaxTree::Command, SyntaxTree::CommandCall)).returns(T::Boolean) }
+      def same_lines_for_command_and_block?(node)
+        node_block = node.block
+        return false unless node_block
+
+        location = node.location
+        block_location = node_block.location
+        block_location.start_line == location.start_line && block_location.end_line == location.end_line
+      end
+
       class PartialRange
         extend T::Sig
 
@@ -223,9 +238,17 @@ module RubyLsp
           end
         end
 
-        add_lines_range(receiver.location.start_line, node.location.end_line - 1) if receiver
+        if receiver
+          unless node.is_a?(SyntaxTree::CommandCall) && same_lines_for_command_and_block?(node)
+            add_lines_range(
+              receiver.location.start_line,
+              node.location.end_line - 1,
+            )
+          end
+        end
 
         visit(node.arguments)
+        visit(node.block) if node.is_a?(SyntaxTree::CommandCall)
       end
 
       sig { params(node: SyntaxTree::DefNode).void }

data/lib/ruby_lsp/requests/formatting.rb

@@ -22,14 +22,23 @@ module RubyLsp
     # ```
     class Formatting < BaseRequest
       class Error < StandardError; end
+      class InvalidFormatter < StandardError; end
 
       extend T::Sig
 
-      sig { params(uri: String, document: Document).void }
-      def initialize(uri, document)
+      sig { params(uri: String, document: Document, formatter: String).void }
+      def initialize(uri, document, formatter: "auto")
         super(document)
 
         @uri = uri
+        @formatter = T.let(
+          if formatter == "auto"
+            defined?(Support::RuboCopFormattingRunner) ? "rubocop" : "syntax_tree"
+          else
+            formatter
+          end,
+          String,
+        )
       end
 
       sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
@@ -37,6 +46,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
 
@@ -58,10 +69,13 @@ module RubyLsp
 
       sig { returns(T.nilable(String)) }
       def formatted_file
-        if defined?(Support::RuboCopFormattingRunner)
+        case @formatter
+        when "rubocop"
           Support::RuboCopFormattingRunner.instance.run(@uri, @document)
-        else
+        when "syntax_tree"
           SyntaxTree.format(@document.source)
+        else
+          raise InvalidFormatter, "Unknown formatter: #{@formatter}"
         end
       end
     end

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/semantic_highlighting.rb

@@ -160,6 +160,7 @@ module RubyLsp
           add_token(node.message.location, :method)
         end
         visit(node.arguments)
+        visit(node.block)
       end
 
       sig { override.params(node: SyntaxTree::CommandCall).void }
@@ -169,6 +170,7 @@ module RubyLsp
         visit(node.receiver)
         add_token(node.message.location, :method)
         visit(node.arguments)
+        visit(node.block)
       end
 
       sig { override.params(node: SyntaxTree::Const).void }
@@ -236,13 +238,12 @@ module RubyLsp
 
         value = node.value
 
-        case value
-        when SyntaxTree::Ident
+        if value.is_a?(SyntaxTree::Ident)
           type = type_for_local(value)
           add_token(value.location, type)
-        else
-          visit(value)
         end
+
+        super
       end
 
       sig { override.params(node: SyntaxTree::VarRef).void }
@@ -260,16 +261,65 @@ module RubyLsp
         end
       end
 
+      # All block locals are variables. E.g.: [].each do |x; block_local|
+      sig { override.params(node: SyntaxTree::BlockVar).void }
+      def visit_block_var(node)
+        node.locals.each { |local| add_token(local.location, :variable) }
+        super
+      end
+
+      # All lambda locals are variables. E.g.: ->(x; lambda_local) {}
+      sig { override.params(node: SyntaxTree::LambdaVar).void }
+      def visit_lambda_var(node)
+        node.locals.each { |local| add_token(local.location, :variable) }
+        super
+      end
+
       sig { override.params(node: SyntaxTree::VCall).void }
       def visit_vcall(node)
         return super unless visible?(node, @range)
 
-        return if special_method?(node.value.value)
+        # A VCall may exist as a local in the current_scope. This happens when used named capture groups in a regexp
+        ident = node.value
+        value = ident.value
+        local = current_scope.find_local(value)
+        return if local.nil? && special_method?(value)
+
+        type = if local
+          :variable
+        elsif Support::Sorbet.annotation?(node)
+          :type
+        else
+          :method
+        end
 
-        type = Support::Sorbet.annotation?(node) ? :type : :method
         add_token(node.value.location, type)
       end
 
+      sig { override.params(node: SyntaxTree::Binary).void }
+      def visit_binary(node)
+        # It's important to visit the regexp first in the WithScope module
+        super
+
+        # You can only capture local variables with regexp by using the =~ operator
+        return unless node.operator == :=~
+
+        left = node.left
+        parts = left.parts
+
+        if left.is_a?(SyntaxTree::RegexpLiteral) && parts.one? && parts.first.is_a?(SyntaxTree::TStringContent)
+          content = parts.first
+
+          # For each capture name we find in the regexp, look for a local in the current_scope
+          Regexp.new(content.value, Regexp::FIXEDENCODING).names.each do |name|
+            local = current_scope.find_local(name)
+            next unless local
+
+            local.definitions.each { |definition| add_token(definition, :variable) }
+          end
+        end
+      end
+
       sig { override.params(node: SyntaxTree::ClassDeclaration).void }
       def visit_class(node)
         return super unless visible?(node, @range)

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

data/lib/ruby_lsp/store.rb

@@ -12,10 +12,14 @@ module RubyLsp
     sig { params(encoding: String).void }
     attr_writer :encoding
 
+    sig { returns(String) }
+    attr_accessor :formatter
+
     sig { void }
     def initialize
       @state = T.let({}, T::Hash[String, Document])
       @encoding = T.let("utf-8", String)
+      @formatter = T.let("auto", String)
     end
 
     sig { params(uri: String).returns(Document) }

data/lib/ruby_lsp/utils.rb

@@ -5,6 +5,9 @@ module RubyLsp
   # Used to indicate that a request shouldn't return a response
   VOID = T.let(Object.new.freeze, Object)
 
+  # This freeze is not redundant since the interpolated string is mutable
+  WORKSPACE_URI = T.let("file://#{Dir.pwd}".freeze, String) # rubocop:disable Style/RedundantFreeze
+
   # A notification to be sent to the client
   class Notification
     extend T::Sig

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-02-15 00:00:00.000000000 Z
+date: 2023-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -44,7 +44,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6'
+        version: 6.0.2
     - - "<"
       - !ruby/object:Gem::Version
         version: '7'
@@ -54,7 +54,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6'
+        version: 6.0.2
     - - "<"
       - !ruby/object:Gem::Version
         version: '7'
@@ -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