ruby-lsp 0.4.5 → 0.5.1

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
-      @messages = T.let([], T::Array[Message])
+      @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, messages: @messages)
+      Result.new(response: response, error: error, request_time: request_time)
     end
 
     private
@@ -43,7 +43,7 @@ module RubyLsp
         errored_extensions = Extension.extensions.select(&:error?)
 
         if errored_extensions.any?
-          @messages << Notification.new(
+          @message_queue << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
               type: Constant::MessageType::WARNING,
@@ -54,6 +54,8 @@ module RubyLsp
           warn(errored_extensions.map(&:backtraces).join("\n\n"))
         end
 
+        check_formatter_is_available
+
         warn("Ruby LSP is ready")
         VOID
       when "textDocument/didOpen"
@@ -63,7 +65,7 @@ module RubyLsp
           request.dig(:params, :textDocument, :version),
         )
       when "textDocument/didClose"
-        @messages << Notification.new(
+        @message_queue << Notification.new(
           message: "textDocument/publishDiagnostics",
           params: Interface::PublishDiagnosticsParams.new(uri: uri, diagnostics: []),
         )
@@ -77,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"
@@ -91,7 +114,7 @@ module RubyLsp
         begin
           formatting(uri)
         rescue Requests::Formatting::InvalidFormatter => error
-          @messages << Notification.new(
+          @message_queue << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
               type: Constant::MessageType::ERROR,
@@ -101,7 +124,7 @@ module RubyLsp
 
           nil
         rescue StandardError => error
-          @messages << Notification.new(
+          @message_queue << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
               type: Constant::MessageType::ERROR,
@@ -127,7 +150,7 @@ module RubyLsp
         begin
           diagnostic(uri)
         rescue StandardError => error
-          @messages << Notification.new(
+          @message_queue << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
               type: Constant::MessageType::ERROR,
@@ -139,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,
@@ -166,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)
@@ -177,31 +190,18 @@ module RubyLsp
       end
 
       # Instantiate all listeners
-      base_listener = Requests::Hover.new
-      listeners = Requests::Hover.listeners.map(&:new)
+      emitter = EventEmitter.new
+      base_listener = Requests::Hover.new(emitter, @message_queue)
+      listeners = Requests::Hover.listeners.map { |l| l.new(emitter, @message_queue) }
 
       # Emit events for all listeners
-      T.unsafe(EventEmitter).new(base_listener, *listeners).emit_for_target(target)
+      emitter.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]) }
-    def document_link(uri)
-      @store.cache_fetch(uri, :document_link) do |document|
-        RubyLsp::Requests::DocumentLink.new(document).run
-      end
-    end
-
-    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
-    end
-
     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)
@@ -227,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
 
@@ -247,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,
@@ -260,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
 
@@ -314,7 +317,7 @@ module RubyLsp
 
       case result
       when Requests::CodeActionResolve::Error::EmptySelection
-        @messages << Notification.new(
+        @message_queue << Notification.new(
           message: "window/showMessage",
           params: Interface::ShowMessageParams.new(
             type: Constant::MessageType::ERROR,
@@ -323,7 +326,7 @@ module RubyLsp
         )
         raise Requests::CodeActionResolve::CodeActionError
       when Requests::CodeActionResolve::Error::InvalidTargetRange
-        @messages << Notification.new(
+        @message_queue << Notification.new(
           message: "window/showMessage",
           params: Interface::ShowMessageParams.new(
             type: Constant::MessageType::ERROR,
@@ -338,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
 
@@ -365,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) }
@@ -382,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)
@@ -491,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/internal.rb

@@ -6,6 +6,7 @@ require "syntax_tree"
 require "language_server-protocol"
 require "benchmark"
 require "bundler"
+require "uri"
 
 require "ruby-lsp"
 require "ruby_lsp/utils"
@@ -16,3 +17,4 @@ 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,12 +14,15 @@ 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
-
       sig { returns(T::Array[T.class_of(Listener)]) }
       def listeners
         @listeners ||= T.let([], T.nilable(T::Array[T.class_of(Listener)]))
@@ -29,16 +32,6 @@ module RubyLsp
       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

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

data/lib/ruby_lsp/requests/code_lens.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Code lens demo](../../misc/code_lens.gif)
+    # ![Code lens demo](../../code_lens.gif)
     #
     # This feature is currently experimental. Clients will need to pass `experimentalFeaturesEnabled`
     # in the initialization options to enable it.
@@ -19,41 +19,41 @@ module RubyLsp
     # class Test < Minitest::Test
     # end
     # ```
+    class CodeLens < Listener
+      extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T::Array[Interface::CodeLens] } }
 
-    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(ResponseType) }
+      attr_reader :response
+
+      sig { params(uri: String, emitter: EventEmitter, message_queue: Thread::Queue).void }
+      def initialize(uri, emitter, message_queue)
+        super(emitter, message_queue)
+
+        @response = T.let([], ResponseType)
+        @path = T.let(T.must(URI(uri).path), String)
+        @visibility = T.let("public", String)
+        @prev_visibility = T.let("public", String)
 
-      sig { override.returns(T.all(T::Array[Interface::CodeLens], Object)) }
-      def run
-        visit(@document.tree) if @document.parsed?
-        @results
+        emitter.register(self, :on_class, :on_def, :on_command, :after_command, :on_call, :after_call, :on_vcall)
       end
 
-      sig { override.params(node: SyntaxTree::ClassDeclaration).void }
-      def visit_class(node)
+      sig { params(node: SyntaxTree::ClassDeclaration).void }
+      def on_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"
+      sig { params(node: SyntaxTree::DefNode).void }
+      def on_def(node)
+        if @visibility == "public"
           method_name = node.name.value
           if method_name.start_with?("test_")
             add_code_lens(
@@ -65,69 +65,85 @@ module RubyLsp
         end
       end
 
-      sig { override.params(node: SyntaxTree::Command).void }
-      def visit_command(node)
-        if node.message.value == "public"
-          with_visiblity("public", node)
+      sig { params(node: SyntaxTree::Command).void }
+      def on_command(node)
+        if ACCESS_MODIFIERS.include?(node.message.value) && node.arguments.parts.any?
+          @prev_visibility = @visibility
+          @visibility = node.message.value
         end
       end
 
-      sig { override.params(node: SyntaxTree::CallNode).void }
-      def visit_call(node)
+      sig { params(node: SyntaxTree::Command).void }
+      def after_command(node)
+        @visibility = @prev_visibility
+      end
+
+      sig { params(node: SyntaxTree::CallNode).void }
+      def on_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)
+          ident_value = T.cast(ident, SyntaxTree::Ident).value
+          if ACCESS_MODIFIERS.include?(ident_value)
+            @prev_visibility = @visibility
+            @visibility = ident_value
           end
         end
       end
 
-      sig { override.params(node: SyntaxTree::VCall).void }
-      def visit_vcall(node)
+      sig { params(node: SyntaxTree::CallNode).void }
+      def after_call(node)
+        @visibility = @prev_visibility
+      end
+
+      sig { params(node: SyntaxTree::VCall).void }
+      def on_vcall(node)
         vcall_value = node.value.value
 
         if ACCESS_MODIFIERS.include?(vcall_value)
-          @modifier = vcall_value
+          @prev_visibility = vcall_value
+          @visibility = 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)
+      sig { params(other: Listener[ResponseType]).returns(T.self_type) }
+      def merge_response!(other)
+        @response.concat(other.response)
+        self
       end
 
+      private
+
       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" },
+        @response << create_code_lens(
+          node,
+          title: "Run",
+          command_name: "rubyLsp.runTest",
+          path: @path,
+          name: name,
+          test_command: command,
+          type: "test",
+        )
+
+        @response << create_code_lens(
+          node,
+          title: "Run In Terminal",
+          command_name: "rubyLsp.runTestInTerminal",
+          path: @path,
+          name: name,
+          test_command: command,
+          type: "test_in_terminal",
+        )
+
+        @response << create_code_lens(
+          node,
+          title: "Debug",
+          command_name: "rubyLsp.debugTest",
+          path: @path,
+          name: name,
+          test_command: command,
+          type: "debug",
         )
       end
     end

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -5,7 +5,7 @@ require "ruby_lsp/requests/support/rubocop_diagnostics_runner"
 
 module RubyLsp
   module Requests
-    # ![Diagnostics demo](../../misc/diagnostics.gif)
+    # ![Diagnostics demo](../../diagnostics.gif)
     #
     # The
     # [diagnostics](https://microsoft.github.io/language-server-protocol/specification#textDocument_publishDiagnostics)
@@ -34,7 +34,7 @@ module RubyLsp
         return unless defined?(Support::RuboCopDiagnosticsRunner)
 
         # Don't try to run RuboCop diagnostics for files outside the current working directory
-        return unless @uri.start_with?(WORKSPACE_URI)
+        return unless URI(@uri).path&.start_with?(T.must(WORKSPACE_URI.path))
 
         Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document)
       end

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Document highlight demo](../../misc/document_highlight.gif)
+    # ![Document highlight demo](../../document_highlight.gif)
     #
     # The [document highlight](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentHighlight)
     # informs the editor all relevant elements of the currently pointed item for highlighting. For example, when