ruby-lsp 0.4.4 → 0.5.0

data/lib/ruby_lsp/executor.rb

@@ -6,12 +6,12 @@ module RubyLsp
   class Executor
     extend T::Sig
 
-    sig { params(store: Store).void }
-    def initialize(store)
+    sig { params(store: Store, message_queue: Thread::Queue).void }
+    def initialize(store, message_queue)
       # 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])
+      @message_queue = message_queue
     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)
     end
 
     private
@@ -38,6 +38,24 @@ module RubyLsp
       when "initialize"
         initialize_request(request.dig(:params))
       when "initialized"
+        Extension.load_extensions
+
+        errored_extensions = Extension.extensions.select(&:error?)
+
+        if errored_extensions.any?
+          @message_queue << 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
+
+        check_formatter_is_available
+
         warn("Ruby LSP is ready")
         VOID
       when "textDocument/didOpen"
@@ -47,7 +65,7 @@ module RubyLsp
           request.dig(:params, :textDocument, :version),
         )
       when "textDocument/didClose"
-        @notifications << Notification.new(
+        @message_queue << Notification.new(
           message: "textDocument/publishDiagnostics",
           params: Interface::PublishDiagnosticsParams.new(uri: uri, diagnostics: []),
         )
@@ -61,12 +79,33 @@ module RubyLsp
         )
       when "textDocument/foldingRange"
         folding_range(uri)
-      when "textDocument/documentLink"
-        document_link(uri)
       when "textDocument/selectionRange"
         selection_range(uri, request.dig(:params, :positions))
-      when "textDocument/documentSymbol"
-        document_symbol(uri)
+      when "textDocument/documentSymbol", "textDocument/documentLink", "textDocument/codeLens"
+        document = @store.get(uri)
+
+        # If the response has already been cached by another request, return it
+        cached_response = document.cache_get(request[:method])
+        return cached_response if cached_response
+
+        # Run listeners for the document
+        emitter = EventEmitter.new
+        document_symbol = Requests::DocumentSymbol.new(emitter, @message_queue)
+        document_link = Requests::DocumentLink.new(uri, emitter, @message_queue)
+        code_lens = Requests::CodeLens.new(uri, emitter, @message_queue)
+        code_lens_extensions_listeners = Requests::CodeLens.listeners.map do |l|
+          T.unsafe(l).new(document.uri, emitter, @message_queue)
+        end
+        emitter.visit(document.tree) if document.parsed?
+
+        code_lens_extensions_listeners.each { |ext| code_lens.merge_response!(ext) }
+
+        # Store all responses retrieve in this round of visits in the cache and then return the response for the request
+        # we actually received
+        document.cache_set("textDocument/documentSymbol", document_symbol.response)
+        document.cache_set("textDocument/documentLink", document_link.response)
+        document.cache_set("textDocument/codeLens", code_lens.response)
+        document.cache_get(request[:method])
       when "textDocument/semanticTokens/full"
         semantic_tokens_full(uri)
       when "textDocument/semanticTokens/range"
@@ -75,7 +114,7 @@ module RubyLsp
         begin
           formatting(uri)
         rescue Requests::Formatting::InvalidFormatter => error
-          @notifications << Notification.new(
+          @message_queue << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
               type: Constant::MessageType::ERROR,
@@ -85,7 +124,7 @@ module RubyLsp
 
           nil
         rescue StandardError => error
-          @notifications << Notification.new(
+          @message_queue << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
               type: Constant::MessageType::ERROR,
@@ -111,7 +150,7 @@ module RubyLsp
         begin
           diagnostic(uri)
         rescue StandardError => error
-          @notifications << Notification.new(
+          @message_queue << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
               type: Constant::MessageType::ERROR,
@@ -123,25 +162,16 @@ module RubyLsp
         end
       when "textDocument/completion"
         completion(uri, request.dig(:params, :position))
-      when "textDocument/codeLens"
-        code_lens(uri)
       end
     end
 
     sig { params(uri: String).returns(T::Array[Interface::FoldingRange]) }
     def folding_range(uri)
-      @store.cache_fetch(uri, :folding_ranges) do |document|
+      @store.cache_fetch(uri, "textDocument/foldingRange") do |document|
         Requests::FoldingRanges.new(document).run
       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,
@@ -150,7 +180,6 @@ module RubyLsp
     end
     def hover(uri, position)
       document = @store.get(uri)
-      document.parse
       return if document.syntax_error?
 
       target, parent = document.locate_node(position)
@@ -160,23 +189,17 @@ module RubyLsp
         target = parent
       end
 
-      listener = RubyLsp::Requests::Hover.new
-      EventEmitter.new(listener).emit_for_target(target)
-      listener.response
-    end
+      # Instantiate all listeners
+      emitter = EventEmitter.new
+      base_listener = Requests::Hover.new(emitter, @message_queue)
+      listeners = Requests::Hover.listeners.map { |l| l.new(emitter, @message_queue) }
 
-    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(document).run
-      end
-    end
+      # Emit events for all listeners
+      emitter.emit_for_target(target)
 
-    sig { params(uri: String).returns(T::Array[Interface::DocumentSymbol]) }
-    def document_symbol(uri)
-      @store.cache_fetch(uri, :document_symbol) do |document|
-        Requests::DocumentSymbol.new(document).run
-      end
+      # Merge all responses into a single hover
+      listeners.each { |ext| base_listener.merge_response!(ext) }
+      base_listener.response
     end
 
     sig { params(uri: String, content_changes: T::Array[Document::EditShape], version: Integer).returns(Object) }
@@ -204,7 +227,7 @@ module RubyLsp
       ).returns(T.nilable(T::Array[T.nilable(Requests::Support::SelectionRange)]))
     end
     def selection_range(uri, positions)
-      ranges = @store.cache_fetch(uri, :selection_ranges) do |document|
+      ranges = @store.cache_fetch(uri, "textDocument/selectionRange") do |document|
         Requests::SelectionRanges.new(document).run
       end
 
@@ -224,7 +247,7 @@ module RubyLsp
 
     sig { params(uri: String).returns(Interface::SemanticTokens) }
     def semantic_tokens_full(uri)
-      @store.cache_fetch(uri, :semantic_highlighting) do |document|
+      @store.cache_fetch(uri, "textDocument/semanticTokens/full") do |document|
         T.cast(
           Requests::SemanticHighlighting.new(
             document,
@@ -237,6 +260,9 @@ module RubyLsp
 
     sig { params(uri: String).returns(T.nilable(T::Array[Interface::TextEdit])) }
     def formatting(uri)
+      # If formatter is set to `auto` but no supported formatting gem is found, don't attempt to format
+      return if @store.formatter == "none"
+
       Requests::Formatting.new(@store.get(uri), formatter: @store.formatter).run
     end
 
@@ -291,7 +317,7 @@ module RubyLsp
 
       case result
       when Requests::CodeActionResolve::Error::EmptySelection
-        @notifications << Notification.new(
+        @message_queue << Notification.new(
           message: "window/showMessage",
           params: Interface::ShowMessageParams.new(
             type: Constant::MessageType::ERROR,
@@ -300,7 +326,7 @@ module RubyLsp
         )
         raise Requests::CodeActionResolve::CodeActionError
       when Requests::CodeActionResolve::Error::InvalidTargetRange
-        @notifications << Notification.new(
+        @message_queue << Notification.new(
           message: "window/showMessage",
           params: Interface::ShowMessageParams.new(
             type: Constant::MessageType::ERROR,
@@ -315,7 +341,7 @@ module RubyLsp
 
     sig { params(uri: String).returns(T.nilable(Interface::FullDocumentDiagnosticReport)) }
     def diagnostic(uri)
-      response = @store.cache_fetch(uri, :diagnostics) do |document|
+      response = @store.cache_fetch(uri, "textDocument/diagnostic") do |document|
         Requests::Diagnostics.new(document).run
       end
 
@@ -342,7 +368,44 @@ module RubyLsp
       params(uri: String, position: Document::PositionShape).returns(T.nilable(T::Array[Interface::CompletionItem]))
     end
     def completion(uri, position)
-      Requests::PathCompletion.new(@store.get(uri), position).run
+      document = @store.get(uri)
+      return unless document.parsed?
+
+      char_position = document.create_scanner.find_char_position(position)
+      matched, parent = document.locate(
+        T.must(document.tree),
+        char_position,
+        node_types: [SyntaxTree::Command, SyntaxTree::CommandCall, SyntaxTree::CallNode],
+      )
+
+      return unless matched && parent
+
+      target = case matched
+      when SyntaxTree::Command, SyntaxTree::CallNode, SyntaxTree::CommandCall
+        message = matched.message
+        return if message.is_a?(Symbol)
+        return unless message.value == "require"
+
+        args = matched.arguments
+        args = args.arguments if args.is_a?(SyntaxTree::ArgParen)
+        return if args.nil? || args.is_a?(SyntaxTree::ArgsForward)
+
+        argument = args.parts.first
+        return unless argument.is_a?(SyntaxTree::StringLiteral)
+
+        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?(char_position)
+
+        path_node
+      end
+
+      return unless target
+
+      emitter = EventEmitter.new
+      listener = Requests::PathCompletion.new(emitter, @message_queue)
+      emitter.emit_for_target(target)
+      listener.response
     end
 
     sig { params(options: T::Hash[Symbol, T.untyped]).returns(Interface::InitializeResult) }
@@ -359,7 +422,11 @@ module RubyLsp
       end
 
       formatter = options.dig(:initializationOptions, :formatter)
-      @store.formatter = formatter unless formatter.nil?
+      @store.formatter = if formatter == "auto"
+        detected_formatter
+      else
+        formatter
+      end
 
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
       experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled)
@@ -468,5 +535,39 @@ module RubyLsp
         ),
       )
     end
+
+    sig { returns(String) }
+    def detected_formatter
+      # NOTE: Intentionally no $ at end, since we want to match rubocop-shopify, etc.
+      if direct_dependency?(/^rubocop/)
+        "rubocop"
+      elsif direct_dependency?(/^syntax_tree$/)
+        "syntax_tree"
+      else
+        "none"
+      end
+    end
+
+    sig { params(gem_pattern: Regexp).returns(T::Boolean) }
+    def direct_dependency?(gem_pattern)
+      Bundler.locked_gems.dependencies.keys.grep(gem_pattern).any?
+    end
+
+    sig { void }
+    def check_formatter_is_available
+      # Warn of an unavailable `formatter` setting, e.g. `rubocop` on a project which doesn't have RuboCop.
+      # Syntax Tree will always be available via Ruby LSP so we don't need to check for it.
+      return unless @store.formatter == "rubocop"
+
+      unless defined?(RubyLsp::Requests::Support::RuboCopRunner)
+        @message_queue << Notification.new(
+          message: "window/showMessage",
+          params: Interface::ShowMessageParams.new(
+            type: Constant::MessageType::ERROR,
+            message: "Ruby LSP formatter is set to `rubocop` but RuboCop was not found in the bundle.",
+          ),
+        )
+      end
+    end
   end
 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

@@ -15,3 +15,5 @@ require "ruby_lsp/event_emitter"
 require "ruby_lsp/requests"
 require "ruby_lsp/listener"
 require "ruby_lsp/store"
+require "ruby_lsp/extension"
+require "ruby_lsp/requests/support/rubocop_runner"

data/lib/ruby_lsp/listener.rb

@@ -14,20 +14,23 @@ module RubyLsp
 
     abstract!
 
+    sig { params(emitter: EventEmitter, message_queue: Thread::Queue).void }
+    def initialize(emitter, message_queue)
+      @emitter = emitter
+      @message_queue = message_queue
+    end
+
     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]))
+      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
     end
 

data/lib/ruby_lsp/requests/base_request.rb

@@ -18,11 +18,6 @@ module RubyLsp
       sig { params(document: Document, _kwargs: T.untyped).void }
       def initialize(document, **_kwargs)
         @document = document
-
-        # Parsing the document here means we're taking a lazy approach by only doing it when the first feature request
-        # is received by the server. This happens because {Document#parse} remembers if there are new edits to be parsed
-        @document.parse
-
         super()
       end
 

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Code action resolve demo](../../misc/code_action_resolve.gif)
+    # ![Code action resolve demo](../../code_action_resolve.gif)
     #
     # The [code action resolve](https://microsoft.github.io/language-server-protocol/specification#codeAction_resolve)
     # request is used to to resolve the edit field for a given code action, if it is not already provided in the

data/lib/ruby_lsp/requests/code_actions.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Code actions demo](../../misc/code_actions.gif)
+    # ![Code actions demo](../../code_actions.gif)
     #
     # The [code actions](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeAction)
     # request informs the editor of RuboCop quick fixes that can be applied. These are accessible by hovering over a