ruby-lsp 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0da1b154c2c048cdea8d1ca6f87e77b895482cdbea155058550eff983fdbae1c
-  data.tar.gz: 7a67502b28e7e525acc6349fafe5de9e9945350d84af72d0a9afaa5d5b0803d8
+  metadata.gz: 812bcf5c0bc5512ad4382440118051b99d79e79d37a2e91e1fbe4341458dd94c
+  data.tar.gz: 73a83f9e143bde544d72819e0c867182a0bc8b82ff2ef2dc98032aecdc28e825
 SHA512:
-  metadata.gz: 77968226990bdcbab7026e962a3b7e1e3459f920939aa19a50331daa7b4a24b180eb46a342b5385412a43b73d1d6e40d6f9de2f1321a512cf65d36046b978cbc
-  data.tar.gz: a27e182f7c554d9b231f4ea69b15b52d0c4c32fe0cbb17879480c8b9ada87288c59ffa93fbfd99963c456bf4a6298164c920f720611532609f5e985e3c1e890c
+  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

data/VERSION

@@ -1 +1 @@
-0.6.2
+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/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/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
@@ -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) }
@@ -436,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
@@ -465,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
 
@@ -539,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

@@ -38,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)
@@ -56,6 +58,22 @@ 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 }

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/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

@@ -62,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
 
@@ -88,10 +113,10 @@ module RubyLsp
         current_line = @lines[@position[:line]]
         next_line = @lines[@position[:line] + 1]
 
-        if current_line.nil? || current_line.blank?
+        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.blank?
+        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

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.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.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-06-23 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