ruby-lsp 0.8.0 → 0.9.0

data/lib/ruby_lsp/executor.rb

@@ -15,6 +15,7 @@ module RubyLsp
       @store = store
       @test_library = T.let(DependencyDetector.detected_test_library, String)
       @message_queue = message_queue
+      @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
     end
 
     sig { params(request: T::Hash[Symbol, T.untyped]).returns(Result) }
@@ -57,6 +58,7 @@ module RubyLsp
           warn(errored_extensions.map(&:backtraces).join("\n\n"))
         end
 
+        perform_initial_indexing
         check_formatter_is_available
 
         warn("Ruby LSP is ready")
@@ -169,25 +171,91 @@ module RubyLsp
         completion(uri, request.dig(:params, :position))
       when "textDocument/definition"
         definition(uri, request.dig(:params, :position))
+      when "workspace/didChangeWatchedFiles"
+        did_change_watched_files(request.dig(:params, :changes))
+      when "workspace/symbol"
+        workspace_symbol(request.dig(:params, :query))
       when "rubyLsp/textDocument/showSyntaxTree"
         show_syntax_tree(uri, request.dig(:params, :range))
       end
     end
 
+    sig { params(changes: T::Array[{ uri: String, type: Integer }]).returns(Object) }
+    def did_change_watched_files(changes)
+      changes.each do |change|
+        # File change events include folders, but we're only interested in files
+        uri = URI(change[:uri])
+        file_path = uri.to_standardized_path
+        next if file_path.nil? || File.directory?(file_path)
+
+        case change[:type]
+        when Constant::FileChangeType::CREATED
+          @index.index_single(file_path)
+        when Constant::FileChangeType::CHANGED
+          @index.delete(file_path)
+          @index.index_single(file_path)
+        when Constant::FileChangeType::DELETED
+          @index.delete(file_path)
+        end
+      end
+
+      VOID
+    end
+
+    sig { void }
+    def perform_initial_indexing
+      return unless @store.experimental_features
+
+      # The begin progress invocation happens during `initialize`, so that the notification is sent before we are
+      # stuck indexing files
+      RubyIndexer.configuration.load_config
+
+      begin
+        @index.index_all
+      rescue StandardError => error
+        @message_queue << Notification.new(
+          message: "window/showMessage",
+          params: Interface::ShowMessageParams.new(
+            type: Constant::MessageType::ERROR,
+            message: "Error while indexing: #{error.message}",
+          ),
+        )
+      end
+
+      # Always end the progress notification even if indexing failed or else it never goes away and the user has no way
+      # of dismissing it
+      end_progress("indexing-progress")
+    end
+
+    sig { params(query: T.nilable(String)).returns(T::Array[Interface::WorkspaceSymbol]) }
+    def workspace_symbol(query)
+      Requests::WorkspaceSymbol.new(query, @index).run
+    end
+
     sig { params(uri: URI::Generic, range: T.nilable(Document::RangeShape)).returns({ ast: String }) }
     def show_syntax_tree(uri, range)
       { ast: Requests::ShowSyntaxTree.new(@store.get(uri), range).run }
     end
 
-    sig { params(uri: URI::Generic, position: Document::PositionShape).returns(T.nilable(Interface::Location)) }
+    sig do
+      params(
+        uri: URI::Generic,
+        position: Document::PositionShape,
+      ).returns(T.nilable(T.any(T::Array[Interface::Location], Interface::Location)))
+    end
     def definition(uri, position)
       document = @store.get(uri)
       return if document.syntax_error?
 
-      target, _parent = document.locate_node(position, node_types: [SyntaxTree::Command])
+      target, parent, nesting = document.locate_node(
+        position,
+        node_types: [SyntaxTree::Command, SyntaxTree::Const, SyntaxTree::ConstPathRef],
+      )
+
+      target = parent if target.is_a?(SyntaxTree::Const) && parent.is_a?(SyntaxTree::ConstPathRef)
 
       emitter = EventEmitter.new
-      base_listener = Requests::Definition.new(uri, emitter, @message_queue)
+      base_listener = Requests::Definition.new(uri, nesting, @index, emitter, @message_queue)
       emitter.emit_for_target(target)
       base_listener.response
     end
@@ -209,16 +277,20 @@ module RubyLsp
       document = @store.get(uri)
       return if document.syntax_error?
 
-      target, parent = document.locate_node(position)
+      target, parent, nesting = document.locate_node(
+        position,
+        node_types: Requests::Hover::ALLOWED_TARGETS,
+      )
 
-      if !Requests::Hover::ALLOWED_TARGETS.include?(target.class) &&
-          Requests::Hover::ALLOWED_TARGETS.include?(parent.class)
+      if (Requests::Hover::ALLOWED_TARGETS.include?(parent.class) &&
+          !Requests::Hover::ALLOWED_TARGETS.include?(target.class)) ||
+          (parent.is_a?(SyntaxTree::ConstPathRef) && target.is_a?(SyntaxTree::Const))
         target = parent
       end
 
       # Instantiate all listeners
       emitter = EventEmitter.new
-      hover = Requests::Hover.new(emitter, @message_queue)
+      hover = Requests::Hover.new(@index, nesting, emitter, @message_queue)
 
       # Emit events for all listeners
       emitter.emit_for_target(target)
@@ -436,6 +508,37 @@ module RubyLsp
       listener.response
     end
 
+    sig { params(id: String, title: String).void }
+    def begin_progress(id, title)
+      return unless @store.supports_progress
+
+      @message_queue << Request.new(
+        message: "window/workDoneProgress/create",
+        params: Interface::WorkDoneProgressCreateParams.new(token: id),
+      )
+
+      @message_queue << Notification.new(
+        message: "$/progress",
+        params: Interface::ProgressParams.new(
+          token: id,
+          value: Interface::WorkDoneProgressBegin.new(kind: "begin", title: title),
+        ),
+      )
+    end
+
+    sig { params(id: String).void }
+    def end_progress(id)
+      return unless @store.supports_progress
+
+      @message_queue << Notification.new(
+        message: "$/progress",
+        params: Interface::ProgressParams.new(
+          token: id,
+          value: Interface::WorkDoneProgressEnd.new(kind: "end"),
+        ),
+      )
+    end
+
     sig { params(options: T::Hash[Symbol, T.untyped]).returns(Interface::InitializeResult) }
     def initialize_request(options)
       @store.clear
@@ -449,6 +552,7 @@ module RubyLsp
         encodings.first
       end
 
+      @store.supports_progress = options.dig(:capabilities, :window, :workDoneProgress) || true
       formatter = options.dig(:initializationOptions, :formatter) || "auto"
       @store.formatter = if formatter == "auto"
         DependencyDetector.detected_formatter
@@ -457,9 +561,7 @@ module RubyLsp
       end
 
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
-
-      # Uncomment the line below and use the variable to gate features behind the experimental flag
-      # experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled)
+      @store.experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
 
       enabled_features = case configured_features
       when Array
@@ -541,6 +643,37 @@ module RubyLsp
         )
       end
 
+      if @store.experimental_features
+        # Dynamically registered capabilities
+        file_watching_caps = options.dig(:capabilities, :workspace, :didChangeWatchedFiles)
+
+        # Not every client supports dynamic registration or file watching
+        if file_watching_caps&.dig(:dynamicRegistration) && file_watching_caps&.dig(:relativePatternSupport)
+          @message_queue << Request.new(
+            message: "client/registerCapability",
+            params: Interface::RegistrationParams.new(
+              registrations: [
+                # Register watching Ruby files
+                Interface::Registration.new(
+                  id: "workspace/didChangeWatchedFiles",
+                  method: "workspace/didChangeWatchedFiles",
+                  register_options: Interface::DidChangeWatchedFilesRegistrationOptions.new(
+                    watchers: [
+                      Interface::FileSystemWatcher.new(
+                        glob_pattern: "**/*.rb",
+                        kind: Constant::WatchKind::CREATE | Constant::WatchKind::CHANGE | Constant::WatchKind::DELETE,
+                      ),
+                    ],
+                  ),
+                ),
+              ],
+            ),
+          )
+        end
+
+        begin_progress("indexing-progress", "Ruby LSP: indexing files")
+      end
+
       Interface::InitializeResult.new(
         capabilities: Interface::ServerCapabilities.new(
           text_document_sync: Interface::TextDocumentSyncOptions.new(
@@ -563,6 +696,7 @@ module RubyLsp
           completion_provider: completion_provider,
           code_lens_provider: code_lens_provider,
           definition_provider: enabled_features["definition"],
+          workspace_symbol_provider: enabled_features["workspaceSymbol"],
         ),
       )
     end

data/lib/ruby_lsp/internal.rb

@@ -3,6 +3,7 @@
 
 require "sorbet-runtime"
 require "syntax_tree"
+require "yarp"
 require "language_server-protocol"
 require "benchmark"
 require "bundler"
@@ -10,6 +11,7 @@ require "uri"
 require "cgi"
 
 require "ruby-lsp"
+require "ruby_indexer/ruby_indexer"
 require "core_ext/uri"
 require "ruby_lsp/utils"
 require "ruby_lsp/server"

data/lib/ruby_lsp/requests/definition.rb

@@ -9,29 +9,51 @@ module RubyLsp
     # request](https://microsoft.github.io/language-server-protocol/specification#textDocument_definition) jumps to the
     # definition of the symbol under the cursor.
     #
-    # Currently, only jumping to required files is supported.
+    # Currently, only jumping to classes, modules and required files is supported.
     #
     # # Example
     #
     # ```ruby
     # require "some_gem/file" # <- Request go to definition on this string will take you to the file
+    # Product.new # <- Request go to definition on this class name will take you to its declaration.
     # ```
     class Definition < Listener
       extend T::Sig
       extend T::Generic
 
-      ResponseType = type_member { { fixed: T.nilable(Interface::Location) } }
+      ResponseType = type_member { { fixed: T.nilable(T.any(T::Array[Interface::Location], Interface::Location)) } }
 
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      sig { params(uri: URI::Generic, emitter: EventEmitter, message_queue: Thread::Queue).void }
-      def initialize(uri, emitter, message_queue)
+      sig do
+        params(
+          uri: URI::Generic,
+          nesting: T::Array[String],
+          index: RubyIndexer::Index,
+          emitter: EventEmitter,
+          message_queue: Thread::Queue,
+        ).void
+      end
+      def initialize(uri, nesting, index, emitter, message_queue)
         super(emitter, message_queue)
 
         @uri = uri
+        @nesting = nesting
+        @index = index
         @response = T.let(nil, ResponseType)
-        emitter.register(self, :on_command)
+        emitter.register(self, :on_command, :on_const, :on_const_path_ref)
+      end
+
+      sig { params(node: SyntaxTree::ConstPathRef).void }
+      def on_const_path_ref(node)
+        name = full_constant_name(node)
+        find_in_index(name)
+      end
+
+      sig { params(node: SyntaxTree::Const).void }
+      def on_const(node)
+        find_in_index(node.value)
       end
 
       sig { params(node: SyntaxTree::Command).void }
@@ -79,6 +101,39 @@ module RubyLsp
 
       private
 
+      sig { params(value: String).void }
+      def find_in_index(value)
+        entries = @index.resolve(value, @nesting)
+        return unless entries
+
+        bundle_path = begin
+          Bundler.bundle_path.to_s
+        rescue Bundler::GemfileNotFound
+          nil
+        end
+
+        @response = entries.filter_map do |entry|
+          location = entry.location
+          # If the project has Sorbet, then we only want to handle go to definition for constants defined in gems, as an
+          # additional behavior on top of jumping to RBIs. Sorbet can already handle go to definition for all constants
+          # in the project, even if the files are typed false
+          file_path = entry.file_path
+          if DependencyDetector::HAS_TYPECHECKER && bundle_path && !file_path.start_with?(bundle_path) &&
+              !file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
+
+            next
+          end
+
+          Interface::Location.new(
+            uri: URI::Generic.from_path(path: file_path).to_s,
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
+              end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
+            ),
+          )
+        end
+      end
+
       sig { params(file: String).returns(T.nilable(String)) }
       def find_file_in_load_path(file)
         return unless file.include?("/")

data/lib/ruby_lsp/requests/hover.rb

@@ -3,19 +3,15 @@
 
 module RubyLsp
   module Requests
-    # ![Hover demo](../../rails_document_link_hover.gif)
+    # ![Hover demo](../../hover.gif)
     #
     # The [hover request](https://microsoft.github.io/language-server-protocol/specification#textDocument_hover)
-    # renders a clickable link to the code's official documentation.
-    # It currently only supports Rails' documentation: when hovering over Rails DSLs/constants under certain paths,
-    # like `before_save :callback` in `models/post.rb`, it generates a link to `before_save`'s API documentation.
+    # displays the documentation for the symbol currently under the cursor.
     #
     # # Example
     #
     # ```ruby
-    # class Post < ApplicationRecord
-    #   before_save :do_something # when hovering on before_save, the link will be rendered
-    # end
+    # String # -> Hovering over the class reference will show all declaration locations and the documentation
     # ```
     class Hover < Listener
       extend T::Sig
@@ -25,6 +21,7 @@ module RubyLsp
 
       ALLOWED_TARGETS = T.let(
         [
+          SyntaxTree::Const,
           SyntaxTree::Command,
           SyntaxTree::CallNode,
           SyntaxTree::ConstPathRef,
@@ -35,15 +32,24 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      sig { params(emitter: EventEmitter, message_queue: Thread::Queue).void }
-      def initialize(emitter, message_queue)
-        super
+      sig do
+        params(
+          index: RubyIndexer::Index,
+          nesting: T::Array[String],
+          emitter: EventEmitter,
+          message_queue: Thread::Queue,
+        ).void
+      end
+      def initialize(index, nesting, emitter, message_queue)
+        super(emitter, message_queue)
 
+        @nesting = nesting
+        @index = index
         @external_listeners.concat(
           Extension.extensions.filter_map { |ext| ext.create_hover_listener(emitter, message_queue) },
         )
         @response = T.let(nil, ResponseType)
-        emitter.register(self, :on_command, :on_const_path_ref, :on_call)
+        emitter.register(self, :on_const_path_ref, :on_const)
       end
 
       # Merges responses from other hover listeners
@@ -55,40 +61,57 @@ module RubyLsp
         if @response.nil?
           @response = other.response
         else
-          @response.contents.value << other_response.contents.value << "\n\n"
+          @response.contents.value << "\n\n" << other_response.contents.value
         end
 
         self
       end
 
-      sig { params(node: SyntaxTree::Command).void }
-      def on_command(node)
-        message = node.message
-        @response = generate_rails_document_link_hover(message.value, message)
-      end
-
       sig { params(node: SyntaxTree::ConstPathRef).void }
       def on_const_path_ref(node)
-        @response = generate_rails_document_link_hover(full_constant_name(node), node)
+        return if DependencyDetector::HAS_TYPECHECKER
+
+        name = full_constant_name(node)
+        generate_hover(name, node)
       end
 
-      sig { params(node: SyntaxTree::CallNode).void }
-      def on_call(node)
-        message = node.message
-        return if message.is_a?(Symbol)
+      sig { params(node: SyntaxTree::Const).void }
+      def on_const(node)
+        return if DependencyDetector::HAS_TYPECHECKER
 
-        @response = generate_rails_document_link_hover(message.value, message)
+        generate_hover(node.value, node)
       end
 
       private
 
-      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?
+      sig { params(name: String, node: SyntaxTree::Node).void }
+      def generate_hover(name, node)
+        entries = @index.resolve(name, @nesting)
+        return unless entries
+
+        title = +"```ruby\n#{name}\n```"
+        definitions = []
+        content = +""
+        entries.each do |entry|
+          loc = entry.location
+
+          # We always handle locations as zero based. However, for file links in Markdown we need them to be one based,
+          # which is why instead of the usual subtraction of 1 to line numbers, we are actually adding 1 to columns. The
+          # format for VS Code file URIs is `file:///path/to/file.rb#Lstart_line,start_column-end_line,end_column`
+          uri = URI::Generic.from_path(
+            path: entry.file_path,
+            fragment: "L#{loc.start_line},#{loc.start_column + 1}-#{loc.end_line},#{loc.end_column + 1}",
+          )
+
+          definitions << "[#{entry.file_name}](#{uri})"
+          content << "\n\n#{entry.comments.join("\n")}" unless entry.comments.empty?
+        end
 
-        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: "#{title}\n\n**Definitions**: #{definitions.join(" | ")}\n\n#{content}",
+        )
+        @response = Interface::Hover.new(range: range_from_syntax_tree_node(node), contents: contents)
       end
     end
   end

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -67,12 +67,10 @@ module RubyLsp
 
         line = T.must(current_line)
 
-        # If the current character is a pipe and both previous ones are pipes too, then we autocompleted a pipe and the
-        # user inserted a third one. In this case, we need to avoid adding a fourth and remove the previous one
-        if line[@position[:character] - 2] == "|" &&
-            line[@position[:character] - 1] == "|" &&
-            line[@position[:character]] == "|"
-
+        # If the user inserts the closing pipe manually to the end of the block argument, we need to avoid adding
+        # an additional one and remove the previous one.  This also helps to remove the user who accidentally
+        # inserts another pipe after the autocompleted one.
+        if line[..@position[:character]] =~ /(do|{)\s+\|[^|]*\|\|$/
           @edits << Interface::TextEdit.new(
             range: Interface::Range.new(
               start: Interface::Position.new(

data/lib/ruby_lsp/requests/support/dependency_detector.rb

@@ -36,6 +36,11 @@ module RubyLsp
         end
       end
 
+      sig { returns(T::Boolean) }
+      def typechecker?
+        direct_dependency?(/^sorbet/) || direct_dependency?(/^sorbet-static-and-runtime/)
+      end
+
       sig { params(gem_pattern: Regexp).returns(T::Boolean) }
       def direct_dependency?(gem_pattern)
         Bundler.with_original_env { Bundler.default_gemfile } &&
@@ -44,5 +49,7 @@ module RubyLsp
         false
       end
     end
+
+    HAS_TYPECHECKER = T.let(typechecker?, T::Boolean)
   end
 end

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -0,0 +1,86 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Workspace symbol demo](../../workspace_symbol.gif)
+    #
+    # The [workspace symbol](https://microsoft.github.io/language-server-protocol/specification#workspace_symbol)
+    # request allows fuzzy searching declarations in the entire project. On VS Code, use CTRL/CMD + T to search for
+    # symbols.
+    #
+    # # Example
+    #
+    # ```ruby
+    # # Searching for `Floo` will fuzzy match and return all declarations according to the query, including this `Foo`
+    # class
+    # class Foo
+    # end
+    # ```
+    #
+    class WorkspaceSymbol
+      extend T::Sig
+
+      sig { params(query: T.nilable(String), index: RubyIndexer::Index).void }
+      def initialize(query, index)
+        @query = query
+        @index = index
+      end
+
+      sig { returns(T::Array[Interface::WorkspaceSymbol]) }
+      def run
+        bundle_path = begin
+          Bundler.bundle_path.to_s
+        rescue Bundler::GemfileNotFound
+          nil
+        end
+
+        @index.fuzzy_search(@query).filter_map do |entry|
+          # If the project is using Sorbet, we let Sorbet handle symbols defined inside the project itself and RBIs, but
+          # we still return entries defined in gems to allow developers to jump directly to the source
+          file_path = entry.file_path
+          if DependencyDetector::HAS_TYPECHECKER && bundle_path && !file_path.start_with?(bundle_path) &&
+              !file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
+
+            next
+          end
+
+          kind = kind_for_entry(entry)
+          loc = entry.location
+
+          # We use the namespace as the container name, but we also use the full name as the regular name. The reason we
+          # do this is to allow people to search for fully qualified names (e.g.: `Foo::Bar`). If we only included the
+          # short name `Bar`, then searching for `Foo::Bar` would not return any results
+          *container, _short_name = entry.name.split("::")
+
+          Interface::WorkspaceSymbol.new(
+            name: entry.name,
+            container_name: T.must(container).join("::"),
+            kind: kind,
+            location: Interface::Location.new(
+              uri: URI::Generic.from_path(path: file_path).to_s,
+              range:  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
+      end
+
+      private
+
+      sig { params(entry: RubyIndexer::Index::Entry).returns(T.nilable(Integer)) }
+      def kind_for_entry(entry)
+        case entry
+        when RubyIndexer::Index::Entry::Class
+          Constant::SymbolKind::CLASS
+        when RubyIndexer::Index::Entry::Module
+          Constant::SymbolKind::NAMESPACE
+        when RubyIndexer::Index::Entry::Constant
+          Constant::SymbolKind::CONSTANT
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests.rb

@@ -41,6 +41,7 @@ module RubyLsp
     autoload :CodeLens, "ruby_lsp/requests/code_lens"
     autoload :Definition, "ruby_lsp/requests/definition"
     autoload :ShowSyntaxTree, "ruby_lsp/requests/show_syntax_tree"
+    autoload :WorkspaceSymbol, "ruby_lsp/requests/workspace_symbol"
 
     # :nodoc:
     module Support