ruby-lsp 0.4.2 → 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,27 +38,74 @@ 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"
-        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_queue << Notification.new(
           message: "textDocument/publishDiagnostics",
           params: Interface::PublishDiagnosticsParams.new(uri: uri, diagnostics: []),
         )
 
         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"
-        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"
@@ -67,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,
@@ -77,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,
@@ -103,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,
@@ -120,7 +167,7 @@ module RubyLsp
 
     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
@@ -132,32 +179,38 @@ module RubyLsp
       ).returns(T.nilable(Interface::Hover))
     end
     def hover(uri, position)
-      RubyLsp::Requests::Hover.new(@store.get(uri), position).run
-    end
+      document = @store.get(uri)
+      return if document.syntax_error?
 
-    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
-      end
-    end
+      target, parent = document.locate_node(position)
 
-    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
+      if !Requests::Hover::ALLOWED_TARGETS.include?(target.class) &&
+          Requests::Hover::ALLOWED_TARGETS.include?(parent.class)
+        target = parent
       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) }
+
+      # Emit events for all listeners
+      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, 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
 
@@ -174,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
 
@@ -194,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,
@@ -207,7 +260,10 @@ 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
+      # 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
 
     sig do
@@ -250,7 +306,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) }
@@ -261,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,
@@ -270,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,
@@ -285,8 +341,8 @@ 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
+      response = @store.cache_fetch(uri, "textDocument/diagnostic") do |document|
+        Requests::Diagnostics.new(document).run
       end
 
       Interface::FullDocumentDiagnosticReport.new(kind: "full", items: response.map(&:to_lsp_diagnostic)) if response
@@ -312,17 +368,68 @@ 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) }
     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?
+      @store.formatter = if formatter == "auto"
+        detected_formatter
+      else
+        formatter
+      end
 
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
+      experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled)
 
       enabled_features = case configured_features
       when Array
@@ -351,6 +458,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 +517,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,8 +531,43 @@ module RubyLsp
           diagnostic_provider: diagnostics_provider,
           inlay_hint_provider: inlay_hint_provider,
           completion_provider: completion_provider,
+          code_lens_provider: code_lens_provider,
         ),
       )
     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

@@ -11,5 +11,9 @@ 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"
+require "ruby_lsp/requests/support/rubocop_runner"

data/lib/ruby_lsp/listener.rb

@@ -0,0 +1,42 @@
+# 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!
+
+    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::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
+
+    # 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!
 
@@ -17,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
 
@@ -31,94 +27,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(LanguageServer::Protocol::Interface::Range) }
-      def range_from_syntax_tree_node(node)
-        loc = node.location
-
-        LanguageServer::Protocol::Interface::Range.new(
-          start: LanguageServer::Protocol::Interface::Position.new(
-            line: loc.start_line - 1,
-            character: loc.start_column,
-          ),
-          end: LanguageServer::Protocol::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