ruby-lsp 0.14.0 → 0.14.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 846e8dec07f2ef860ee536f5031df7d38b43d60fa920edd8858d3231aea8dfdc
-  data.tar.gz: 423fe5ec4630332897a9a691c5fb7349c1c2f31e017fa1d5bbdc07a95f0c616d
+  metadata.gz: 293c03761c9b7d497045546e3bf7ca88a08ed5556ad0ba52c205a9798e820ce5
+  data.tar.gz: 38157f012f3f1dc944186ac1530dc660d8662cb59ca7b12ad3b117655e0c1709
 SHA512:
-  metadata.gz: aa20b2be3ee98080569821635324953270b40986c914c57737239e8879175ad3a31bb76094e27518249e6388d366575d0cef76a762cb108136fb54d1b47fe897
-  data.tar.gz: 5e3cd7e882c998001234cce3b08124148c4bffbf6b223d57b6eca9cef5d9128c2b8d460161fb1b4bbf13e77c9f2360cb98a903a24b82e739b754bf9e08b1ca00
+  metadata.gz: c4996e277088f015004df0f82e2cc47dc2f979f6658f9dfac19fe495c8c4deced3028b021e330ac0681dbfd79048e9033037c7ce93e6cc044c8ae6d91087e0df
+  data.tar.gz: 67c5c31c97c279f192b0b3d6c729c97a19f7aac4581eca037c0e5355cc0f3d3ed69fb4007a5f32985e046980324575e2e35a92ce81e8078b41ee5b6db711ac88

data/README.md

@@ -85,6 +85,9 @@ features. This is the mechanism that powers addons like
 - [Ruby LSP RSpec](https://github.com/st0012/ruby-lsp-rspec)
 - [Ruby LSP rubyfmt](https://github.com/jscharf/ruby-lsp-rubyfmt)
 
+Other community driven addons can be found in [rubygems](https://rubygems.org/search?query=name%3A+ruby-lsp) by
+searching for the `ruby-lsp` prefix.
+
 For instructions on how to create addons, see the [addons documentation](ADDONS.md).
 
 ## Learn More

data/VERSION

@@ -1 +1 @@
-0.14.0
+0.14.2

data/exe/ruby-lsp-doctor

@@ -6,6 +6,8 @@ require "ruby_lsp/internal"
 
 index = RubyIndexer::Index.new
 
+puts "Globbing for indexable files"
+
 RubyIndexer.configuration.indexables.each do |indexable|
   puts "indexing: #{indexable.full_path}"
   content = File.read(indexable.full_path)

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -237,9 +237,9 @@ module RubyIndexer
       real_parts.join("::")
     end
 
-    # Attempts to find a given method for a resolved fully qualified receiver name. Returns `nil` if the method does not
-    # exist on that receiver
-    sig { params(method_name: String, receiver_name: String).returns(T.nilable(Entry::Member)) }
+    # Attempts to find methods for a resolved fully qualified receiver name.
+    # Returns `nil` if the method does not exist on that receiver
+    sig { params(method_name: String, receiver_name: String).returns(T.nilable(T::Array[Entry::Member])) }
     def resolve_method(method_name, receiver_name)
       method_entries = self[method_name]
       owner_entries = self[receiver_name]
@@ -247,10 +247,10 @@ module RubyIndexer
 
       owner_name = T.must(owner_entries.first).name
       T.cast(
-        method_entries.grep(Entry::Member).find do |entry|
+        method_entries.grep(Entry::Member).select do |entry|
           T.cast(entry, Entry::Member).owner&.name == owner_name
         end,
-        T.nilable(Entry::Member),
+        T::Array[Entry::Member],
       )
     end
 

data/lib/ruby_indexer/test/index_test.rb

@@ -226,9 +226,9 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index.resolve_method("baz", "Foo::Bar"))
-      assert_equal("baz", entry.name)
-      assert_equal("Foo::Bar", T.must(entry.owner).name)
+      entries = T.must(@index.resolve_method("baz", "Foo::Bar"))
+      assert_equal("baz", entries.first.name)
+      assert_equal("Foo::Bar", T.must(entries.first.owner).name)
     end
 
     def test_resolve_method_with_class_name_conflict
@@ -241,9 +241,9 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index.resolve_method("Array", "Foo"))
-      assert_equal("Array", entry.name)
-      assert_equal("Foo", T.must(entry.owner).name)
+      entries = T.must(@index.resolve_method("Array", "Foo"))
+      assert_equal("Array", entries.first.name)
+      assert_equal("Foo", T.must(entries.first.owner).name)
     end
 
     def test_resolve_method_attribute
@@ -253,9 +253,33 @@ module RubyIndexer
         end
       RUBY
 
-      entry = T.must(@index.resolve_method("bar", "Foo"))
-      assert_equal("bar", entry.name)
-      assert_equal("Foo", T.must(entry.owner).name)
+      entries = T.must(@index.resolve_method("bar", "Foo"))
+      assert_equal("bar", entries.first.name)
+      assert_equal("Foo", T.must(entries.first.owner).name)
+    end
+
+    def test_resolve_method_with_two_definitions
+      index(<<~RUBY)
+        class Foo
+          # Hello from first `bar`
+          def bar; end
+        end
+
+        class Foo
+          # Hello from second `bar`
+          def bar; end
+        end
+      RUBY
+
+      first_entry, second_entry = T.must(@index.resolve_method("bar", "Foo"))
+
+      assert_equal("bar", first_entry.name)
+      assert_equal("Foo", T.must(first_entry.owner).name)
+      assert_includes(first_entry.comments, "Hello from first `bar`")
+
+      assert_equal("bar", second_entry.name)
+      assert_equal("Foo", T.must(second_entry.owner).name)
+      assert_includes(second_entry.comments, "Hello from second `bar`")
     end
 
     def test_prefix_search_for_methods

data/lib/ruby_lsp/addon.rb

@@ -25,21 +25,25 @@ module RubyLsp
 
     abstract!
 
+    @addons = T.let([], T::Array[Addon])
+    @addon_classes = T.let([], T::Array[T.class_of(Addon)])
+
     class << self
       extend T::Sig
 
+      sig { returns(T::Array[Addon]) }
+      attr_accessor :addons
+
+      sig { returns(T::Array[T.class_of(Addon)]) }
+      attr_reader :addon_classes
+
       # Automatically track and instantiate addon classes
       sig { params(child_class: T.class_of(Addon)).void }
       def inherited(child_class)
-        addons << child_class.new
+        addon_classes << child_class
         super
       end
 
-      sig { returns(T::Array[Addon]) }
-      def addons
-        @addons ||= T.let([], T.nilable(T::Array[Addon]))
-      end
-
       # Discovers and loads all addons. Returns the list of activated addons
       sig { params(message_queue: Thread::Queue).returns(T::Array[Addon]) }
       def load_addons(message_queue)
@@ -51,11 +55,13 @@ module RubyLsp
           $stderr.puts(e.full_message)
         end
 
+        # Instantiate all discovered addon classes
+        self.addons = addon_classes.map(&:new)
+
         # Activate each one of the discovered addons. If any problems occur in the addons, we don't want to
         # fail to boot the server
         addons.each do |addon|
           addon.activate(message_queue)
-          nil
         rescue => e
           addon.add_error(e)
         end

data/lib/ruby_lsp/internal.rb

@@ -7,13 +7,17 @@ yarp_require_paths = Gem.loaded_specs["yarp"]&.full_require_paths
 $LOAD_PATH.delete_if { |path| yarp_require_paths.include?(path) } if yarp_require_paths
 
 require "sorbet-runtime"
-require "prism"
-require "prism/visitor"
-require "language_server-protocol"
+
+# Set Bundler's UI level to silent as soon as possible to prevent any prints to STDOUT
 require "bundler"
+Bundler.ui.level = :silent
+
 require "uri"
 require "cgi"
 require "set"
+require "prism"
+require "prism/visitor"
+require "language_server-protocol"
 
 require "ruby-lsp"
 require "ruby_indexer/ruby_indexer"
@@ -29,5 +33,3 @@ require "ruby_lsp/ruby_document"
 require "ruby_lsp/store"
 require "ruby_lsp/addon"
 require "ruby_lsp/requests/support/rubocop_runner"
-
-Bundler.ui.level = :silent

data/lib/ruby_lsp/listeners/completion.rb

@@ -43,7 +43,9 @@ module RubyLsp
       def on_constant_read_node_enter(node)
         return if DependencyDetector.instance.typechecker
 
-        name = node.slice
+        name = constant_name(node)
+        return if name.nil?
+
         candidates = @index.prefix_search(name, @nesting)
         candidates.each do |entries|
           complete_name = T.must(entries.first).name
@@ -62,7 +64,8 @@ module RubyLsp
       def on_constant_path_node_enter(node)
         return if DependencyDetector.instance.typechecker
 
-        name = node.slice
+        name = constant_name(node)
+        return if name.nil?
 
         top_level_reference = if name.start_with?("::")
           name = name.delete_prefix("::")

data/lib/ruby_lsp/listeners/definition.rb

@@ -45,12 +45,18 @@ module RubyLsp
 
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
-        find_in_index(node.slice)
+        name = constant_name(node)
+        return if name.nil?
+
+        find_in_index(name)
       end
 
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
-        find_in_index(node.slice)
+        name = constant_name(node)
+        return if name.nil?
+
+        find_in_index(name)
       end
 
       private
@@ -62,20 +68,22 @@ module RubyLsp
         message = node.message
         return unless message
 
-        target_method = @index.resolve_method(message, @nesting.join("::"))
-        return unless target_method
+        methods = @index.resolve_method(message, @nesting.join("::"))
+        return unless methods
 
-        location = target_method.location
-        file_path = target_method.file_path
-        return if @typechecker_enabled && not_in_dependencies?(file_path)
+        methods.each do |target_method|
+          location = target_method.location
+          file_path = target_method.file_path
+          next if @typechecker_enabled && not_in_dependencies?(file_path)
 
-        @response_builder << Interface::Location.new(
-          uri: URI::Generic.from_path(path: file_path).to_s,
-          range: Interface::Range.new(
-            start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
-            end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
-          ),
-        )
+          @response_builder << Interface::Location.new(
+            uri: URI::Generic.from_path(path: file_path).to_s,
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
+              end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
+            ),
+          )
+        end
       end
 
       sig { params(node: Prism::CallNode).void }

data/lib/ruby_lsp/listeners/document_symbol.rb

@@ -25,6 +25,14 @@ module RubyLsp
           :on_call_node_enter,
           :on_constant_path_write_node_enter,
           :on_constant_write_node_enter,
+          :on_constant_path_or_write_node_enter,
+          :on_constant_path_operator_write_node_enter,
+          :on_constant_path_and_write_node_enter,
+          :on_constant_or_write_node_enter,
+          :on_constant_operator_write_node_enter,
+          :on_constant_and_write_node_enter,
+          :on_constant_target_node_enter,
+          :on_constant_path_target_node_enter,
           :on_def_node_enter,
           :on_def_node_leave,
           :on_module_node_enter,
@@ -98,6 +106,86 @@ module RubyLsp
         )
       end
 
+      sig { params(node: Prism::ConstantPathAndWriteNode).void }
+      def on_constant_path_and_write_node_enter(node)
+        create_document_symbol(
+          name: node.target.location.slice,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.target.location,
+        )
+      end
+
+      sig { params(node: Prism::ConstantPathOrWriteNode).void }
+      def on_constant_path_or_write_node_enter(node)
+        create_document_symbol(
+          name: node.target.location.slice,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.target.location,
+        )
+      end
+
+      sig { params(node: Prism::ConstantPathOperatorWriteNode).void }
+      def on_constant_path_operator_write_node_enter(node)
+        create_document_symbol(
+          name: node.target.location.slice,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.target.location,
+        )
+      end
+
+      sig { params(node: Prism::ConstantOrWriteNode).void }
+      def on_constant_or_write_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.name_loc,
+        )
+      end
+
+      sig { params(node: Prism::ConstantAndWriteNode).void }
+      def on_constant_and_write_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.name_loc,
+        )
+      end
+
+      sig { params(node: Prism::ConstantOperatorWriteNode).void }
+      def on_constant_operator_write_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.name_loc,
+        )
+      end
+
+      sig { params(node: Prism::ConstantTargetNode).void }
+      def on_constant_target_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.location,
+        )
+      end
+
+      sig { params(node: Prism::ConstantPathTargetNode).void }
+      def on_constant_path_target_node_enter(node)
+        create_document_symbol(
+          name: node.slice,
+          kind: Constant::SymbolKind::CONSTANT,
+          range_location: node.location,
+          selection_range_location: node.location,
+        )
+      end
+
       sig { params(node: Prism::DefNode).void }
       def on_def_node_leave(node)
         @response_builder.pop
@@ -206,23 +294,34 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode).void }
       def handle_attr_accessor(node)
-        return unless node.receiver.nil?
+        receiver = node.receiver
+        return if receiver && !receiver.is_a?(Prism::SelfNode)
 
         arguments = node.arguments
         return unless arguments
 
         arguments.arguments.each do |argument|
-          next unless argument.is_a?(Prism::SymbolNode)
-
-          name = argument.value
-          next unless name
-
-          create_document_symbol(
-            name: name,
-            kind: Constant::SymbolKind::FIELD,
-            range_location: argument.location,
-            selection_range_location: T.must(argument.value_loc),
-          )
+          if argument.is_a?(Prism::SymbolNode)
+            name = argument.value
+            next unless name
+
+            create_document_symbol(
+              name: name,
+              kind: Constant::SymbolKind::FIELD,
+              range_location: argument.location,
+              selection_range_location: T.must(argument.value_loc),
+            )
+          elsif argument.is_a?(Prism::StringNode)
+            name = argument.content
+            next if name.empty?
+
+            create_document_symbol(
+              name: name,
+              kind: Constant::SymbolKind::FIELD,
+              range_location: argument.location,
+              selection_range_location: argument.content_loc,
+            )
+          end
         end
       end
 

data/lib/ruby_lsp/listeners/hover.rb

@@ -55,7 +55,10 @@ module RubyLsp
       def on_constant_read_node_enter(node)
         return if @typechecker_enabled
 
-        generate_hover(node.slice, node.location)
+        name = constant_name(node)
+        return if name.nil?
+
+        generate_hover(name, node.location)
       end
 
       sig { params(node: Prism::ConstantWriteNode).void }
@@ -69,7 +72,10 @@ module RubyLsp
       def on_constant_path_node_enter(node)
         return if DependencyDetector.instance.typechecker
 
-        generate_hover(node.slice, node.location)
+        name = constant_name(node)
+        return if name.nil?
+
+        generate_hover(name, node.location)
       end
 
       sig { params(node: Prism::CallNode).void }
@@ -86,10 +92,10 @@ module RubyLsp
         message = node.message
         return unless message
 
-        target_method = @index.resolve_method(message, @nesting.join("::"))
-        return unless target_method
+        methods = @index.resolve_method(message, @nesting.join("::"))
+        return unless methods
 
-        categorized_markdown_from_index_entries(message, target_method).each do |category, content|
+        categorized_markdown_from_index_entries(message, methods).each do |category, content|
           @response_builder.push(content, category: category)
         end
       end

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -30,7 +30,10 @@ module RubyLsp
         message = node.message
         return unless message
 
-        target_method = @index.resolve_method(message, @nesting.join("::"))
+        methods = @index.resolve_method(message, @nesting.join("::"))
+        return unless methods
+
+        target_method = methods.first
         return unless target_method
 
         parameters = target_method.parameters
@@ -59,7 +62,7 @@ module RubyLsp
               parameters: parameters.map { |param| Interface::ParameterInformation.new(label: param.name) },
               documentation: Interface::MarkupContent.new(
                 kind: "markdown",
-                value: markdown_from_index_entries("", target_method),
+                value: markdown_from_index_entries("", methods),
               ),
             ),
           ],

data/lib/ruby_lsp/requests/code_lens.rb

@@ -11,12 +11,12 @@ module RubyLsp
     #
     # The
     # [code lens](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeLens)
-    # request informs the editor of runnable commands such as tests
+    # request informs the editor of runnable commands such as testing and debugging
     #
     # # Example
     #
     # ```ruby
-    # # Run
+    # # Run | Run in Terminal | Debug
     # class Test < Minitest::Test
     # end
     # ```

data/lib/ruby_lsp/requests/support/common.rb

@@ -132,6 +132,21 @@ module RubyLsp
             #{categorized_markdown[:documentation]}
           MARKDOWN
         end
+
+        sig do
+          params(
+            node: T.any(
+              Prism::ConstantPathNode,
+              Prism::ConstantReadNode,
+              Prism::ConstantPathTargetNode,
+            ),
+          ).returns(T.nilable(String))
+        end
+        def constant_name(node)
+          node.full_name
+        rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError
+          nil
+        end
       end
     end
   end

data/lib/ruby_lsp/setup_bundler.rb

@@ -57,15 +57,18 @@ module RubyLsp
     def setup!
       raise BundleNotLocked if @gemfile&.exist? && !@lockfile&.exist?
 
-      # Do not setup a custom bundle if both `ruby-lsp` and `debug` are already in the Gemfile
-      if @dependencies["ruby-lsp"] && @dependencies["debug"]
+      # Do not set up a custom bundle if LSP dependencies are already in the Gemfile
+      if @dependencies["ruby-lsp"] &&
+          @dependencies["debug"] &&
+          (@dependencies["rails"] ? @dependencies["ruby-lsp-rails"] : true)
         $stderr.puts(
-          "Ruby LSP> Skipping custom bundle setup since both `ruby-lsp` and `debug` are already in #{@gemfile}",
+          "Ruby LSP> Skipping custom bundle setup since LSP dependencies are already in #{@gemfile}",
         )
 
-        # If the user decided to add the `ruby-lsp` and `debug` to their Gemfile after having already run the Ruby LSP,
-        # then we need to remove the `.ruby-lsp` folder, otherwise we will run `bundle install` for the top level and
-        # try to execute the Ruby LSP using the custom bundle, which will fail since the gems are not installed there
+        # If the user decided to add `ruby-lsp` and `debug` (and potentially `ruby-lsp-rails`) to their Gemfile after
+        # having already run the Ruby LSP, then we need to remove the `.ruby-lsp` folder, otherwise we will run `bundle
+        # install` for the top level and try to execute the Ruby LSP using the custom bundle, which will fail since the
+        # gems are not installed there
         @custom_dir.rmtree if @custom_dir.exist?
         return run_bundle_install
       end
@@ -143,6 +146,10 @@ module RubyLsp
         parts << 'gem "debug", require: false, group: :development, platforms: :mri'
       end
 
+      if @dependencies["rails"] && !@dependencies["ruby-lsp-rails"]
+        parts << 'gem "ruby-lsp-rails", require: false, group: :development'
+      end
+
       content = parts.join("\n")
       @custom_gemfile.write(content) unless @custom_gemfile.exist? && @custom_gemfile.read == content
     end
@@ -183,22 +190,24 @@ module RubyLsp
       local_config_path = File.join(Dir.pwd, ".bundle")
       env["BUNDLE_APP_CONFIG"] = local_config_path if Dir.exist?(local_config_path)
 
-      # If both `ruby-lsp` and `debug` are already in the Gemfile, then we shouldn't try to upgrade them or else we'll
-      # produce undesired source control changes. If the custom bundle was just created and either `ruby-lsp` or `debug`
-      # weren't a part of the Gemfile, then we need to run `bundle install` for the first time to generate the
-      # Gemfile.lock with them included or else Bundler will complain that they're missing. We can only update if the
-      # custom `.ruby-lsp/Gemfile.lock` already exists and includes both gems
+      # If `ruby-lsp` and `debug` (and potentially `ruby-lsp-rails`) are already in the Gemfile, then we shouldn't try
+      # to upgrade them or else we'll produce undesired source control changes. If the custom bundle was just created
+      # and any of `ruby-lsp`, `ruby-lsp-rails` or `debug` weren't a part of the Gemfile, then we need to run `bundle
+      # install` for the first time to generate the Gemfile.lock with them included or else Bundler will complain that
+      # they're missing. We can only update if the custom `.ruby-lsp/Gemfile.lock` already exists and includes all gems
 
       # When not updating, we run `(bundle check || bundle install)`
       # When updating, we run `((bundle check && bundle update ruby-lsp debug) || bundle install)`
       command = +"(bundle check"
 
       if should_bundle_update?
-        # If ruby-lsp or debug are not in the Gemfile, try to update them to the latest version
+        # If any of `ruby-lsp`, `ruby-lsp-rails` or `debug` are not in the Gemfile, try to update them to the latest
+        # version
         command.prepend("(")
         command << " && bundle update "
         command << "ruby-lsp " unless @dependencies["ruby-lsp"]
         command << "debug " unless @dependencies["debug"]
+        command << "ruby-lsp-rails " if @dependencies["rails"] && !@dependencies["ruby-lsp-rails"]
         command << "--pre" if @experimental
         command.delete_suffix!(" ")
         command << ")"
@@ -221,13 +230,20 @@ module RubyLsp
 
     sig { returns(T::Boolean) }
     def should_bundle_update?
-      # If both `ruby-lsp` and `debug` are in the Gemfile, then we shouldn't try to upgrade them or else it will produce
-      # version control changes
-      return false if @dependencies["ruby-lsp"] && @dependencies["debug"]
+      # If `ruby-lsp`, `ruby-lsp-rails` and `debug` are in the Gemfile, then we shouldn't try to upgrade them or else it
+      # will produce version control changes
+      if @dependencies["rails"]
+        return false if @dependencies.values_at("ruby-lsp", "ruby-lsp-rails", "debug").all?
+
+        # If the custom lockfile doesn't include `ruby-lsp`, `ruby-lsp-rails` or `debug`, we need to run bundle install
+        # before updating
+        return false if custom_bundle_dependencies.values_at("ruby-lsp", "debug", "ruby-lsp-rails").any?(&:nil?)
+      else
+        return false if @dependencies.values_at("ruby-lsp", "debug").all?
 
-      # If the custom lockfile doesn't include either the `ruby-lsp` or `debug`, we need to run bundle install before
-      # updating
-      return false if custom_bundle_dependencies["ruby-lsp"].nil? || custom_bundle_dependencies["debug"].nil?
+        # If the custom lockfile doesn't include `ruby-lsp` or `debug`, we need to run bundle install before updating
+        return false if custom_bundle_dependencies.values_at("ruby-lsp", "debug").any?(&:nil?)
+      end
 
       # If the last updated file doesn't exist or was updated more than 4 hours ago, we should update
       !@last_updated_path.exist? || Time.parse(@last_updated_path.read) < (Time.now - FOUR_HOURS)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.14.2
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-02-08 00:00:00.000000000 Z
+date: 2024-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -30,20 +30,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.19.0
+        version: 0.22.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.22'
+        version: '0.25'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.19.0
+        version: 0.22.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.22'
+        version: '0.25'
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -159,6 +159,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
+  documentation_uri: https://shopify.github.io/ruby-lsp/
 post_install_message: 
 rdoc_options: []
 require_paths: