ruby-lsp 0.3.3 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62174da68ba92c0af61878221168a02398c9b3df2867b63c063850b1787c7104
-  data.tar.gz: dc3d2e17e3fe2dcbb6578902eb3b672babc72d0f10511c021db767cfde709b0b
+  metadata.gz: 37a06a9c8be918e5c5a22986e68e378fc767f5c5becc46f79baa78d4b00c8c08
+  data.tar.gz: 4a79a4a39aaf59c49bddd6420e526246e31ade2a944ab314328f0a30da7661c2
 SHA512:
-  metadata.gz: c8295ce6739f9452dd20cab22ebb19fb099040f4782afa4dfd63b423b08ad73eedeb1fccc33113dcd7b27d38745e7112a6d272ea28652e00102a870c18c51b96
-  data.tar.gz: 1e1a2a681dcdf97bbb1f667211111b89ca274c1d89745bcd3cf8511fbc3d41416d0bb5a45f2fcaf85feb8b0469a5441b5500148136f849657d263531ffe5ff8a
+  metadata.gz: 698eaf5cf5d213f6a1ffce60e40f1a4e89d599132e1940699f3a98eb5de7b4141cb442338f97c3a35850a0ed239a52a8d27edaf8a59e7a1f169373a8c2fd9fa1
+  data.tar.gz: d5668dfd0c88482fbb6fab215b1782a2fcfc384504a485b8047fd28a99bb3b958de9bde80ecd213b30ae369bfb50d521c60d361e631d06e398f4efb5731e3158

data/VERSION

@@ -1 +1 @@
-0.3.3
+0.3.5

data/lib/ruby_lsp/document.rb

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

data/lib/ruby_lsp/requests/base_request.rb

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

data/lib/ruby_lsp/requests/document_highlight.rb

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

data/lib/ruby_lsp/requests/document_link.rb

@@ -31,7 +31,7 @@ module RubyLsp
       class << self
         extend T::Sig
 
-        sig { returns(T::Hash[String, T::Array[String]]) }
+        sig { returns(T::Hash[String, T::Hash[String, T::Hash[String, String]]]) }
         def gem_paths
           @gem_paths ||= T.let(begin
             lookup = {}
@@ -61,7 +61,7 @@ module RubyLsp
             end
 
             lookup
-          end, T.nilable(T::Hash[String, T::Array[String]]))
+          end, T.nilable(T::Hash[String, T::Hash[String, T::Hash[String, String]]]))
         end
       end
 
@@ -78,7 +78,7 @@ module RubyLsp
 
       sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentLink], Object)) }
       def run
-        visit(@document.tree)
+        visit(@document.tree) if @document.parsed?
         @links
       end
 
@@ -88,7 +88,7 @@ module RubyLsp
         return unless match
 
         uri = T.cast(URI(match[0]), URI::Source)
-        gem_version = resolve_version(uri)
+        gem_version = T.must(resolve_version(uri))
         file_path = self.class.gem_paths.dig(uri.gem_name, gem_version, uri.path)
         return if file_path.nil?
 

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -85,7 +85,7 @@ module RubyLsp
 
       sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol], Object)) }
       def run
-        visit(@document.tree)
+        visit(@document.tree) if @document.parsed?
         @root.children
       end
 

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -66,8 +66,11 @@ module RubyLsp
 
       sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::FoldingRange], Object)) }
       def run
-        visit(@document.tree)
-        emit_partial_range
+        if @document.parsed?
+          visit(@document.tree)
+          emit_partial_range
+        end
+
         @ranges
       end
 

data/lib/ruby_lsp/requests/hover.rb

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

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -31,7 +31,7 @@ module RubyLsp
 
       sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::InlayHint], Object)) }
       def run
-        visit(@document.tree)
+        visit(@document.tree) if @document.parsed?
         @hints
       end
 

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -70,7 +70,7 @@ module RubyLsp
 
       sig { override.returns(T.all(T::Array[Support::SelectionRange], Object)) }
       def run
-        visit(@document.tree)
+        visit(@document.tree) if @document.parsed?
         @ranges.reverse!
       end
 

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -20,6 +20,7 @@ module RubyLsp
     # ```
     class SemanticHighlighting < BaseRequest
       extend T::Sig
+      include SyntaxTree::WithEnvironment
 
       TOKEN_TYPES = T.let({
         namespace: 0,
@@ -94,6 +95,8 @@ module RubyLsp
         )
       end
       def run
+        return @tokens unless @document.parsed?
+
         visit(@tree)
         return @tokens unless @encoder
 
@@ -170,37 +173,52 @@ module RubyLsp
       def visit_params(node)
         node.keywords.each do |keyword,|
           location = keyword.location
-          add_token(location_without_colon(location), :variable)
+          add_token(location_without_colon(location), :parameter)
         end
 
         node.requireds.each do |required|
-          add_token(required.location, :variable)
+          add_token(required.location, :parameter)
         end
 
         rest = node.keyword_rest
-        return if rest.nil? || rest.is_a?(SyntaxTree::ArgsForward)
+        if rest && !rest.is_a?(SyntaxTree::ArgsForward)
+          name = rest.name
+          add_token(name.location, :parameter) if name
+        end
 
-        name = rest.name
-        add_token(name.location, :variable) if name
+        super
+      end
+
+      sig { override.params(node: SyntaxTree::Field).void }
+      def visit_field(node)
+        add_token(node.name.location, :method)
+
+        super
       end
 
       sig { override.params(node: SyntaxTree::VarField).void }
       def visit_var_field(node)
-        case node.value
+        value = node.value
+
+        case value
         when SyntaxTree::Ident
-          add_token(node.value.location, :variable)
+          type = type_for_local(value)
+          add_token(value.location, type)
         else
-          visit(node.value)
+          visit(value)
         end
       end
 
       sig { override.params(node: SyntaxTree::VarRef).void }
       def visit_var_ref(node)
-        case node.value
+        value = node.value
+
+        case value
         when SyntaxTree::Ident
-          add_token(node.value.location, :variable)
+          type = type_for_local(value)
+          add_token(value.location, type)
         else
-          visit(node.value)
+          visit(value)
         end
       end
 
@@ -261,6 +279,17 @@ module RubyLsp
       def special_method?(method_name)
         SPECIAL_RUBY_METHODS.include?(method_name)
       end
+
+      sig { params(value: SyntaxTree::Ident).returns(Symbol) }
+      def type_for_local(value)
+        local = current_environment.find_local(value.value)
+
+        if local.nil? || local.type == :variable
+          :variable
+        else
+          :parameter
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,114 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "net/http"
+
+module RubyLsp
+  module Requests
+    module Support
+      class RailsDocumentClient
+        RAILS_DOC_HOST = "https://api.rubyonrails.org"
+        SUPPORTED_RAILS_DOC_NAMESPACES = T.let(
+          Regexp.union(
+            /ActionDispatch/, /ActionController/, /AbstractController/, /ActiveRecord/, /ActiveModel/, /ActiveStorage/,
+            /ActionText/, /ActiveJob/
+          ).freeze,
+          Regexp,
+        )
+
+        RAILTIES_VERSION = T.let(
+          [*::Gem::Specification.default_stubs, *::Gem::Specification.stubs].find do |s|
+            s.name == "railties"
+          end&.version&.to_s, T.nilable(String)
+        )
+
+        class << self
+          extend T::Sig
+          sig do
+            params(name: String).returns(T::Array[String])
+          end
+          def generate_rails_document_urls(name)
+            docs = search_index&.fetch(name, nil)
+
+            return [] unless docs
+
+            docs.map do |doc|
+              owner = doc[:owner]
+
+              link_name =
+                # class/module name
+                if owner == name
+                  name
+                else
+                  "#{owner}##{name}"
+                end
+
+              "[Rails Document: `#{link_name}`](#{doc[:url]})"
+            end
+          end
+
+          sig { returns(T.nilable(T::Hash[String, T::Array[T::Hash[Symbol, String]]])) }
+          private def search_index
+            @rails_documents ||= T.let(
+              build_search_index,
+              T.nilable(T::Hash[String, T::Array[T::Hash[Symbol, String]]]),
+            )
+          end
+
+          sig { returns(T.nilable(T::Hash[String, T::Array[T::Hash[Symbol, String]]])) }
+          private def build_search_index
+            return unless RAILTIES_VERSION
+
+            $stderr.puts "Fetching Rails Documents..."
+            # If the version's doc is not found, e.g. Rails main, it'll be redirected
+            # In this case, we just fetch the latest doc
+            response = if Gem::Version.new(RAILTIES_VERSION).prerelease?
+              Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/js/search_index.js"))
+            else
+              Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/v#{RAILTIES_VERSION}/js/search_index.js"))
+            end
+
+            if response.code == "200"
+              process_search_index(response.body)
+            else
+              $stderr.puts("Response failed: #{response.inspect}")
+              nil
+            end
+          rescue StandardError => e
+            $stderr.puts("Exception occurred when fetching Rails document index: #{e.inspect}")
+          end
+
+          sig { params(js: String).returns(T::Hash[String, T::Array[T::Hash[Symbol, String]]]) }
+          private def process_search_index(js)
+            raw_data = js.sub("var search_data = ", "")
+            info = JSON.parse(raw_data).dig("index", "info")
+
+            # An entry looks like this:
+            #
+            # ["belongs_to",                                                              # method or module/class
+            #  "ActiveRecord::Associations::ClassMethods",                                # method owner
+            #  "classes/ActiveRecord/Associations/ClassMethods.html#method-i-belongs_to", # path to the document
+            #  "(name, scope = nil, **options)",                                          # method's parameters
+            #  "<p>Specifies a one-to-one association with another class..."]             # document preview
+            #
+            info.each_with_object({}) do |(method_or_class, method_owner, doc_path, _, doc_preview), table|
+              # If a method doesn't have documentation, there's no need to generate the link to it.
+              next if doc_preview.nil? || doc_preview.empty?
+
+              # If the method or class/module is not from the supported namespace, reject it
+              next unless [method_or_class, method_owner].any? do |elem|
+                            elem.match?(SUPPORTED_RAILS_DOC_NAMESPACES)
+                          end
+
+              owner = method_owner.empty? ? method_or_class : method_owner
+              table[method_or_class] ||= []
+              # It's possible to have multiple modules defining the same method name. For example,
+              # both `ActiveRecord::FinderMethods` and `ActiveRecord::Associations::CollectionProxy` defines `#find`
+              table[method_or_class] << { owner: owner, url: "#{RAILS_DOC_HOST}/v#{RAILTIES_VERSION}/#{doc_path}" }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests.rb

@@ -6,6 +6,7 @@ module RubyLsp
   #
   # - {RubyLsp::Requests::DocumentSymbol}
   # - {RubyLsp::Requests::DocumentLink}
+  # - {RubyLsp::Requests::Hover}
   # - {RubyLsp::Requests::FoldingRanges}
   # - {RubyLsp::Requests::SelectionRanges}
   # - {RubyLsp::Requests::SemanticHighlighting}
@@ -20,6 +21,7 @@ module RubyLsp
     autoload :BaseRequest, "ruby_lsp/requests/base_request"
     autoload :DocumentSymbol, "ruby_lsp/requests/document_symbol"
     autoload :DocumentLink, "ruby_lsp/requests/document_link"
+    autoload :Hover, "ruby_lsp/requests/hover"
     autoload :FoldingRanges, "ruby_lsp/requests/folding_ranges"
     autoload :SelectionRanges, "ruby_lsp/requests/selection_ranges"
     autoload :SemanticHighlighting, "ruby_lsp/requests/semantic_highlighting"
@@ -37,6 +39,7 @@ module RubyLsp
       autoload :SemanticTokenEncoder, "ruby_lsp/requests/support/semantic_token_encoder"
       autoload :SyntaxErrorDiagnostic, "ruby_lsp/requests/support/syntax_error_diagnostic"
       autoload :HighlightTarget, "ruby_lsp/requests/support/highlight_target"
+      autoload :RailsDocumentClient, "ruby_lsp/requests/support/rails_document_client"
     end
   end
 end

data/lib/ruby_lsp/server.rb

@@ -23,6 +23,10 @@ module RubyLsp
         Interface::DocumentLinkOptions.new(resolve_provider: false)
       end
 
+      hover_provider = if enabled_features.include?("hover")
+        Interface::HoverClientCapabilities.new(dynamic_registration: false)
+      end
+
       folding_ranges_provider = if enabled_features.include?("foldingRanges")
         Interface::FoldingRangeClientCapabilities.new(line_folding_only: true)
       end
@@ -66,6 +70,7 @@ module RubyLsp
             open_close: true,
           ),
           selection_range_provider: enabled_features.include?("selectionRanges"),
+          hover_provider: hover_provider,
           document_symbol_provider: document_symbol_provider,
           document_link_provider: document_link_provider,
           folding_range_provider: folding_ranges_provider,
@@ -116,6 +121,13 @@ module RubyLsp
       end
     end
 
+    on("textDocument/hover") do |request|
+      position = request.dig(:params, :position)
+      document = store.get(request.dig(:params, :textDocument, :uri))
+
+      RubyLsp::Requests::Hover.new(document, position).run
+    end
+
     on("textDocument/foldingRange", parallel: true) do |request|
       store.cache_fetch(request.dig(:params, :textDocument, :uri), :folding_ranges) do |document|
         Requests::FoldingRanges.new(document).run
@@ -175,9 +187,7 @@ module RubyLsp
     on("textDocument/documentHighlight", parallel: true) do |request|
       document = store.get(request.dig(:params, :textDocument, :uri))
 
-      if document.parsed?
-        Requests::DocumentHighlight.new(document, request.dig(:params, :position)).run
-      end
+      Requests::DocumentHighlight.new(document, request.dig(:params, :position)).run
     end
 
     on("textDocument/codeAction", parallel: true) do |request|
@@ -197,9 +207,7 @@ module RubyLsp
       start_line = range.dig(:start, :line)
       end_line = range.dig(:end, :line)
 
-      if document.parsed?
-        Requests::InlayHints.new(document, start_line..end_line).run
-      end
+      Requests::InlayHints.new(document, start_line..end_line).run
     end
 
     on("$/cancelRequest") do |request|

data/lib/ruby_lsp/store.rb

@@ -55,13 +55,10 @@ module RubyLsp
           uri: String,
           request_name: Symbol,
           block: T.proc.params(document: Document).returns(T.type_parameter(:T)),
-        ).returns(T.nilable(T.type_parameter(:T)))
+        ).returns(T.type_parameter(:T))
     end
     def cache_fetch(uri, request_name, &block)
-      document = get(uri)
-      return unless document.parsed?
-
-      document.cache_fetch(request_name, &block)
+      get(uri).cache_fetch(request_name, &block)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.5
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-10-03 00:00:00.000000000 Z
+date: 2022-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: 4.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: 4.0.2
 description: An opinionated language server for Ruby
 email:
 - ruby@shopify.com
@@ -78,11 +78,13 @@ files:
 - lib/ruby_lsp/requests/document_symbol.rb
 - lib/ruby_lsp/requests/folding_ranges.rb
 - lib/ruby_lsp/requests/formatting.rb
+- lib/ruby_lsp/requests/hover.rb
 - lib/ruby_lsp/requests/inlay_hints.rb
 - lib/ruby_lsp/requests/on_type_formatting.rb
 - lib/ruby_lsp/requests/selection_ranges.rb
 - lib/ruby_lsp/requests/semantic_highlighting.rb
 - lib/ruby_lsp/requests/support/highlight_target.rb
+- lib/ruby_lsp/requests/support/rails_document_client.rb
 - lib/ruby_lsp/requests/support/rubocop_diagnostic.rb
 - lib/ruby_lsp/requests/support/rubocop_diagnostics_runner.rb
 - lib/ruby_lsp/requests/support/rubocop_formatting_runner.rb