ruby-lsp 0.4.3 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7bf79fd6cdc704c8f874f58985f0e72ac034c76bb70a68166654185f6f00cf1
-  data.tar.gz: '083edc726c05ffb6e5e3ae63d480b17fa0f7161ee62349665cc57e309acd5598'
+  metadata.gz: 61c8fe2a55057823533a8a17b4472309e3d463ec3d63302fa3393f046ec4b339
+  data.tar.gz: fb9636b8aafac9d5002a872d0f34f7f9852e9348009cdc2934369637a4cadb4c
 SHA512:
-  metadata.gz: f6192daf27dfd82dbb505f5184eebd66308690ce10ead4d4cedc4d9c6667be882a8b9de4c87e66eb88ff43e896307be24bbcc6506b0544b496e1bcb3c9804498
-  data.tar.gz: bb68928d9a72b3b2873509bf915f753a202a520187bf5f55da1870d552e0ba0917a7d21ea70d20853ac60aa614f7d85d117d7291ec9c0778cab80e4561a7aba0
+  metadata.gz: db51fd5526431b773125c0b27bfe8ca53b2861759457f9a36e7a681bcfbffb0f58026b4f8cc4dc991be2380309959aacde7c8cc2cd0a0f0373dfb313d0d28db9
+  data.tar.gz: 13cc3991bffd1a18dd1e2580c8d1051161b03a171a25e8ce681f46fb8d5baedb1de0f9f96304556e08f3db95c2262e29693d22bf3659ba45eff620157adc035c

data/README.md

@@ -44,6 +44,7 @@ See the [documentation](https://shopify.github.io/ruby-lsp) for more in-depth de
 ## Learn More
 
 * [RubyConf 2022: Improving the development experience with language servers](https://www.youtube.com/watch?v=kEfXPTm1aCI) ([Vinicius Stock](https://github.com/vinistock))
+* [Remote Ruby: Ruby Language Server with Vinicius Stock](https://remoteruby.com/221)
 
 ## Contributing
 

data/VERSION

@@ -1 +1 @@
-0.4.3
+0.4.4

data/lib/ruby_lsp/document.rb

@@ -22,7 +22,7 @@ module RubyLsp
     attr_reader :uri
 
     sig { params(source: String, version: Integer, uri: String, encoding: String).void }
-    def initialize(source:, version:, uri:, encoding: "utf-8")
+    def initialize(source:, version:, uri:, encoding: Constant::PositionEncodingKind::UTF8)
       @cache = T.let({}, T::Hash[Symbol, T.untyped])
       @encoding = T.let(encoding, String)
       @source = T.let(source, String)
@@ -77,9 +77,9 @@ module RubyLsp
     def parse
       return if @unparsed_edits.empty?
 
+      @unparsed_edits.clear
       @tree = SyntaxTree.parse(@source)
       @syntax_error = false
-      @unparsed_edits.clear
     rescue SyntaxTree::Parser::ParseError
       @syntax_error = true
     end
@@ -99,6 +99,61 @@ module RubyLsp
       Scanner.new(@source, @encoding)
     end
 
+    sig do
+      params(
+        position: PositionShape,
+        node_types: T::Array[T.class_of(SyntaxTree::Node)],
+      ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node)])
+    end
+    def locate_node(position, node_types: [])
+      return [nil, nil] unless parsed?
+
+      locate(T.must(@tree), create_scanner.find_char_position(position))
+    end
+
+    sig do
+      params(
+        node: SyntaxTree::Node,
+        char_position: Integer,
+        node_types: T::Array[T.class_of(SyntaxTree::Node)],
+      ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node)])
+    end
+    def locate(node, char_position, node_types: [])
+      queue = T.let(node.child_nodes.compact, T::Array[T.nilable(SyntaxTree::Node)])
+      closest = node
+      parent = T.let(nil, T.nilable(SyntaxTree::Node))
+
+      until queue.empty?
+        candidate = queue.shift
+
+        # Skip nil child nodes
+        next if candidate.nil?
+
+        # Add the next child_nodes to the queue to be processed
+        queue.concat(candidate.child_nodes)
+
+        # Skip if the current node doesn't cover the desired position
+        loc = candidate.location
+        next unless (loc.start_char...loc.end_char).cover?(char_position)
+
+        # If the node's start character is already past the position, then we should've found the closest node
+        # already
+        break if char_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.class == 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 = closest
+          closest = candidate
+        end
+      end
+
+      [closest, parent]
+    end
+
     class Scanner
       extend T::Sig
 
@@ -127,7 +182,11 @@ module RubyLsp
         # The final position is the beginning of the line plus the requested column. If the encoding is UTF-16, we also
         # need to adjust for surrogate pairs
         requested_position = @pos + position[:character]
-        requested_position -= utf_16_character_position_correction(@pos, requested_position) if @encoding == "utf-16"
+
+        if @encoding == Constant::PositionEncodingKind::UTF16
+          requested_position -= utf_16_character_position_correction(@pos, requested_position)
+        end
+
         requested_position
       end
 

data/lib/ruby_lsp/event_emitter.rb

@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  # EventEmitter is an intermediary between our requests and Syntax Tree visitors. It's used to visit the document's AST
+  # and emit events that the requests can listen to for providing functionality. Usages:
+  #
+  # - For positional requests, locate the target node and use `emit_for_target` to fire events for each listener
+  # - For nonpositional requests, use `visit` to go through the AST, which will fire events for each listener as nodes
+  # are found
+  #
+  # = Example
+  #
+  # ```ruby
+  # target_node = document.locate_node(position)
+  # listener = Requests::Hover.new
+  # EventEmitter.new(listener).emit_for_target(target_node)
+  # listener.response
+  # ```
+  class EventEmitter < SyntaxTree::Visitor
+    extend T::Sig
+
+    sig { params(listeners: Listener[T.untyped]).void }
+    def initialize(*listeners)
+      @listeners = listeners
+
+      # Create a map of event name to listeners that have registered it, so that we avoid unnecessary invocations
+      @event_to_listener_map = T.let(
+        listeners.each_with_object(Hash.new { |h, k| h[k] = [] }) do |listener, hash|
+          listener.class.events&.each { |event| hash[event] << listener }
+        end,
+        T::Hash[Symbol, T::Array[Listener[T.untyped]]],
+      )
+
+      super()
+    end
+
+    # Emit events for a specific node. This is similar to the regular `visit` method, but avoids going deeper into the
+    # tree for performance
+    sig { params(node: T.nilable(SyntaxTree::Node)).void }
+    def emit_for_target(node)
+      case node
+      when SyntaxTree::Command
+        @event_to_listener_map[:on_command]&.each { |listener| T.unsafe(listener).on_command(node) }
+      when SyntaxTree::CallNode
+        @event_to_listener_map[:on_call]&.each { |listener| T.unsafe(listener).on_call(node) }
+      when SyntaxTree::ConstPathRef
+        @event_to_listener_map[:on_const_path_ref]&.each { |listener| T.unsafe(listener).on_const_path_ref(node) }
+      end
+    end
+  end
+end

data/lib/ruby_lsp/executor.rb

@@ -123,6 +123,8 @@ module RubyLsp
         end
       when "textDocument/completion"
         completion(uri, request.dig(:params, :position))
+      when "textDocument/codeLens"
+        code_lens(uri)
       end
     end
 
@@ -133,6 +135,13 @@ module RubyLsp
       end
     end
 
+    sig { params(uri: String).returns(T::Array[Interface::CodeLens]) }
+    def code_lens(uri)
+      @store.cache_fetch(uri, :code_lens) do |document|
+        Requests::CodeLens.new(document).run
+      end
+    end
+
     sig do
       params(
         uri: String,
@@ -140,7 +149,20 @@ module RubyLsp
       ).returns(T.nilable(Interface::Hover))
     end
     def hover(uri, position)
-      RubyLsp::Requests::Hover.new(@store.get(uri), position).run
+      document = @store.get(uri)
+      document.parse
+      return if document.syntax_error?
+
+      target, parent = document.locate_node(position)
+
+      if !Requests::Hover::ALLOWED_TARGETS.include?(target.class) &&
+          Requests::Hover::ALLOWED_TARGETS.include?(parent.class)
+        target = parent
+      end
+
+      listener = RubyLsp::Requests::Hover.new
+      EventEmitter.new(listener).emit_for_target(target)
+      listener.response
     end
 
     sig { params(uri: String).returns(T::Array[Interface::DocumentLink]) }
@@ -326,11 +348,21 @@ module RubyLsp
     sig { params(options: T::Hash[Symbol, T.untyped]).returns(Interface::InitializeResult) }
     def initialize_request(options)
       @store.clear
-      @store.encoding = options.dig(:capabilities, :general, :positionEncodings)
+
+      encodings = options.dig(:capabilities, :general, :positionEncodings)
+      @store.encoding = if encodings.nil? || encodings.empty?
+        Constant::PositionEncodingKind::UTF16
+      elsif encodings.include?(Constant::PositionEncodingKind::UTF8)
+        Constant::PositionEncodingKind::UTF8
+      else
+        encodings.first
+      end
+
       formatter = options.dig(:initializationOptions, :formatter)
       @store.formatter = formatter unless formatter.nil?
 
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
+      experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled)
 
       enabled_features = case configured_features
       when Array
@@ -359,6 +391,10 @@ module RubyLsp
         Interface::DocumentLinkOptions.new(resolve_provider: false)
       end
 
+      code_lens_provider = if experimental_features
+        Interface::CodeLensOptions.new(resolve_provider: false)
+      end
+
       hover_provider = if enabled_features["hover"]
         Interface::HoverClientCapabilities.new(dynamic_registration: false)
       end
@@ -414,6 +450,7 @@ module RubyLsp
             change: Constant::TextDocumentSyncKind::INCREMENTAL,
             open_close: true,
           ),
+          position_encoding: @store.encoding,
           selection_range_provider: enabled_features["selectionRanges"],
           hover_provider: hover_provider,
           document_symbol_provider: document_symbol_provider,
@@ -427,6 +464,7 @@ module RubyLsp
           diagnostic_provider: diagnostics_provider,
           inlay_hint_provider: inlay_hint_provider,
           completion_provider: completion_provider,
+          code_lens_provider: code_lens_provider,
         ),
       )
     end

data/lib/ruby_lsp/internal.rb

@@ -11,5 +11,7 @@ require "ruby-lsp"
 require "ruby_lsp/utils"
 require "ruby_lsp/server"
 require "ruby_lsp/executor"
+require "ruby_lsp/event_emitter"
 require "ruby_lsp/requests"
+require "ruby_lsp/listener"
 require "ruby_lsp/store"

data/lib/ruby_lsp/listener.rb

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  # Listener is an abstract class to be used by requests for listening to events emitted when visiting an AST using the
+  # EventEmitter.
+  class Listener
+    extend T::Sig
+    extend T::Helpers
+    extend T::Generic
+    include Requests::Support::Common
+
+    ResponseType = type_member
+
+    abstract!
+
+    class << self
+      extend T::Sig
+
+      sig { returns(T.nilable(T::Array[Symbol])) }
+      attr_reader :events
+
+      # All listener events must be defined inside of a `listener_events` block. This is to ensure we know which events
+      # have been registered. Defining an event outside of this block will simply not register it and it'll never be
+      # invoked
+      sig { params(block: T.proc.void).void }
+      def listener_events(&block)
+        current_methods = instance_methods
+        block.call
+        @events = T.let(instance_methods - current_methods, T.nilable(T::Array[Symbol]))
+      end
+    end
+
+    # Override this method with an attr_reader that returns the response of your listener. The listener should
+    # accumulate results in a @response variable and then provide the reader so that it is accessible
+    sig { abstract.returns(ResponseType) }
+    def response; end
+  end
+end

data/lib/ruby_lsp/requests/base_request.rb

@@ -7,6 +7,7 @@ module RubyLsp
     class BaseRequest < SyntaxTree::Visitor
       extend T::Sig
       extend T::Helpers
+      include Support::Common
 
       abstract!
 
@@ -31,94 +32,10 @@ module RubyLsp
       # 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 }
+      sig { params(nodes: T::Array[T.nilable(SyntaxTree::Node)]).void }
       def visit_all(nodes)
         nodes.each { |node| visit(node) }
       end
-
-      sig { params(node: SyntaxTree::Node).returns(Interface::Range) }
-      def range_from_syntax_tree_node(node)
-        loc = node.location
-
-        Interface::Range.new(
-          start: Interface::Position.new(
-            line: loc.start_line - 1,
-            character: loc.start_column,
-          ),
-          end: Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
-        )
-      end
-
-      sig do
-        params(node: T.any(SyntaxTree::ConstPathRef, SyntaxTree::ConstRef, SyntaxTree::TopConstRef)).returns(String)
-      end
-      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(
-          node: SyntaxTree::Node,
-          position: Integer,
-          node_types: T::Array[T.class_of(SyntaxTree::Node)],
-        ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node)])
-      end
-      def locate(node, position, node_types: [])
-        queue = T.let(node.child_nodes.compact, T::Array[T.nilable(SyntaxTree::Node)])
-        closest = node
-
-        until queue.empty?
-          candidate = queue.shift
-
-          # Skip nil child nodes
-          next if candidate.nil?
-
-          # Add the next child_nodes to the queue to be processed
-          queue.concat(candidate.child_nodes)
-
-          # Skip if the current node doesn't cover the desired position
-          loc = candidate.location
-          next unless (loc.start_char...loc.end_char).cover?(position)
-
-          # 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
-        end
-
-        [closest, parent]
-      end
-
-      sig { params(node: T.nilable(SyntaxTree::Node), range: T.nilable(T::Range[Integer])).returns(T::Boolean) }
-      def visible?(node, range)
-        return true if range.nil?
-        return false if node.nil?
-
-        loc = node.location
-        range.cover?(loc.start_line - 1) && range.cover?(loc.end_line - 1)
-      end
     end
   end
 end

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -54,7 +54,8 @@ module RubyLsp
         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
+        closest_statements, parent_statements = @document
+          .locate(T.must(@document.tree), start_index, node_types: [SyntaxTree::Statements])
         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
@@ -64,25 +65,51 @@ module RubyLsp
           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
+        # Find the parent expression of the closest node
+        parent_expression = parent_statements.child_nodes.compact.find do |node|
+          loc = node.location
+          loc.start_line - 1 <= source_range.dig(:start, :line) && loc.end_line - 1 >= source_range.dig(:end, :line)
+        end if parent_statements
+
+        closest_node_loc = closest_node.location
+        # If the parent expression is a single line block, then we have to extract it inside of the oneline block
+        if parent_expression.is_a?(SyntaxTree::MethodAddBlock) &&
+            parent_expression.location.start_line == parent_expression.location.end_line
+
+          variable_source = " #{NEW_VARIABLE_NAME} = #{extracted_source};"
+          character = source_range.dig(:start, :character) - 1
+          target_range = {
+            start: { line: closest_node_loc.end_line - 1, character: character },
+            end: { line: closest_node_loc.end_line - 1, character: character },
+          }
         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}"
+          # If the closest node covers the requested location, then we're extracting a statement nested inside of it. In
+          # that case, we want to place the extraction at the start of the closest node (one line above). Otherwise, we
+          # want to place the extract right below the closest node
+          if closest_node_loc.start_line - 1 <= source_range.dig(
+            :start,
+            :line,
+          ) && closest_node_loc.end_line - 1 >= source_range.dig(:end, :line)
+            indentation_line = closest_node_loc.start_line - 1
+            target_line = indentation_line
+          else
+            target_line = closest_node_loc.end_line
+            indentation_line = closest_node_loc.end_line - 1
+          end
+
+          lines = @document.source.lines
+          indentation = T.must(T.must(lines[indentation_line])[/\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
         end
 
         Interface::CodeAction.new(

data/lib/ruby_lsp/requests/code_lens.rb

@@ -0,0 +1,135 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Code lens demo](../../misc/code_lens.gif)
+    #
+    # This feature is currently experimental. Clients will need to pass `experimentalFeaturesEnabled`
+    # in the initialization options to enable it.
+    #
+    # The
+    # [code lens](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeLens)
+    # request informs the editor of runnable commands such as tests
+    #
+    # # Example
+    #
+    # ```ruby
+    # # Run
+    # class Test < Minitest::Test
+    # end
+    # ```
+
+    class CodeLens < BaseRequest
+      BASE_COMMAND = T.let((File.exist?("Gemfile.lock") ? "bundle exec ruby" : "ruby") + " -Itest ", String)
+      ACCESS_MODIFIERS = T.let(["public", "private", "protected"], T::Array[String])
+
+      sig do
+        params(
+          document: Document,
+        ).void
+      end
+      def initialize(document)
+        super(document)
+        @results = T.let([], T::Array[Interface::CodeLens])
+        @path = T.let(document.uri.delete_prefix("file://"), String)
+        @modifier = T.let("public", String)
+      end
+
+      sig { override.returns(T.all(T::Array[Interface::CodeLens], Object)) }
+      def run
+        visit(@document.tree) if @document.parsed?
+        @results
+      end
+
+      sig { override.params(node: SyntaxTree::ClassDeclaration).void }
+      def visit_class(node)
+        class_name = node.constant.constant.value
+        if class_name.end_with?("Test")
+          add_code_lens(node, name: class_name, command: BASE_COMMAND + @path)
+        end
+        visit(node.bodystmt)
+      end
+
+      sig { override.params(node: SyntaxTree::DefNode).void }
+      def visit_def(node)
+        if @modifier == "public"
+          method_name = node.name.value
+          if method_name.start_with?("test_")
+            add_code_lens(
+              node,
+              name: method_name,
+              command: BASE_COMMAND + @path + " --name " + method_name,
+            )
+          end
+        end
+      end
+
+      sig { override.params(node: SyntaxTree::Command).void }
+      def visit_command(node)
+        if node.message.value == "public"
+          with_visiblity("public", node)
+        end
+      end
+
+      sig { override.params(node: SyntaxTree::CallNode).void }
+      def visit_call(node)
+        ident = node.message if node.message.is_a?(SyntaxTree::Ident)
+
+        if ident
+          if T.cast(ident, SyntaxTree::Ident).value == "public"
+            with_visiblity("public", node)
+          end
+        end
+      end
+
+      sig { override.params(node: SyntaxTree::VCall).void }
+      def visit_vcall(node)
+        vcall_value = node.value.value
+
+        if ACCESS_MODIFIERS.include?(vcall_value)
+          @modifier = vcall_value
+        end
+      end
+
+      private
+
+      sig do
+        params(
+          visibility: String,
+          node: T.any(SyntaxTree::CallNode, SyntaxTree::Command),
+        ).void
+      end
+      def with_visiblity(visibility, node)
+        current_visibility = @modifier
+        @modifier = visibility
+        visit(node.arguments)
+      ensure
+        @modifier = T.must(current_visibility)
+      end
+
+      sig { params(node: SyntaxTree::Node, name: String, command: String).void }
+      def add_code_lens(node, name:, command:)
+        @results << Interface::CodeLens.new(
+          range: range_from_syntax_tree_node(node),
+          command: Interface::Command.new(
+            title: "Run",
+            command: "rubyLsp.runTest",
+            arguments: [
+              @path,
+              name,
+              command,
+              {
+                start_line: node.location.start_line - 1,
+                start_column: node.location.start_column,
+                end_line: node.location.end_line - 1,
+                end_column: node.location.end_column,
+              },
+            ],
+          ),
+          data: { type: "test" },
+        )
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -32,8 +32,7 @@ module RubyLsp
         @highlights = T.let([], T::Array[Interface::DocumentHighlight])
         return unless document.parsed?
 
-        position = document.create_scanner.find_char_position(position)
-        @target = T.let(find(T.must(document.tree), position), T.nilable(Support::HighlightTarget))
+        @target = T.let(find(position), T.nilable(Support::HighlightTarget))
       end
 
       sig { override.returns(T.all(T::Array[Interface::DocumentHighlight], Object)) }
@@ -68,12 +67,11 @@ module RubyLsp
 
       sig do
         params(
-          node: SyntaxTree::Node,
-          position: Integer,
+          position: Document::PositionShape,
         ).returns(T.nilable(Support::HighlightTarget))
       end
-      def find(node, position)
-        matched, parent = locate(node, position)
+      def find(position)
+        matched, parent = @document.locate_node(position)
 
         return unless matched && parent
         return unless matched.is_a?(SyntaxTree::Ident) || DIRECT_HIGHLIGHTS.include?(matched.class)

data/lib/ruby_lsp/requests/hover.rb

@@ -17,8 +17,11 @@ module RubyLsp
     #   before_save :do_something # when hovering on before_save, the link will be rendered
     # end
     # ```
-    class Hover < BaseRequest
+    class Hover < Listener
       extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T.nilable(Interface::Hover) } }
 
       ALLOWED_TARGETS = T.let(
         [
@@ -29,53 +32,45 @@ module RubyLsp
         T::Array[T.class_of(SyntaxTree::Node)],
       )
 
-      sig { params(document: Document, position: Document::PositionShape).void }
-      def initialize(document, position)
-        super(document)
+      sig { override.returns(ResponseType) }
+      attr_reader :response
 
-        @position = T.let(document.create_scanner.find_char_position(position), Integer)
+      sig { void }
+      def initialize
+        @response = T.let(nil, ResponseType)
+        super()
       end
 
-      sig { override.returns(T.nilable(Interface::Hover)) }
-      def run
-        return unless @document.parsed?
+      listener_events do
+        sig { params(node: SyntaxTree::Command).void }
+        def on_command(node)
+          message = node.message
+          @response = generate_rails_document_link_hover(message.value, message)
+        end
 
-        target, parent = locate(T.must(@document.tree), @position)
-        target = parent if !ALLOWED_TARGETS.include?(target.class) && ALLOWED_TARGETS.include?(parent.class)
+        sig { params(node: SyntaxTree::ConstPathRef).void }
+        def on_const_path_ref(node)
+          @response = generate_rails_document_link_hover(full_constant_name(node), node)
+        end
 
-        case target
-        when SyntaxTree::Command
-          message = target.message
-          generate_rails_document_link_hover(message.value, message)
-        when SyntaxTree::CallNode
-          message = target.message
+        sig { params(node: SyntaxTree::CallNode).void }
+        def on_call(node)
+          message = node.message
           return if message.is_a?(Symbol)
 
-          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)
+          @response = generate_rails_document_link_hover(message.value, message)
         end
       end
 
       private
 
-      sig do
-        params(name: String, node: SyntaxTree::Node).returns(T.nilable(Interface::Hover))
-      end
+      sig { params(name: String, node: SyntaxTree::Node).returns(T.nilable(Interface::Hover)) }
       def generate_rails_document_link_hover(name, node)
         urls = Support::RailsDocumentClient.generate_rails_document_urls(name)
-
         return if urls.empty?
 
-        contents = Interface::MarkupContent.new(
-          kind: "markdown",
-          value: urls.join("\n\n"),
-        )
-        Interface::Hover.new(
-          range: range_from_syntax_tree_node(node),
-          contents: contents,
-        )
+        contents = Interface::MarkupContent.new(kind: "markdown", value: urls.join("\n\n"))
+        Interface::Hover.new(range: range_from_syntax_tree_node(node), contents: contents)
       end
     end
   end

data/lib/ruby_lsp/requests/path_completion.rb

@@ -29,8 +29,7 @@ module RubyLsp
         # 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))
+        target = T.let(find, T.nilable(SyntaxTree::TStringContent))
         # no target means the we are not inside a `require` call
         return [] unless target
 
@@ -51,11 +50,12 @@ module RubyLsp
         end
       end
 
-      sig { params(position: Integer).returns(T.nilable(SyntaxTree::TStringContent)) }
-      def find(position)
-        matched, parent = locate(
+      sig { returns(T.nilable(SyntaxTree::TStringContent)) }
+      def find
+        char_position = @document.create_scanner.find_char_position(@position)
+        matched, parent = @document.locate(
           T.must(@document.tree),
-          position,
+          char_position,
           node_types: [SyntaxTree::Command, SyntaxTree::CommandCall, SyntaxTree::CallNode],
         )
 
@@ -76,7 +76,7 @@ module RubyLsp
 
           path_node = argument.parts.first
           return unless path_node.is_a?(SyntaxTree::TStringContent)
-          return unless (path_node.location.start_char..path_node.location.end_char).cover?(position)
+          return unless (path_node.location.start_char..path_node.location.end_char).cover?(char_position)
 
           path_node
         end

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

@@ -0,0 +1,55 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      module Common
+        extend T::Sig
+
+        sig { params(node: SyntaxTree::Node).returns(Interface::Range) }
+        def range_from_syntax_tree_node(node)
+          loc = node.location
+
+          Interface::Range.new(
+            start: Interface::Position.new(
+              line: loc.start_line - 1,
+              character: loc.start_column,
+            ),
+            end: Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
+          )
+        end
+
+        sig do
+          params(node: T.any(SyntaxTree::ConstPathRef, SyntaxTree::ConstRef, SyntaxTree::TopConstRef)).returns(String)
+        end
+        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 { params(node: T.nilable(SyntaxTree::Node), range: T.nilable(T::Range[Integer])).returns(T::Boolean) }
+        def visible?(node, range)
+          return true if range.nil?
+          return false if node.nil?
+
+          loc = node.location
+          range.cover?(loc.start_line - 1) && range.cover?(loc.end_line - 1)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests.rb

@@ -18,6 +18,7 @@ module RubyLsp
   # - {RubyLsp::Requests::DocumentHighlight}
   # - {RubyLsp::Requests::InlayHints}
   # - {RubyLsp::Requests::PathCompletion}
+  # - {RubyLsp::Requests::CodeLens}
 
   module Requests
     autoload :BaseRequest, "ruby_lsp/requests/base_request"
@@ -35,6 +36,7 @@ module RubyLsp
     autoload :DocumentHighlight, "ruby_lsp/requests/document_highlight"
     autoload :InlayHints, "ruby_lsp/requests/inlay_hints"
     autoload :PathCompletion, "ruby_lsp/requests/path_completion"
+    autoload :CodeLens, "ruby_lsp/requests/code_lens"
 
     # :nodoc:
     module Support
@@ -46,6 +48,7 @@ module RubyLsp
       autoload :HighlightTarget, "ruby_lsp/requests/support/highlight_target"
       autoload :RailsDocumentClient, "ruby_lsp/requests/support/rails_document_client"
       autoload :PrefixTree, "ruby_lsp/requests/support/prefix_tree"
+      autoload :Common, "ruby_lsp/requests/support/common"
     end
   end
 end

data/lib/ruby_lsp/store.rb

@@ -9,8 +9,8 @@ module RubyLsp
   class Store
     extend T::Sig
 
-    sig { params(encoding: String).void }
-    attr_writer :encoding
+    sig { returns(String) }
+    attr_accessor :encoding
 
     sig { returns(String) }
     attr_accessor :formatter
@@ -18,7 +18,7 @@ module RubyLsp
     sig { void }
     def initialize
       @state = T.let({}, T::Hash[String, Document])
-      @encoding = T.let("utf-8", String)
+      @encoding = T.let(Constant::PositionEncodingKind::UTF8, String)
       @formatter = T.let("auto", String)
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.4
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-30 00:00:00.000000000 Z
+date: 2023-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -73,12 +73,15 @@ files:
 - lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb
 - lib/ruby-lsp.rb
 - lib/ruby_lsp/document.rb
+- lib/ruby_lsp/event_emitter.rb
 - lib/ruby_lsp/executor.rb
 - lib/ruby_lsp/internal.rb
+- lib/ruby_lsp/listener.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/code_lens.rb
 - lib/ruby_lsp/requests/diagnostics.rb
 - lib/ruby_lsp/requests/document_highlight.rb
 - lib/ruby_lsp/requests/document_link.rb
@@ -92,6 +95,7 @@ files:
 - lib/ruby_lsp/requests/selection_ranges.rb
 - lib/ruby_lsp/requests/semantic_highlighting.rb
 - lib/ruby_lsp/requests/support/annotation.rb
+- lib/ruby_lsp/requests/support/common.rb
 - lib/ruby_lsp/requests/support/highlight_target.rb
 - lib/ruby_lsp/requests/support/prefix_tree.rb
 - lib/ruby_lsp/requests/support/rails_document_client.rb
@@ -127,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.9
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby