ruby-lsp 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11dd3401d408ed456da9b4dd0aca906b991a45a0103ca8786eafbf34d4659c85
-  data.tar.gz: 8469dd62a3660965daee589835e1481fe09e17b55cbd9d61c461d4ba94db833e
+  metadata.gz: 812bcf5c0bc5512ad4382440118051b99d79e79d37a2e91e1fbe4341458dd94c
+  data.tar.gz: 73a83f9e143bde544d72819e0c867182a0bc8b82ff2ef2dc98032aecdc28e825
 SHA512:
-  metadata.gz: 6d2e0c3d9c5bf11068b1d5e3092d4b5f3b233066a33b7e74ea218f115fbb8b154798a8b8b0634569781245f1dedcb6da3e5ca3a23db04f78fc105c496d2a3280
-  data.tar.gz: 529ce841833605ac40c67536bbca1eb1a9568b742de854f4698ced147813ec63569fd926d4035d518f7bb0ab54d2bbd4665e7ad2564923b49036573a0d4625e7
+  metadata.gz: 03b1252a63bc78186983a8962b91f2e89efa679e2ee3b4978d655a83e9a6cbdeb6a8171647e416dd4ebf43ae82fc36e04b805444acbc2a7eade386166873026e
+  data.tar.gz: 443e7b58bd600a27827043915897c1d848fe8f07c00d348677a9322dcff005bdb4427d2ceade5347f8256fbb6a68897f85215bdd563110d02b0a1887abb71224

data/README.md

@@ -27,7 +27,11 @@ The gem can be installed by doing
 gem install ruby-lsp
 ```
 
-If you decide to add the gem to the bundle, it is not necessary to require it.
+**NOTE**: starting with v0.7.0, it is no longer recommended to add the `ruby-lsp` to the bundle. The gem will generate a
+custom bundle in `.ruby-lsp/Gemfile` which is used to identify the versions of dependencies that should be used for the
+application (e.g.: the correct RuboCop version).
+
+For older versions, 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
@@ -42,6 +46,15 @@ See the [documentation](https://shopify.github.io/ruby-lsp) for more in-depth de
 For creating rich themes for Ruby using the semantic highlighting information, see the [semantic highlighting
 documentation](SEMANTIC_HIGHLIGHTING.md).
 
+### Extensions
+
+The Ruby LSP provides a server extension system that allows other gems to enhance the base functionality with more
+editor features. This is the mechanism that powers extensions like
+
+- [Ruby LSP Rails](https://github.com/Shopify/ruby-lsp-rails)
+
+For instructions on how to create extensions, see the [server extensions documentation](SERVER_EXTENSIONS.md).
+
 ## Learn More
 
 * [RubyConf 2022: Improving the development experience with language servers](https://www.youtube.com/watch?v=kEfXPTm1aCI) ([Vinicius Stock](https://github.com/vinistock))

data/VERSION

@@ -1 +1 @@
-0.6.1
+0.7.0

data/exe/ruby-lsp

@@ -1,6 +1,19 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+# When we're running without bundler, then we need to make sure the custom bundle is fully configured and re-execute
+# using `BUNDLE_GEMFILE=.ruby-lsp/Gemfile bundle exec ruby-lsp` so that we have access to the gems that are a part of
+# the application's bundle
+if ENV["BUNDLE_GEMFILE"].nil? && File.exist?("Gemfile.lock")
+  require_relative "../lib/ruby_lsp/setup_bundler"
+
+  # In some cases, like when the `ruby-lsp` is already a part of the bundle, we don't generate `.ruby-lsp/Gemfile`.
+  # However, we still want to run the server with `bundle exec`. We need to make sure we're pointing to the right
+  # `Gemfile`
+  bundle_gemfile = File.exist?(".ruby-lsp/Gemfile") ? ".ruby-lsp/Gemfile" : "Gemfile"
+  exit exec("BUNDLE_GEMFILE=#{bundle_gemfile} bundle exec ruby-lsp #{ARGV.join(" ")}")
+end
+
 require "sorbet-runtime"
 
 begin

data/exe/ruby-lsp-check

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This executable checks if all automatic LSP requests run successfully on every Ruby file under the current directory
+
+require "sorbet-runtime"
+
+begin
+  T::Configuration.default_checked_level = :never
+  T::Configuration.call_validation_error_handler = ->(*) {}
+  T::Configuration.inline_type_error_handler = ->(*) {}
+  T::Configuration.sig_validation_error_handler = ->(*) {}
+rescue
+  nil
+end
+
+require_relative "../lib/ruby_lsp/internal"
+
+RubyLsp::Extension.load_extensions
+
+T::Utils.run_all_sig_blocks
+
+files = Dir.glob("#{Dir.pwd}/**/*.rb")
+
+puts "Verifying that all automatic LSP requests execute successfully. This may take a while..."
+
+errors = {}
+store = RubyLsp::Store.new
+message_queue = Thread::Queue.new
+executor = RubyLsp::Executor.new(store, message_queue)
+
+files.each_with_index do |file, index|
+  uri = "file://#{file}"
+  store.set(uri: uri, source: File.read(file), version: 1)
+
+  # Executing any of the automatic requests will execute all of them, so here we just pick one
+  result = executor.execute({
+    method: "textDocument/documentSymbol",
+    params: { textDocument: { uri: uri } },
+  })
+
+  error = result.error
+  errors[file] = error if error
+ensure
+  store.delete(uri)
+  print("\033[M\033[0KCompleted #{index + 1}/#{files.length}") unless ENV["CI"]
+end
+
+puts "\n"
+message_queue.close
+
+if errors.empty?
+  puts "All automatic LSP requests executed successfully"
+  exit
+end
+
+puts <<~ERRORS
+  Errors while executing requests:
+
+  #{errors.map { |file, error| "#{file}: #{error.message}" }.join("\n")}
+ERRORS
+exit!

data/lib/ruby_lsp/check_docs.rb

@@ -52,7 +52,7 @@ module RubyLsp
       # Find all classes that inherit from BaseRequest or Listener, which are the ones we want to make sure are
       # documented
       features = ObjectSpace.each_object(Class).filter_map do |k|
-        klass = T.cast(k, T::Class[T.anything])
+        klass = T.unsafe(k)
         klass if klass < RubyLsp::Requests::BaseRequest || klass < RubyLsp::Listener
       end
 

data/lib/ruby_lsp/document.rb

@@ -114,12 +114,12 @@ module RubyLsp
       params(
         position: PositionShape,
         node_types: T::Array[T.class_of(SyntaxTree::Node)],
-      ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node)])
+      ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node), T::Array[String]])
     end
     def locate_node(position, node_types: [])
-      return [nil, nil] unless parsed?
+      return [nil, nil, []] unless parsed?
 
-      locate(T.must(@tree), create_scanner.find_char_position(position))
+      locate(T.must(@tree), create_scanner.find_char_position(position), node_types: node_types)
     end
 
     sig do
@@ -127,12 +127,13 @@ module RubyLsp
         node: SyntaxTree::Node,
         char_position: Integer,
         node_types: T::Array[T.class_of(SyntaxTree::Node)],
-      ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node)])
+      ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node), T::Array[String]])
     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))
+      nesting = T.let([], T::Array[T.any(SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration)])
 
       until queue.empty?
         candidate = queue.shift
@@ -140,8 +141,10 @@ module RubyLsp
         # Skip nil child nodes
         next if candidate.nil?
 
-        # Add the next child_nodes to the queue to be processed
-        queue.concat(candidate.child_nodes)
+        # Add the next child_nodes to the queue to be processed. The order here is important! We want to move in the
+        # same order as the visiting mechanism, which means searching the child nodes before moving on to the next
+        # sibling
+        queue.unshift(*candidate.child_nodes)
 
         # Skip if the current node doesn't cover the desired position
         loc = candidate.location
@@ -151,6 +154,17 @@ module RubyLsp
         # already
         break if char_position < loc.start_char
 
+        # If the candidate starts after the end of the previous nesting level, then we've exited that nesting level and
+        # need to pop the stack
+        previous_level = nesting.last
+        nesting.pop if previous_level && candidate.start_char > previous_level.end_char
+
+        # Keep track of the nesting where we found the target. This is used to determine the fully qualified name of the
+        # target when it is a constant
+        if candidate.is_a?(SyntaxTree::ClassDeclaration) || candidate.is_a?(SyntaxTree::ModuleDeclaration)
+          nesting << candidate
+        end
+
         # 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 }
 
@@ -162,7 +176,7 @@ module RubyLsp
         end
       end
 
-      [closest, parent]
+      [closest, parent, nesting.map { |n| n.constant.constant.value }]
     end
 
     class Scanner

data/lib/ruby_lsp/event_emitter.rb

@@ -53,6 +53,12 @@ module RubyLsp
 
     # Visit dispatchers are below. Notice that for nodes that create a new scope (e.g.: classes, modules, method defs)
     # we need both an `on_*` and `after_*` event. This is because some requests must know when we exit the scope
+    sig { override.params(node: T.nilable(SyntaxTree::Node)).void }
+    def visit(node)
+      @listeners[:on_node]&.each { |l| T.unsafe(l).on_node(node) }
+      super
+    end
+
     sig { override.params(node: SyntaxTree::ClassDeclaration).void }
     def visit_class(node)
       @listeners[:on_class]&.each { |l| T.unsafe(l).on_class(node) }

data/lib/ruby_lsp/executor.rb

@@ -97,13 +97,11 @@ module RubyLsp
         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, @test_library)
-        code_lens_extensions_listeners = Requests::CodeLens.listeners.map do |l|
-          T.unsafe(l).new(document.uri, emitter, @message_queue)
-        end
+
         semantic_highlighting = Requests::SemanticHighlighting.new(emitter, @message_queue)
         emitter.visit(document.tree) if document.parsed?
 
-        code_lens_extensions_listeners.each { |ext| code_lens.merge_response!(ext) }
+        code_lens.merge_external_listeners_responses!
 
         # Store all responses retrieve in this round of visits in the cache and then return the response for the request
         # we actually received
@@ -130,7 +128,7 @@ module RubyLsp
           )
 
           nil
-        rescue StandardError => error
+        rescue StandardError, LoadError => error
           @message_queue << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
@@ -156,7 +154,7 @@ module RubyLsp
       when "textDocument/diagnostic"
         begin
           diagnostic(uri)
-        rescue StandardError => error
+        rescue StandardError, LoadError => error
           @message_queue << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
@@ -169,9 +167,26 @@ module RubyLsp
         end
       when "textDocument/completion"
         completion(uri, request.dig(:params, :position))
+      when "textDocument/definition"
+        definition(uri, request.dig(:params, :position))
+      when "rubyLsp/textDocument/showSyntaxTree"
+        { ast: Requests::ShowSyntaxTree.new(@store.get(uri)).run }
       end
     end
 
+    sig { params(uri: String, position: Document::PositionShape).returns(T.nilable(Interface::Location)) }
+    def definition(uri, position)
+      document = @store.get(uri)
+      return if document.syntax_error?
+
+      target, _parent = document.locate_node(position, node_types: [SyntaxTree::Command])
+
+      emitter = EventEmitter.new
+      base_listener = Requests::Definition.new(uri, emitter, @message_queue)
+      emitter.emit_for_target(target)
+      base_listener.response
+    end
+
     sig { params(uri: String).returns(T::Array[Interface::FoldingRange]) }
     def folding_range(uri)
       @store.cache_fetch(uri, "textDocument/foldingRange") do |document|
@@ -198,15 +213,13 @@ module RubyLsp
 
       # 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) }
+      hover = Requests::Hover.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
+      hover.merge_external_listeners_responses!
+      hover.response
     end
 
     sig { params(uri: String, content_changes: T::Array[Document::EditShape], version: Integer).returns(Object) }
@@ -275,10 +288,17 @@ module RubyLsp
       params(
         uri: String,
         position: Document::PositionShape,
-      ).returns(T::Array[Interface::DocumentHighlight])
+      ).returns(T.nilable(T::Array[Interface::DocumentHighlight]))
     end
     def document_highlight(uri, position)
-      Requests::DocumentHighlight.new(@store.get(uri), position).run
+      document = @store.get(uri)
+      return if document.syntax_error?
+
+      target, parent = document.locate_node(position)
+      emitter = EventEmitter.new
+      listener = Requests::DocumentHighlight.new(target, parent, emitter, @message_queue)
+      emitter.visit(document.tree)
+      listener.response
     end
 
     sig { params(uri: String, range: Document::RangeShape).returns(T.nilable(T::Array[Interface::InlayHint])) }
@@ -429,7 +449,9 @@ module RubyLsp
       end
 
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
-      experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled)
+
+      # Uncomment the line below and use the variable to gate features behind the experimental flag
+      # experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled)
 
       enabled_features = case configured_features
       when Array
@@ -458,7 +480,7 @@ module RubyLsp
         Interface::DocumentLinkOptions.new(resolve_provider: false)
       end
 
-      code_lens_provider = if experimental_features
+      code_lens_provider = if enabled_features["codeLens"]
         Interface::CodeLensOptions.new(resolve_provider: false)
       end
 
@@ -532,6 +554,7 @@ module RubyLsp
           inlay_hint_provider: inlay_hint_provider,
           completion_provider: completion_provider,
           code_lens_provider: code_lens_provider,
+          definition_provider: enabled_features["definition"],
         ),
       )
     end

data/lib/ruby_lsp/requests/code_lens.rb

@@ -29,6 +29,7 @@ module RubyLsp
 
       BASE_COMMAND = T.let((File.exist?("Gemfile.lock") ? "bundle exec ruby" : "ruby") + " -Itest ", String)
       ACCESS_MODIFIERS = T.let(["public", "private", "protected"], T::Array[String])
+      SUPPORTED_TEST_LIBRARIES = T.let(["minitest", "test-unit"], T::Array[String])
 
       sig { override.returns(ResponseType) }
       attr_reader :response
@@ -37,6 +38,8 @@ module RubyLsp
       def initialize(uri, emitter, message_queue, test_library)
         super(emitter, message_queue)
 
+        @uri = T.let(uri, String)
+        @external_listeners = T.let([], T::Array[RubyLsp::Listener[ResponseType]])
         @test_library = T.let(test_library, String)
         @response = T.let([], ResponseType)
         @path = T.let(T.must(URI(uri).path), String)
@@ -55,14 +58,31 @@ module RubyLsp
           :after_call,
           :on_vcall,
         )
+
+        register_external_listeners!
+      end
+
+      sig { void }
+      def register_external_listeners!
+        self.class.listeners.each do |l|
+          @external_listeners << T.unsafe(l).new(@uri, @emitter, @message_queue)
+        end
+      end
+
+      sig { void }
+      def merge_external_listeners_responses!
+        @external_listeners.each do |l|
+          merge_response!(l)
+        end
       end
 
       sig { params(node: SyntaxTree::ClassDeclaration).void }
       def on_class(node)
         @visibility_stack.push(["public", "public"])
         class_name = node.constant.constant.value
+        @class_stack.push(class_name)
+
         if class_name.end_with?("Test")
-          @class_stack.push(class_name)
           add_test_code_lens(
             node,
             name: class_name,
@@ -81,7 +101,7 @@ module RubyLsp
       sig { params(node: SyntaxTree::DefNode).void }
       def on_def(node)
         class_name = @class_stack.last
-        return unless class_name
+        return unless class_name&.end_with?("Test")
 
         visibility, _ = @visibility_stack.last
         if visibility == "public"
@@ -156,6 +176,9 @@ module RubyLsp
 
       sig { params(node: SyntaxTree::Node, name: String, command: String, kind: Symbol).void }
       def add_test_code_lens(node, name:, command:, kind:)
+        # don't add code lenses if the test library is not supported or unknown
+        return unless SUPPORTED_TEST_LIBRARIES.include?(@test_library)
+
         arguments = [
           @path,
           name,
@@ -195,10 +218,13 @@ module RubyLsp
 
       sig { params(node: SyntaxTree::Command).returns(T.nilable(String)) }
       def resolve_gem_remote(node)
-        gem_statement = node.arguments.parts.flat_map(&:child_nodes).first
-        return unless gem_statement
+        gem_statement = node.arguments.parts.first
+        return unless gem_statement.is_a?(SyntaxTree::StringLiteral)
+
+        gem_name = gem_statement.parts.first
+        return unless gem_name.is_a?(SyntaxTree::TStringContent)
 
-        spec = Gem::Specification.stubs.find { |gem| gem.name == gem_statement.value }&.to_spec
+        spec = Gem::Specification.stubs.find { |gem| gem.name == gem_name.value }&.to_spec
         return if spec.nil?
 
         [spec.homepage, spec.metadata["source_code_uri"]].compact.find do |page|

data/lib/ruby_lsp/requests/definition.rb

@@ -0,0 +1,95 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Definition demo](../../definition.gif)
+    #
+    # The [definition
+    # 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.
+    #
+    # # Example
+    #
+    # ```ruby
+    # require "some_gem/file" # <- Request go to definition on this string will take you to the file
+    # ```
+    class Definition < Listener
+      extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T.nilable(Interface::Location) } }
+
+      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)
+
+        @uri = uri
+        @response = T.let(nil, ResponseType)
+        emitter.register(self, :on_command)
+      end
+
+      sig { params(node: SyntaxTree::Command).void }
+      def on_command(node)
+        message = node.message.value
+        return unless message == "require" || message == "require_relative"
+
+        argument = node.arguments.parts.first
+        return unless argument.is_a?(SyntaxTree::StringLiteral)
+
+        string = argument.parts.first
+        return unless string.is_a?(SyntaxTree::TStringContent)
+
+        required_file = "#{string.value}.rb"
+
+        case message
+        when "require"
+          candidate = find_file_in_load_path(required_file)
+
+          if candidate
+            @response = Interface::Location.new(
+              uri: "file://#{candidate}",
+              range: Interface::Range.new(
+                start: Interface::Position.new(line: 0, character: 0),
+                end: Interface::Position.new(line: 0, character: 0),
+              ),
+            )
+          end
+        when "require_relative"
+          current_file = T.must(URI.parse(@uri).path)
+          current_folder = Pathname.new(current_file).dirname
+          candidate = File.expand_path(File.join(current_folder, required_file))
+
+          if candidate
+            @response = Interface::Location.new(
+              uri: "file://#{candidate}",
+              range: Interface::Range.new(
+                start: Interface::Position.new(line: 0, character: 0),
+                end: Interface::Position.new(line: 0, character: 0),
+              ),
+            )
+          end
+        end
+      end
+
+      private
+
+      sig { params(file: String).returns(T.nilable(String)) }
+      def find_file_in_load_path(file)
+        return unless file.include?("/")
+
+        $LOAD_PATH.each do |p|
+          found = Dir.glob("**/#{file}", base: p).first
+          return "#{p}/#{found}" if found
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -22,34 +22,49 @@ module RubyLsp
     #   FOO # should be highlighted as "read"
     # end
     # ```
-    class DocumentHighlight < BaseRequest
+    class DocumentHighlight < Listener
       extend T::Sig
 
-      sig { params(document: Document, position: Document::PositionShape).void }
-      def initialize(document, position)
-        super(document)
+      ResponseType = type_member { { fixed: T::Array[Interface::DocumentHighlight] } }
 
-        @highlights = T.let([], T::Array[Interface::DocumentHighlight])
-        return unless document.parsed?
+      sig { override.returns(ResponseType) }
+      attr_reader :response
 
-        @target = T.let(find(position), T.nilable(Support::HighlightTarget))
+      sig do
+        params(
+          target: T.nilable(SyntaxTree::Node),
+          parent: T.nilable(SyntaxTree::Node),
+          emitter: EventEmitter,
+          message_queue: Thread::Queue,
+        ).void
       end
+      def initialize(target, parent, emitter, message_queue)
+        super(emitter, message_queue)
+
+        @response = T.let([], T::Array[Interface::DocumentHighlight])
+
+        return unless target && parent
 
-      sig { override.returns(T.all(T::Array[Interface::DocumentHighlight], Object)) }
-      def run
-        # no @target means the target is not highlightable
-        visit(@document.tree) if @document.parsed? && @target
-        @highlights
+        highlight_target =
+          case target
+          when *DIRECT_HIGHLIGHTS
+            Support::HighlightTarget.new(target)
+          when SyntaxTree::Ident
+            relevant_node = parent.is_a?(SyntaxTree::Params) ? target : parent
+            Support::HighlightTarget.new(relevant_node)
+          end
+
+        @target = T.let(highlight_target, T.nilable(Support::HighlightTarget))
+
+        emitter.register(self, :on_node) if @target
       end
 
-      sig { override.params(node: T.nilable(SyntaxTree::Node)).void }
-      def visit(node)
+      sig { params(node: T.nilable(SyntaxTree::Node)).void }
+      def on_node(node)
         return if node.nil?
 
         match = T.must(@target).highlight_type(node)
         add_highlight(match) if match
-
-        super
       end
 
       private
@@ -65,30 +80,10 @@ module RubyLsp
         T::Array[T.class_of(SyntaxTree::Node)],
       )
 
-      sig do
-        params(
-          position: Document::PositionShape,
-        ).returns(T.nilable(Support::HighlightTarget))
-      end
-      def find(position)
-        matched, parent = @document.locate_node(position)
-
-        return unless matched && parent
-        return unless matched.is_a?(SyntaxTree::Ident) || DIRECT_HIGHLIGHTS.include?(matched.class)
-
-        case matched
-        when *DIRECT_HIGHLIGHTS
-          Support::HighlightTarget.new(matched)
-        when SyntaxTree::Ident
-          relevant_node = parent.is_a?(SyntaxTree::Params) ? matched : parent
-          Support::HighlightTarget.new(relevant_node)
-        end
-      end
-
       sig { params(match: Support::HighlightTarget::HighlightMatch).void }
       def add_highlight(match)
         range = range_from_syntax_tree_node(match.node)
-        @highlights << Interface::DocumentHighlight.new(range: range, kind: match.type)
+        @response << Interface::DocumentHighlight.new(range: range, kind: match.type)
       end
     end
   end

data/lib/ruby_lsp/requests/hover.rb

@@ -39,8 +39,25 @@ module RubyLsp
       def initialize(emitter, message_queue)
         super
 
+        @external_listeners = T.let([], T::Array[RubyLsp::Listener[ResponseType]])
         @response = T.let(nil, ResponseType)
         emitter.register(self, :on_command, :on_const_path_ref, :on_call)
+
+        register_external_listeners!
+      end
+
+      sig { void }
+      def register_external_listeners!
+        self.class.listeners.each do |l|
+          @external_listeners << T.unsafe(l).new(@emitter, @message_queue)
+        end
+      end
+
+      sig { void }
+      def merge_external_listeners_responses!
+        @external_listeners.each do |l|
+          merge_response!(l)
+        end
       end
 
       # Merges responses from other hover listeners

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -30,13 +30,11 @@ module RubyLsp
       def initialize(document, position, trigger_character)
         super(document)
 
-        scanner = document.create_scanner
-        line_begin = position[:line] == 0 ? 0 : scanner.find_char_position({ line: position[:line] - 1, character: 0 })
-        @line_end = T.let(scanner.find_char_position(position), Integer)
-        line = T.must(@document.source[line_begin..@line_end])
+        @lines = T.let(@document.source.lines, T::Array[String])
+        line = @lines[[position[:line] - 1, 0].max]
 
-        @indentation = T.let(find_indentation(line), Integer)
-        @previous_line = T.let(line.strip.chomp, String)
+        @indentation = T.let(line ? find_indentation(line) : 0, Integer)
+        @previous_line = T.let(line ? line.strip.chomp : "", String)
         @position = position
         @edits = T.let([], T::Array[Interface::TextEdit])
         @trigger_character = trigger_character
@@ -64,9 +62,34 @@ module RubyLsp
 
       sig { void }
       def handle_pipe
-        return unless /((?<=do)|(?<={))\s+\|/.match?(@previous_line)
+        current_line = @lines[@position[:line]]
+        return unless /((?<=do)|(?<={))\s+\|/.match?(current_line)
+
+        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]] == "|"
+
+          @edits << Interface::TextEdit.new(
+            range: Interface::Range.new(
+              start: Interface::Position.new(
+                line: @position[:line],
+                character: @position[:character],
+              ),
+              end: Interface::Position.new(
+                line: @position[:line],
+                character: @position[:character] + 1,
+              ),
+            ),
+            new_text: "",
+          )
+        else
+          add_edit_with_text("|")
+        end
 
-        add_edit_with_text("|")
         move_cursor_to(@position[:line], @position[:character])
       end
 
@@ -87,30 +110,15 @@ module RubyLsp
         return unless END_REGEXES.any? { |regex| regex.match?(@previous_line) }
 
         indents = " " * @indentation
+        current_line = @lines[@position[:line]]
+        next_line = @lines[@position[:line] + 1]
 
-        if @previous_line.include?("\n")
-          # If the previous line has a line break, then it means there's content after the line break that triggered
-          # this completion. For these cases, we want to add the `end` after the content and move the cursor back to the
-          # keyword that triggered the completion
-
-          line = @position[:line]
-
-          # If there are enough lines in the document, we want to add the `end` token on the line below the extra
-          # content. Otherwise, we want to insert and extra line break ourselves
-          correction = if T.must(@document.source[@line_end..-1]).count("\n") >= 2
-            line -= 1
-            "#{indents}end"
-          else
-            "#{indents}\nend"
-          end
-
-          add_edit_with_text(correction, { line: @position[:line] + 1, character: @position[:character] })
-          move_cursor_to(line, @indentation + 3)
-        else
-          # If there's nothing after the new line break that triggered the completion, then we want to add the `end` and
-          # move the cursor to the body of the statement
+        if current_line.nil? || current_line.strip.empty?
           add_edit_with_text(" \n#{indents}end")
           move_cursor_to(@position[:line], @indentation + 2)
+        elsif next_line.nil? || next_line.strip.empty?
+          add_edit_with_text("#{indents}end", { line: @position[:line] + 1, character: @position[:character] })
+          move_cursor_to(@position[:line], @indentation + 3)
         end
       end
 

data/lib/ruby_lsp/requests/show_syntax_tree.rb

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Show syntax tree demo](../../show_syntax_tree.gif)
+    #
+    # Show syntax tree is a custom [LSP
+    # request](https://microsoft.github.io/language-server-protocol/specification#requestMessage) that displays the AST
+    # for the current document in a new tab.
+    #
+    # # Example
+    #
+    # ```ruby
+    # # Executing the Ruby LSP: Show syntax tree command will display the AST for the document
+    # 1 + 1
+    # # (program (statements ((binary (int "1") + (int "1")))))
+    # ```
+    #
+    class ShowSyntaxTree < BaseRequest
+      extend T::Sig
+
+      sig { override.returns(String) }
+      def run
+        return "Document contains syntax error" if @document.syntax_error?
+
+        output_string = +""
+        PP.pp(@document.tree, output_string)
+        output_string
+      end
+    end
+  end
+end

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

@@ -20,15 +20,19 @@ module RubyLsp
 
       sig { returns(String) }
       def detected_test_library
-        if direct_dependency?(/^minitest/)
+        # A Rails app may have a dependency on minitest, but we would instead want to use the Rails test runner provided
+        # by ruby-lsp-rails.
+        if direct_dependency?(/^rails$/)
+          "rails"
+        # NOTE: Intentionally ends with $ to avoid mis-matching minitest-reporters, etc. in a Rails app.
+        elsif direct_dependency?(/^minitest$/)
           "minitest"
         elsif direct_dependency?(/^test-unit/)
           "test-unit"
         elsif direct_dependency?(/^rspec/)
           "rspec"
         else
-          warn("WARNING: No test library detected. Assuming minitest.")
-          "minitest"
+          "unknown"
         end
       end
 

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

@@ -78,7 +78,7 @@ module URI
     if URI.respond_to?(:register_scheme)
       URI.register_scheme("SOURCE", self)
     else
-      @@schemes = T.let(@@schemes, T::Hash[String, T::Class[T.anything]]) # rubocop:disable Style/ClassVars
+      @@schemes = T.let(@@schemes, T::Hash[String, T.untyped]) # rubocop:disable Style/ClassVars
       @@schemes["SOURCE"] = self
     end
   end

data/lib/ruby_lsp/requests.rb

@@ -19,6 +19,8 @@ module RubyLsp
   # - [InlayHint](rdoc-ref:RubyLsp::Requests::InlayHints)
   # - [PathCompletion](rdoc-ref:RubyLsp::Requests::PathCompletion)
   # - [CodeLens](rdoc-ref:RubyLsp::Requests::CodeLens)
+  # - [Definition](rdoc-ref:RubyLsp::Requests::Definition)
+  # - [ShowSyntaxTree](rdoc-ref:RubyLsp::Requests::ShowSyntaxTree)
 
   module Requests
     autoload :BaseRequest, "ruby_lsp/requests/base_request"
@@ -37,6 +39,8 @@ module RubyLsp
     autoload :InlayHints, "ruby_lsp/requests/inlay_hints"
     autoload :PathCompletion, "ruby_lsp/requests/path_completion"
     autoload :CodeLens, "ruby_lsp/requests/code_lens"
+    autoload :Definition, "ruby_lsp/requests/definition"
+    autoload :ShowSyntaxTree, "ruby_lsp/requests/show_syntax_tree"
 
     # :nodoc:
     module Support

data/lib/ruby_lsp/server.rb

@@ -70,6 +70,8 @@ module RubyLsp
         when "$/cancelRequest"
           # Cancel the job if it's still in the queue
           @mutex.synchronize { @jobs[request[:params][:id]]&.cancel }
+        when "$/setTrace"
+          VOID
         when "shutdown"
           warn("Shutting down Ruby LSP...")
 

data/lib/ruby_lsp/setup_bundler.rb

@@ -0,0 +1,86 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "bundler"
+require "fileutils"
+require "pathname"
+
+# This file is a script that will configure a custom bundle for the Ruby LSP. The custom bundle allows developers to use
+# the Ruby LSP without including the gem in their application's Gemfile while at the same time giving us access to the
+# exact locked versions of dependencies.
+
+# Do not setup a custom bundle if we're working on the Ruby LSP, since it's already included by default
+if Pathname.new(Dir.pwd).basename == "ruby-lsp"
+  warn("Ruby LSP> Skipping custom bundle setup since we're working on the Ruby LSP itself")
+  return
+end
+
+# We need to parse the Gemfile.lock manually here. If we try to do `bundler/setup` to use something more convenient, we
+# may end up with issues when the globally installed `ruby-lsp` version mismatches the one included in the `Gemfile`
+dependencies = Bundler::LockfileParser.new(Bundler.read_file("Gemfile.lock")).dependencies
+
+# When working on a gem, the `ruby-lsp` might be listed as a dependency in the gemspec. We need to make sure we check
+# those as well or else we may get version mismatch errors
+gemspec_path = Dir.glob("*.gemspec").first
+if gemspec_path
+  gemspec_dependencies = Bundler.load_gemspec(gemspec_path).dependencies.to_h { |dep| [dep.name, dep] }
+  dependencies.merge!(gemspec_dependencies)
+end
+
+# Do not setup a custom bundle if both `ruby-lsp` and `debug` are already in the Gemfile
+if dependencies["ruby-lsp"] && dependencies["debug"]
+  warn("Ruby LSP> Skipping custom bundle setup since both `ruby-lsp` and `debug` are already in the Gemfile")
+  return
+end
+
+# Automatically create and ignore the .ruby-lsp folder for users
+FileUtils.mkdir(".ruby-lsp") unless Dir.exist?(".ruby-lsp")
+File.write(".ruby-lsp/.gitignore", "*") unless File.exist?(".ruby-lsp/.gitignore")
+
+parts = [
+  "# This custom gemfile is automatically generated by the Ruby LSP.",
+  "# It should be automatically git ignored, but in any case: do not commit it to your repository.",
+  "",
+  "eval_gemfile(File.expand_path(\"../Gemfile\", __dir__))",
+]
+
+unless dependencies["ruby-lsp"]
+  parts << 'gem "ruby-lsp", require: false, group: :development, source: "https://rubygems.org"'
+end
+
+unless dependencies["debug"]
+  parts << 'gem "debug", require: false, group: :development, platforms: :mri, source: "https://rubygems.org"'
+end
+
+gemfile_content = parts.join("\n")
+
+unless File.exist?(".ruby-lsp/Gemfile") && File.read(".ruby-lsp/Gemfile") == gemfile_content
+  File.write(".ruby-lsp/Gemfile", gemfile_content)
+end
+
+# If .ruby-lsp/Gemfile.lock already exists and the top level Gemfile.lock hasn't been modified since it was last
+# updated, then we're ready to boot the server
+if File.exist?(".ruby-lsp/Gemfile.lock") && File.stat(".ruby-lsp/Gemfile.lock").mtime > File.stat("Gemfile.lock").mtime
+  warn("Ruby LSP> Skipping custom bundle setup since .ruby-lsp/Gemfile.lock already exists and is up to date")
+  return
+end
+
+FileUtils.cp("Gemfile.lock", ".ruby-lsp/Gemfile.lock")
+
+# If the user has a custom bundle path configured, we need to ensure that we will use the absolute and not relative
+# version of it when running bundle install. This is necessary to avoid installing the gems under the `.ruby-lsp`
+# folder, which is not the user's intention. For example, if path is configured as `vendor`, we want to install it in
+# the top level `vendor` and not `.ruby-lsp/vendor`
+path = Bundler.settings["path"]
+
+command = +""
+# Use the absolute `BUNDLE_PATH` to prevent accidentally creating unwanted folders under `.ruby-lsp`
+command << "BUNDLE_PATH=#{File.expand_path(path, Dir.pwd)} " if path
+# Install gems using the custom bundle
+command << "BUNDLE_GEMFILE=.ruby-lsp/Gemfile bundle install "
+# Redirect stdout to stderr to prevent going into an infinite loop. The extension might confuse stdout output with
+# responses
+command << "1>&2"
+
+warn("Ruby LSP> Running bundle install for the custom bundle. This may take a while...")
+system(command)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-06-19 00:00:00.000000000 Z
+date: 2023-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -63,6 +63,7 @@ email:
 - ruby@shopify.com
 executables:
 - ruby-lsp
+- ruby-lsp-check
 extensions: []
 extra_rdoc_files: []
 files:
@@ -70,6 +71,7 @@ files:
 - README.md
 - VERSION
 - exe/ruby-lsp
+- exe/ruby-lsp-check
 - lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb
 - lib/ruby-lsp.rb
 - lib/ruby_lsp/check_docs.rb
@@ -84,6 +86,7 @@ files:
 - lib/ruby_lsp/requests/code_action_resolve.rb
 - lib/ruby_lsp/requests/code_actions.rb
 - lib/ruby_lsp/requests/code_lens.rb
+- lib/ruby_lsp/requests/definition.rb
 - lib/ruby_lsp/requests/diagnostics.rb
 - lib/ruby_lsp/requests/document_highlight.rb
 - lib/ruby_lsp/requests/document_link.rb
@@ -96,6 +99,7 @@ files:
 - lib/ruby_lsp/requests/path_completion.rb
 - lib/ruby_lsp/requests/selection_ranges.rb
 - lib/ruby_lsp/requests/semantic_highlighting.rb
+- lib/ruby_lsp/requests/show_syntax_tree.rb
 - lib/ruby_lsp/requests/support/annotation.rb
 - lib/ruby_lsp/requests/support/common.rb
 - lib/ruby_lsp/requests/support/dependency_detector.rb
@@ -113,6 +117,7 @@ files:
 - lib/ruby_lsp/requests/support/source_uri.rb
 - lib/ruby_lsp/requests/support/syntax_tree_formatting_runner.rb
 - lib/ruby_lsp/server.rb
+- lib/ruby_lsp/setup_bundler.rb
 - lib/ruby_lsp/store.rb
 - lib/ruby_lsp/utils.rb
 homepage: https://github.com/Shopify/ruby-lsp
@@ -135,7 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.14
+rubygems_version: 3.4.16
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby