ruby-lsp 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0812eed9a874fa78fbe75cf2e8dc2bd58c2dfb67a61353f732aaba965ae9d66f'
-  data.tar.gz: 6d9a567aa54c95f5fd7ada3756d4b5575f068bee90f19f99f83f485d91de83a0
+  metadata.gz: c5d9c6b487aab55ce25eb2741fff92afa8ca0ee544f21374debacce7f887cc50
+  data.tar.gz: 8da9da85900753306f5e8558bc1a42f25b7173ffe1087ea70612c10ef5558e27
 SHA512:
-  metadata.gz: 53311978b0c6d32a34e1e69ddeea1d4b154ee0e2bc1cd426fd7e4db6ab46eeb7a5dff7d0516b5c2c722f95f05a0c5051fe7caf874e14740b5023b5f0e79da962
-  data.tar.gz: ce04150602707622dd0d463a35a2a9c94fe7b24b1e376dbeeae4e45f4487438219f8ab48056658946e9f7cc56136714496fdfbddf7513b77fea334aac2687ae3
+  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.1
+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/executor.rb

@@ -66,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",
@@ -197,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
@@ -259,6 +269,15 @@ module RubyLsp
           ),
         )
         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
@@ -300,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: {
@@ -311,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(
@@ -335,29 +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
 
-      code_action_provider = if enabled_features.include?("codeActions")
+      code_action_provider = if enabled_features["codeActions"]
         Interface::CodeActionOptions.new(resolve_provider: true)
       end
 
-      inlay_hint_provider = if enabled_features.include?("inlayHint")
+      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: ["/"],
@@ -370,14 +406,14 @@ 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"),
+          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,

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

@@ -30,6 +30,7 @@ module RubyLsp
       class Error < ::T::Enum
         enums do
           EmptySelection = new
+          InvalidTargetRange = new
         end
       end
 
@@ -45,11 +46,44 @@ module RubyLsp
         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])
-        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
+        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",
@@ -60,7 +94,10 @@ module RubyLsp
                   uri: @code_action.dig(:data, :uri),
                   version: nil,
                 ),
-                edits: edits_to_extract_variable(source_range, extraction_source, source_line_indentation),
+                edits: [
+                  create_text_edit(source_range, NEW_VARIABLE_NAME),
+                  create_text_edit(target_range, variable_source),
+                ],
               ),
             ],
           ),
@@ -69,22 +106,6 @@ module RubyLsp
 
       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(

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))) }
@@ -60,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/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/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.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-02-22 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'