ruby-lsp 0.4.2 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5d9c6b487aab55ce25eb2741fff92afa8ca0ee544f21374debacce7f887cc50
-  data.tar.gz: 8da9da85900753306f5e8558bc1a42f25b7173ffe1087ea70612c10ef5558e27
+  metadata.gz: 61c8fe2a55057823533a8a17b4472309e3d463ec3d63302fa3393f046ec4b339
+  data.tar.gz: fb9636b8aafac9d5002a872d0f34f7f9852e9348009cdc2934369637a4cadb4c
 SHA512:
-  metadata.gz: 3dca630b9cae262f1af8d0aef0300ab7399dafd348db5f578ed7fdffb22a7afd48fe9467aa65e467fb50e16663f8fad32f1d0cc46b30819b06a6b7472700dcc0
-  data.tar.gz: f048c6c9fe14d20edefeca7ac504942af34c61699163f0d09ec54f4d80e7469e1bb1762757b96aa3d8d06a6e8168473dacfc932112b2d31ca4b380748eef8899
+  metadata.gz: db51fd5526431b773125c0b27bfe8ca53b2861759457f9a36e7a681bcfbffb0f58026b4f8cc4dc991be2380309959aacde7c8cc2cd0a0f0373dfb313d0d28db9
+  data.tar.gz: 13cc3991bffd1a18dd1e2580c8d1051161b03a171a25e8ce681f46fb8d5baedb1de0f9f96304556e08f3db95c2262e29693d22bf3659ba45eff620157adc035c

data/README.md

@@ -1,57 +1,51 @@
-![Build Status](https://github.com/Shopify/ruby-lsp/workflows/CI/badge.svg)
+[![Build Status](https://github.com/Shopify/ruby-lsp/workflows/CI/badge.svg)](https://github.com/Shopify/ruby-lsp/actions/workflows/ci.yml)
+[![Ruby LSP extension](https://img.shields.io/badge/VS%20Code-Ruby%20LSP-success?logo=visual-studio-code)](https://marketplace.visualstudio.com/items?itemName=Shopify.ruby-lsp)
+[![Ruby DX Slack](https://img.shields.io/badge/Slack-Ruby%20DX-success?logo=slack)](https://join.slack.com/t/ruby-dx/shared_invite/zt-1s6f4y15t-v9jedZ9YUPQLM91TEJ4Gew)
 
-# Ruby LSP
-
-This gem is an implementation of the [language server protocol specification](https://microsoft.github.io/language-server-protocol/) for Ruby, used to improve editor features.
-
-# Overview
-
-The intention of Ruby LSP is to provide a fast, robust and feature-rich coding environment for Ruby developers.
-
-It's part of a [wider Shopify goal](https://github.com/Shopify/vscode-shopify-ruby) to provide a state-of-the-art experience to Ruby developers using modern standards for cross-editor features, documentation and debugging.
 
-It provides many features, including:
-
-* Syntax highlighting
-* Linting and formatting
-* Code folding
-* Selection ranges
-
-It does not perform typechecking, so its features are implemented on a best-effort basis, aiming to be as accurate as possible.
-
-Planned future features include:
+# Ruby LSP
 
-* Auto-completion and navigation ("Go To Definition") ([prototype](https://github.com/Shopify/ruby-lsp/pull/429))
-* Support for plug-ins to extend behavior
+The Ruby LSP is an implementation of the [language server protocol](https://microsoft.github.io/language-server-protocol/)
+for Ruby, used to improve rich features in editors. It is a part of a wider goal to provide a state-of-the-art
+experience to Ruby developers using modern standards for cross-editor features, documentation and debugging.
 
-The Ruby LSP does not perform any type-checking or provide any type-related assistance, but it can be used alongside [Sorbet](https://github.com/sorbet/sorbet)'s LSP server.
+Want to discuss Ruby developer experience? Consider joining the public
+[Ruby DX Slack workspace](https://join.slack.com/t/ruby-dx/shared_invite/zt-1s6f4y15t-v9jedZ9YUPQLM91TEJ4Gew).
 
-At the time of writing, these are the major differences between Ruby LSP and [Solargraph](https://solargraph.org/):
+## Usage
 
-* Solargraph [uses](https://solargraph.org/guides/yard) YARD documentation to gather information about your project and its gem dependencies. This provides functionality such as context-aware auto-completion and navigation ("Go To Definition")
-* Solargraph can be used as a globally installed gem, but Ruby LSP must be added to the Gemfile or gemspec if using RuboCop. (There are pros and cons to each approach)
+### With VS Code
 
-## Learn More
+If using VS Code, all you have to do is install the [Ruby LSP extension](https://github.com/Shopify/vscode-ruby-lsp) to
+get the extra features in the editor. Do not install this gem manually.
 
-* [RubyConf 2022: Improving the development experience with language servers](https://www.youtube.com/watch?v=kEfXPTm1aCI) ([Vinicius Stock](https://github.com/vinistock))
+### With other editors
 
-## Usage
+See [editors](https://github.com/Shopify/ruby-lsp/blob/main/EDITORS.md) for community instructions on setting up the
+Ruby LSP.
 
-Install the gem. There's no need to require it, since the server is used as a standalone executable.
+The gem can be installed by doing
+```shell
+gem install ruby-lsp
+```
 
+If you decide to add the gem to the bundle, it is not necessary to require it.
 ```ruby
 group :development do
   gem "ruby-lsp", require: false
 end
 ```
 
-If using VS Code, install the [Ruby LSP extension](https://github.com/Shopify/vscode-ruby-lsp) to get the extra features
-in the editor. See [editors](https://github.com/Shopify/ruby-lsp/blob/main/EDITORS.md) for community instructions on
-setting up the Ruby LSP in different editors.
+### Documentation
 
 See the [documentation](https://shopify.github.io/ruby-lsp) for more in-depth details about the
 [supported features](https://shopify.github.io/ruby-lsp/RubyLsp/Requests.html).
 
+## 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
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/ruby-lsp.
@@ -113,7 +107,7 @@ To add a new expectations test runner for a new request handler:
     * Tests with expectations will be checked with `assert_expectations`
     * Tests without expectations will be ran against your new $HANDLER to check that nothing breaks
 
-## Debugging
+### Debugging
 
 ### Debugging Tests
 
@@ -135,7 +129,7 @@ To add a new expectations test runner for a new request handler:
 7. [`ruby-lsp`] Use commands like `b <file>:<line>` or `b Class#method` to set breakpoints and type `c` to continue the process.
 8. In your `Extension Development Host` project (e.g. [`Tapioca`](https://github.com/Shopify/tapioca)), trigger the request that will hit the breakpoint.
 
-## Spell Checking
+### Spell Checking
 
 VS Code users will be prompted to enable the [Code Spell Checker](https://marketplace.visualstudio.com/items?itemName=streetsidesoftware.code-spell-checker) extension.
 By default this will be enabled for all workspaces, but you can choose to selectively enable or disable it per workspace.

data/VERSION

@@ -1 +1 @@
-0.4.2
+0.4.4

data/lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb

@@ -0,0 +1,62 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rubocop"
+require "sorbet-runtime"
+
+module RuboCop
+  module Cop
+    module RubyLsp
+      # Prefer using `Interface`, `Transport` and `Constant` aliases
+      # within the `RubyLsp` module, without having to prefix with
+      # `LanguageServer::Protocol`
+      #
+      # @example
+      #   # bad
+      #   module RubyLsp
+      #     class FoldingRanges
+      #       sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::FoldingRange], Object)) }
+      #       def run; end
+      #     end
+      #
+      #   # good
+      #   module RubyLsp
+      #     class FoldingRanges
+      #       sig { override.returns(T.all(T::Array[Interface::FoldingRange], Object)) }
+      #       def run; end
+      #     end
+      #   end
+      class UseLanguageServerAliases < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+
+        ALIASED_CONSTANTS = T.let([:Interface, :Transport, :Constant].freeze, T::Array[Symbol])
+
+        MSG = "Use constant alias `%{constant}`."
+
+        def_node_search :ruby_lsp_modules, <<~PATTERN
+          (module (const nil? :RubyLsp) ...)
+        PATTERN
+
+        def_node_search :lsp_constant_usages, <<~PATTERN
+          (const (const (const nil? :LanguageServer) :Protocol) {:Interface | :Transport | :Constant})
+        PATTERN
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          ruby_lsp_modules(processed_source.ast).each do |ruby_lsp_mod|
+            lsp_constant_usages(ruby_lsp_mod).each do |node|
+              lsp_const = node.children.last
+
+              next unless ALIASED_CONSTANTS.include?(lsp_const)
+
+              add_offense(node, message: format(MSG, constant: lsp_const)) do |corrector|
+                corrector.replace(node, lsp_const)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/document.rb

@@ -15,11 +15,19 @@ module RubyLsp
     sig { returns(String) }
     attr_reader :source
 
-    sig { params(source: String, encoding: String).void }
-    def initialize(source, encoding = "utf-8")
+    sig { returns(Integer) }
+    attr_reader :version
+
+    sig { returns(String) }
+    attr_reader :uri
+
+    sig { params(source: String, version: Integer, uri: String, encoding: String).void }
+    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)
+      @version = T.let(version, Integer)
+      @uri = T.let(uri, String)
       @unparsed_edits = T.let([], T::Array[EditShape])
       @syntax_error = T.let(false, T::Boolean)
       @tree = T.let(SyntaxTree.parse(@source), T.nilable(SyntaxTree::Node))
@@ -48,8 +56,8 @@ module RubyLsp
       result
     end
 
-    sig { params(edits: T::Array[EditShape]).void }
-    def push_edits(edits)
+    sig { params(edits: T::Array[EditShape], version: Integer).void }
+    def push_edits(edits, version:)
       edits.each do |edit|
         range = edit[:range]
         scanner = create_scanner
@@ -60,6 +68,7 @@ module RubyLsp
         @source[start_position...end_position] = edit[:text]
       end
 
+      @version = version
       @unparsed_edits.concat(edits)
       @cache.clear
     end
@@ -68,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
@@ -90,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
 
@@ -118,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

@@ -41,7 +41,11 @@ module RubyLsp
         warn("Ruby LSP is ready")
         VOID
       when "textDocument/didOpen"
-        text_document_did_open(uri, request.dig(:params, :textDocument, :text))
+        text_document_did_open(
+          uri,
+          request.dig(:params, :textDocument, :text),
+          request.dig(:params, :textDocument, :version),
+        )
       when "textDocument/didClose"
         @notifications << Notification.new(
           message: "textDocument/publishDiagnostics",
@@ -50,7 +54,11 @@ module RubyLsp
 
         text_document_did_close(uri)
       when "textDocument/didChange"
-        text_document_did_change(uri, request.dig(:params, :contentChanges))
+        text_document_did_change(
+          uri,
+          request.dig(:params, :contentChanges),
+          request.dig(:params, :textDocument, :version),
+        )
       when "textDocument/foldingRange"
         folding_range(uri)
       when "textDocument/documentLink"
@@ -115,6 +123,8 @@ module RubyLsp
         end
       when "textDocument/completion"
         completion(uri, request.dig(:params, :position))
+      when "textDocument/codeLens"
+        code_lens(uri)
       end
     end
 
@@ -125,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,
@@ -132,13 +149,26 @@ 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]) }
     def document_link(uri)
       @store.cache_fetch(uri, :document_link) do |document|
-        RubyLsp::Requests::DocumentLink.new(uri, document).run
+        RubyLsp::Requests::DocumentLink.new(document).run
       end
     end
 
@@ -149,15 +179,15 @@ module RubyLsp
       end
     end
 
-    sig { params(uri: String, content_changes: T::Array[Document::EditShape]).returns(Object) }
-    def text_document_did_change(uri, content_changes)
-      @store.push_edits(uri, content_changes)
+    sig { params(uri: String, content_changes: T::Array[Document::EditShape], version: Integer).returns(Object) }
+    def text_document_did_change(uri, content_changes, version)
+      @store.push_edits(uri: uri, edits: content_changes, version: version)
       VOID
     end
 
-    sig { params(uri: String, text: String).returns(Object) }
-    def text_document_did_open(uri, text)
-      @store.set(uri, text)
+    sig { params(uri: String, text: String, version: Integer).returns(Object) }
+    def text_document_did_open(uri, text, version)
+      @store.set(uri: uri, source: text, version: version)
       VOID
     end
 
@@ -207,7 +237,7 @@ module RubyLsp
 
     sig { params(uri: String).returns(T.nilable(T::Array[Interface::TextEdit])) }
     def formatting(uri)
-      Requests::Formatting.new(uri, @store.get(uri), formatter: @store.formatter).run
+      Requests::Formatting.new(@store.get(uri), formatter: @store.formatter).run
     end
 
     sig do
@@ -250,7 +280,7 @@ module RubyLsp
     def code_action(uri, range, context)
       document = @store.get(uri)
 
-      Requests::CodeActions.new(uri, document, range, context).run
+      Requests::CodeActions.new(document, range, context).run
     end
 
     sig { params(params: T::Hash[Symbol, T.untyped]).returns(Interface::CodeAction) }
@@ -286,7 +316,7 @@ module RubyLsp
     sig { params(uri: String).returns(T.nilable(Interface::FullDocumentDiagnosticReport)) }
     def diagnostic(uri)
       response = @store.cache_fetch(uri, :diagnostics) do |document|
-        Requests::Diagnostics.new(uri, document).run
+        Requests::Diagnostics.new(document).run
       end
 
       Interface::FullDocumentDiagnosticReport.new(kind: "full", items: response.map(&:to_lsp_diagnostic)) if response
@@ -318,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
@@ -351,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
@@ -406,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,
@@ -419,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