ruby-lsp 0.4.3 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7bf79fd6cdc704c8f874f58985f0e72ac034c76bb70a68166654185f6f00cf1
-  data.tar.gz: '083edc726c05ffb6e5e3ae63d480b17fa0f7161ee62349665cc57e309acd5598'
+  metadata.gz: 437c2048862bed450fd70057489636117c99943dd7bb68df35c4e161a29f8385
+  data.tar.gz: 30d26e8455f9086bc934ffe23b5e37816f18f5904e3422495c316a980a860cfc
 SHA512:
-  metadata.gz: f6192daf27dfd82dbb505f5184eebd66308690ce10ead4d4cedc4d9c6667be882a8b9de4c87e66eb88ff43e896307be24bbcc6506b0544b496e1bcb3c9804498
-  data.tar.gz: bb68928d9a72b3b2873509bf915f753a202a520187bf5f55da1870d552e0ba0917a7d21ea70d20853ac60aa614f7d85d117d7291ec9c0778cab80e4561a7aba0
+  metadata.gz: 366dd4b756ded58762b598545e398059fe0eae7578b13c92cc0a90dcc9aba2d58106dbf2dc0e9867a9db7de5007e6114ebbbf7cf191bcdebb843b077de945ba9
+  data.tar.gz: 1f798c1462825cccafd48bff23baecb8ba8ef36f9b5733502d79c5d8e6e52550c7ab722a99678eec04ce2a8b42c4d84aab912acb2100ff7d26e422b02f2c185b

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
 
@@ -122,7 +123,7 @@ To add a new expectations test runner for a new request handler:
 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.
+    - Run `vscode-ruby-lsp` extension in debug mode, which will start a new `ruby-lsp` process with the `--debug` flag. Note that debugging is not available on Windows.
 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.

data/VERSION

@@ -1 +1 @@
-0.4.3
+0.4.5

data/exe/ruby-lsp

@@ -21,6 +21,11 @@ end
 require_relative "../lib/ruby_lsp/internal"
 
 if ARGV.include?("--debug")
+  if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
+    puts "Debugging is not supported on Windows"
+    exit 1
+  end
+
   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
@@ -28,7 +33,11 @@ if ARGV.include?("--debug")
   socket_identifier = "ruby-debug-#{ENV["USER"]}-#{File.basename(Dir.pwd)}.sock"
   ENV["RUBY_DEBUG_SOCK_PATH"] = "#{sockets_dir}/#{socket_identifier}"
 
-  require "debug/open_nonstop"
+  begin
+    require "debug/open_nonstop"
+  rescue LoadError
+    warn("You need to install the debug gem to use the --debug flag")
+  end
 end
 
 RubyLsp::Server.new.start

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,54 @@
+# 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) }
+      when SyntaxTree::Const
+        @event_to_listener_map[:on_const]&.each { |listener| T.unsafe(listener).on_const(node) }
+      end
+    end
+  end
+end

data/lib/ruby_lsp/executor.rb

@@ -11,7 +11,7 @@ module RubyLsp
       # Requests that mutate the store must be run sequentially! Parallel requests only receive a temporary copy of the
       # store
       @store = store
-      @notifications = T.let([], T::Array[Notification])
+      @messages = T.let([], T::Array[Message])
     end
 
     sig { params(request: T::Hash[Symbol, T.untyped]).returns(Result) }
@@ -25,7 +25,7 @@ module RubyLsp
         error = e
       end
 
-      Result.new(response: response, error: error, request_time: request_time, notifications: @notifications)
+      Result.new(response: response, error: error, request_time: request_time, messages: @messages)
     end
 
     private
@@ -38,6 +38,22 @@ module RubyLsp
       when "initialize"
         initialize_request(request.dig(:params))
       when "initialized"
+        Extension.load_extensions
+
+        errored_extensions = Extension.extensions.select(&:error?)
+
+        if errored_extensions.any?
+          @messages << Notification.new(
+            message: "window/showMessage",
+            params: Interface::ShowMessageParams.new(
+              type: Constant::MessageType::WARNING,
+              message: "Error loading extensions:\n\n#{errored_extensions.map(&:formatted_errors).join("\n\n")}",
+            ),
+          )
+
+          warn(errored_extensions.map(&:backtraces).join("\n\n"))
+        end
+
         warn("Ruby LSP is ready")
         VOID
       when "textDocument/didOpen"
@@ -47,7 +63,7 @@ module RubyLsp
           request.dig(:params, :textDocument, :version),
         )
       when "textDocument/didClose"
-        @notifications << Notification.new(
+        @messages << Notification.new(
           message: "textDocument/publishDiagnostics",
           params: Interface::PublishDiagnosticsParams.new(uri: uri, diagnostics: []),
         )
@@ -75,7 +91,7 @@ module RubyLsp
         begin
           formatting(uri)
         rescue Requests::Formatting::InvalidFormatter => error
-          @notifications << Notification.new(
+          @messages << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
               type: Constant::MessageType::ERROR,
@@ -85,7 +101,7 @@ module RubyLsp
 
           nil
         rescue StandardError => error
-          @notifications << Notification.new(
+          @messages << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
               type: Constant::MessageType::ERROR,
@@ -111,7 +127,7 @@ module RubyLsp
         begin
           diagnostic(uri)
         rescue StandardError => error
-          @notifications << Notification.new(
+          @messages << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
               type: Constant::MessageType::ERROR,
@@ -123,6 +139,8 @@ module RubyLsp
         end
       when "textDocument/completion"
         completion(uri, request.dig(:params, :position))
+      when "textDocument/codeLens"
+        code_lens(uri)
       end
     end
 
@@ -133,6 +151,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 +165,27 @@ 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
+
+      # Instantiate all listeners
+      base_listener = Requests::Hover.new
+      listeners = Requests::Hover.listeners.map(&:new)
+
+      # Emit events for all listeners
+      T.unsafe(EventEmitter).new(base_listener, *listeners).emit_for_target(target)
+
+      # Merge all responses into a single hover
+      listeners.each { |ext| base_listener.merge_response!(ext) }
+      base_listener.response
     end
 
     sig { params(uri: String).returns(T::Array[Interface::DocumentLink]) }
@@ -269,7 +314,7 @@ module RubyLsp
 
       case result
       when Requests::CodeActionResolve::Error::EmptySelection
-        @notifications << Notification.new(
+        @messages << Notification.new(
           message: "window/showMessage",
           params: Interface::ShowMessageParams.new(
             type: Constant::MessageType::ERROR,
@@ -278,7 +323,7 @@ module RubyLsp
         )
         raise Requests::CodeActionResolve::CodeActionError
       when Requests::CodeActionResolve::Error::InvalidTargetRange
-        @notifications << Notification.new(
+        @messages << Notification.new(
           message: "window/showMessage",
           params: Interface::ShowMessageParams.new(
             type: Constant::MessageType::ERROR,
@@ -326,11 +371,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 +414,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 +473,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 +487,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/extension.rb

@@ -0,0 +1,104 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  # To register an extension, inherit from this class and implement both `name` and `activate`
+  #
+  # # Example
+  #
+  # ```ruby
+  # module MyGem
+  #   class MyExtension < Extension
+  #     def activate
+  #       # Perform any relevant initialization
+  #     end
+  #
+  #     def name
+  #       "My extension name"
+  #     end
+  #   end
+  # end
+  # ```
+  class Extension
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    class << self
+      extend T::Sig
+
+      # Automatically track and instantiate extension classes
+      sig { params(child_class: T.class_of(Extension)).void }
+      def inherited(child_class)
+        extensions << child_class.new
+        super
+      end
+
+      sig { returns(T::Array[Extension]) }
+      def extensions
+        @extensions ||= T.let([], T.nilable(T::Array[Extension]))
+      end
+
+      # Discovers and loads all extensions. Returns the list of activated extensions
+      sig { returns(T::Array[Extension]) }
+      def load_extensions
+        # Require all extensions entry points, which should be placed under
+        # `some_gem/lib/ruby_lsp/your_gem_name/extension.rb`
+        Gem.find_files("ruby_lsp/**/extension.rb").each do |extension|
+          require File.expand_path(extension)
+        rescue => e
+          warn(e.message)
+          warn(e.backtrace.to_s) # rubocop:disable Lint/RedundantStringCoercion
+        end
+
+        # Activate each one of the discovered extensions. If any problems occur in the extensions, we don't want to
+        # fail to boot the server
+        extensions.each do |extension|
+          extension.activate
+          nil
+        rescue => e
+          extension.add_error(e)
+        end
+      end
+    end
+
+    sig { void }
+    def initialize
+      @errors = T.let([], T::Array[StandardError])
+    end
+
+    sig { params(error: StandardError).returns(T.self_type) }
+    def add_error(error)
+      @errors << error
+      self
+    end
+
+    sig { returns(T::Boolean) }
+    def error?
+      @errors.any?
+    end
+
+    sig { returns(String) }
+    def formatted_errors
+      <<~ERRORS
+        #{name}:
+          #{@errors.map(&:message).join("\n")}
+      ERRORS
+    end
+
+    sig { returns(String) }
+    def backtraces
+      @errors.filter_map(&:backtrace).join("\n\n")
+    end
+
+    # Each extension should implement `MyExtension#activate` and use to perform any sort of initialization, such as
+    # reading information into memory or even spawning a separate process
+    sig { abstract.void }
+    def activate; end
+
+    # Extensions should override the `name` method to return the extension name
+    sig { abstract.returns(String) }
+    def name; end
+  end
+end

data/lib/ruby_lsp/internal.rb

@@ -11,5 +11,8 @@ 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"
+require "ruby_lsp/extension"

data/lib/ruby_lsp/listener.rb

@@ -0,0 +1,49 @@
+# 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
+
+      sig { returns(T::Array[T.class_of(Listener)]) }
+      def listeners
+        @listeners ||= T.let([], T.nilable(T::Array[T.class_of(Listener)]))
+      end
+
+      sig { params(listener: T.class_of(Listener)).void }
+      def add_listener(listener)
+        listeners << listener
+      end
+
+      # 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,60 @@ 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
+
+      sig { void }
+      def initialize
+        @response = T.let(nil, ResponseType)
+        super()
+      end
+
+      # Merges responses from other hover listeners
+      sig { params(other: Listener[ResponseType]).returns(T.self_type) }
+      def merge_response!(other)
+        other_response = other.response
+        return self unless other_response
+
+        if @response.nil?
+          @response = other.response
+        else
+          @response.contents.value << other_response.contents.value << "\n\n"
+        end
 
-        @position = T.let(document.create_scanner.find_char_position(position), Integer)
+        self
       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/on_type_formatting.rb

@@ -80,6 +80,10 @@ module RubyLsp
 
       sig { void }
       def handle_statement_end
+        # If a keyword occurs in a line which appears be a comment or a string, we will not try to format it, since
+        # it could be a coincidental match. This approach is not perfect, but it should cover most cases.
+        return if @previous_line.start_with?(/["'#]/)
+
         return unless END_REGEXES.any? { |regex| regex.match?(@previous_line) }
 
         indents = " " * @indentation

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

@@ -23,6 +23,7 @@ module RubyLsp
       @jobs = T.let({}, T::Hash[T.any(String, Integer), Job])
       @mutex = T.let(Mutex.new, Mutex)
       @worker = T.let(new_worker, Thread)
+      @current_request_id = T.let(1, Integer)
 
       Thread.main.priority = 1
     end
@@ -54,7 +55,7 @@ module RubyLsp
           @worker.join
           @store.clear
 
-          finalize_request(Result.new(response: nil, notifications: []), request)
+          finalize_request(Result.new(response: nil, messages: []), request)
         when "exit"
           # We return zero if shutdown has already been received or one otherwise as per the recommendation in the spec
           # https://microsoft.github.io/language-server-protocol/specification/#exit
@@ -88,7 +89,7 @@ module RubyLsp
 
           result = if job.cancelled
             # We need to return nil to the client even if the request was cancelled
-            Result.new(response: nil, notifications: [])
+            Result.new(response: nil, messages: [])
           else
             Executor.new(@store).execute(request)
           end
@@ -105,9 +106,6 @@ module RubyLsp
         error = result.error
         response = result.response
 
-        # If the response include any notifications, go through them and publish each one
-        result.notifications.each { |n| @writer.write(method: n.message, params: n.params) }
-
         if error
           @writer.write(
             id: request[:id],
@@ -121,6 +119,17 @@ module RubyLsp
           @writer.write(id: request[:id], result: response)
         end
 
+        # If the response include any messages, go through them and publish each one
+        result.messages.each do |n|
+          case n
+          when Notification
+            @writer.write(method: n.message, params: n.params)
+          when Request
+            @writer.write(id: @current_request_id, method: n.message, params: n.params)
+            @current_request_id += 1
+          end
+        end
+
         request_time = result.request_time
         if request_time
           @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, error))

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
 

data/lib/ruby_lsp/utils.rb

@@ -9,8 +9,11 @@ module RubyLsp
   WORKSPACE_URI = T.let("file://#{Dir.pwd}".freeze, String) # rubocop:disable Style/RedundantFreeze
 
   # A notification to be sent to the client
-  class Notification
+  class Message
     extend T::Sig
+    extend T::Helpers
+
+    abstract!
 
     sig { returns(String) }
     attr_reader :message
@@ -25,6 +28,9 @@ module RubyLsp
     end
   end
 
+  class Notification < Message; end
+  class Request < Message; end
+
   # The final result of running a request before its IO is finalized
   class Result
     extend T::Sig
@@ -32,8 +38,8 @@ module RubyLsp
     sig { returns(T.untyped) }
     attr_reader :response
 
-    sig { returns(T::Array[Notification]) }
-    attr_reader :notifications
+    sig { returns(T::Array[Message]) }
+    attr_reader :messages
 
     sig { returns(T.nilable(Exception)) }
     attr_reader :error
@@ -44,14 +50,14 @@ module RubyLsp
     sig do
       params(
         response: T.untyped,
-        notifications: T::Array[Notification],
+        messages: T::Array[Message],
         error: T.nilable(Exception),
         request_time: T.nilable(Float),
       ).void
     end
-    def initialize(response:, notifications:, error: nil, request_time: nil)
+    def initialize(response:, messages:, error: nil, request_time: nil)
       @response = response
-      @notifications = notifications
+      @messages = messages
       @error = error
       @request_time = request_time
     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.5
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-30 00:00:00.000000000 Z
+date: 2023-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -73,12 +73,16 @@ 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/extension.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 +96,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 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.9
+rubygems_version: 3.4.12
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby