ruby-lsp 0.23.23 → 0.26.1

data/lib/ruby_lsp/setup_bundler.rb

@@ -1,7 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "sorbet-runtime"
 require "bundler"
 require "bundler/cli"
 require "bundler/cli/install"
@@ -12,19 +11,24 @@ require "digest"
 require "time"
 require "uri"
 
-# This file is a script that will configure a composed bundle for the Ruby LSP. The composed 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.
+# This file is a script that will configure a composed bundle for the Ruby LSP. The composed 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.
 
 Bundler.ui.level = :silent
 
 module RubyLsp
   class SetupBundler
-    extend T::Sig
-
     class BundleNotLocked < StandardError; end
     class BundleInstallFailure < StandardError; end
 
+    module ThorPatch
+      #: -> IO
+      def stdout
+        $stderr
+      end
+    end
+
     FOUR_HOURS = 4 * 60 * 60 #: Integer
 
     #: (String project_path, **untyped options) -> void
@@ -61,6 +65,7 @@ module RubyLsp
       @bundler_version = bundler_version #: Gem::Version?
       @rails_app = rails_app? #: bool
       @retry = false #: bool
+      @needs_update_path = @custom_dir + "needs_update" #: Pathname
     end
 
     # Sets up the composed bundle and returns the `BUNDLE_GEMFILE`, `BUNDLE_PATH` and `BUNDLE_APP_CONFIG` that should be
@@ -229,6 +234,14 @@ module RubyLsp
         # If no error occurred, then clear previous errors
         @error_path.delete if @error_path.exist?
         $stderr.puts("Ruby LSP> Composed bundle installation complete")
+      rescue Errno::EPIPE
+        # If the $stderr pipe was closed by the client, for example when closing the editor during running bundle
+        # install, we don't want to write the error to a file or else we will report to telemetry on the next launch and
+        # it does not represent an actual error.
+        #
+        # This situation may happen because while running bundle install, the server is not yet ready to receive
+        # shutdown requests and we may continue doing work until the process is killed.
+        @error_path.delete if @error_path.exist?
       rescue => e
         # Write the error object to a file so that we can read it from the parent process
         @error_path.write(Marshal.dump(e))
@@ -256,19 +269,50 @@ module RubyLsp
     #: (Hash[String, String] env, ?force_install: bool) -> Hash[String, String]
     def run_bundle_install_directly(env, force_install: false)
       RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
+      return update(env) if @needs_update_path.exist?
 
       # The ENV can only be merged after checking if an update is required because we depend on the original value of
       # ENV["BUNDLE_GEMFILE"], which gets overridden after the merge
-      should_update = should_bundle_update?
-      ENV #: as untyped
-        .merge!(env)
+      FileUtils.touch(@needs_update_path) if should_bundle_update?
+      ENV.merge!(env)
 
-      unless should_update && !force_install
-        Bundler::CLI::Install.new({ "no-cache" => true }).run
-        correct_relative_remote_paths if @custom_lockfile.exist?
-        return env
+      $stderr.puts("Ruby LSP> Checking if the composed bundle is satisfied...")
+      missing_gems = bundle_check
+
+      unless missing_gems.empty?
+        $stderr.puts(<<~MESSAGE)
+          Ruby LSP> Running bundle install because the following gems are not installed:
+          #{missing_gems.map { |g| "#{g.name}: #{g.version}" }.join("\n")}
+        MESSAGE
+
+        bundle_install
       end
 
+      $stderr.puts("Ruby LSP> Bundle already satisfied")
+      env
+    rescue => e
+      $stderr.puts("Ruby LSP> Running bundle install because #{e.message}")
+      bundle_install
+      env
+    end
+
+    # Essentially the same as bundle check, but simplified
+    #: -> Array[Gem::Specification]
+    def bundle_check
+      definition = Bundler.definition
+      definition.validate_runtime!
+      definition.check!
+      definition.missing_specs
+    end
+
+    #: -> void
+    def bundle_install
+      Bundler::CLI::Install.new({ "no-cache" => true }).run
+      correct_relative_remote_paths if @custom_lockfile.exist?
+    end
+
+    #: (Hash[String, String]) -> Hash[String, String]
+    def update(env)
       # Try to auto upgrade the gems we depend on, unless they are in the Gemfile as that would result in undesired
       # source control changes
       gems = ["ruby-lsp", "debug", "prism"].reject { |dep| @dependencies[dep] }
@@ -276,11 +320,9 @@ module RubyLsp
 
       Bundler::CLI::Update.new({ conservative: true }, gems).run
       correct_relative_remote_paths if @custom_lockfile.exist?
+      @needs_update_path.delete
       @last_updated_path.write(Time.now.iso8601)
       env
-    rescue Bundler::GemNotFound, Bundler::GitError
-      # If a gem is not installed, skip the upgrade and try to install it with a single retry
-      @retry ? env : run_bundle_install_directly(env, force_install: true)
     end
 
     #: (Hash[String, String] env) -> Hash[String, String]
@@ -440,15 +482,7 @@ module RubyLsp
     def patch_thor_to_print_progress_to_stderr!
       return unless defined?(Bundler::Thor::Shell::Basic)
 
-      Bundler::Thor::Shell::Basic.prepend(Module.new do
-        extend T::Sig
-
-        sig { returns(IO) }
-        def stdout
-          $stderr
-        end
-      end)
-
+      Bundler::Thor::Shell::Basic.prepend(ThorPatch)
       Bundler.ui.level = :info
     end
   end

data/lib/ruby_lsp/static_docs.rb

@@ -14,6 +14,7 @@ module RubyLsp
 
   # A map of keyword => short documentation to be displayed on hover or completion
   KEYWORD_DOCS = {
+    "break" => "Terminates the execution of a block or loop",
     "yield" => "Invokes the passed block with the given arguments",
   }.freeze #: Hash[String, String]
 end

data/lib/ruby_lsp/store.rb

@@ -5,9 +5,6 @@ module RubyLsp
   class Store
     class NonExistingDocumentError < StandardError; end
 
-    #: Hash[Symbol, RequestConfig]
-    attr_accessor :features_configuration
-
     #: String
     attr_accessor :client_name
 
@@ -15,13 +12,6 @@ module RubyLsp
     def initialize(global_state)
       @global_state = global_state
       @state = {} #: Hash[String, Document[untyped]]
-      @features_configuration = {
-        inlayHint: RequestConfig.new({
-          enableAll: false,
-          implicitRescue: false,
-          implicitHashValue: false,
-        }),
-      } #: Hash[Symbol, RequestConfig]
       @client_name = "Unknown" #: String
     end
 

data/lib/ruby_lsp/test_helper.rb

@@ -4,13 +4,10 @@
 # NOTE: This module is intended to be used by addons for writing their own tests, so keep that in mind if changing.
 
 module RubyLsp
+  # @requires_ancestor: Kernel
   module TestHelper
     class TestError < StandardError; end
 
-    extend T::Helpers
-
-    requires_ancestor { Kernel }
-
     #: [T] (?String? source, ?URI::Generic uri, ?stub_no_typechecker: bool, ?load_addons: bool) { (RubyLsp::Server server, URI::Generic uri) -> T } -> T
     def with_server(source = nil, uri = Kernel.URI("file:///fake.rb"), stub_no_typechecker: false, load_addons: true,
       &block)

data/lib/ruby_lsp/test_reporters/lsp_reporter.rb

@@ -12,16 +12,23 @@ module RubyLsp
   class LspReporter
     include Singleton
 
-    #: bool
-    attr_reader :invoked_shutdown
+    # https://code.visualstudio.com/api/references/vscode-api#Position
+    #: type position = { line: Integer, character: Integer }
+
+    # https://code.visualstudio.com/api/references/vscode-api#Range
+    #: type range = { start: position, end: position }
+
+    # https://code.visualstudio.com/api/references/vscode-api#BranchCoverage
+    #: type branch_coverage = { executed: Integer, label: String, location: range }
+
+    # https://code.visualstudio.com/api/references/vscode-api#StatementCoverage
+    #: type statement_coverage = { executed: Integer, location: position, branches: Array[branch_coverage] }
 
     #: -> void
     def initialize
       dir_path = File.join(Dir.tmpdir, "ruby-lsp")
       FileUtils.mkdir_p(dir_path)
 
-      # Remove in 1 month once updates have rolled out
-      legacy_port_path = File.join(dir_path, "test_reporter_port")
       port_db_path = File.join(dir_path, "test_reporter_port_db.json")
       port = ENV["RUBY_LSP_REPORTER_PORT"]
 
@@ -32,8 +39,6 @@ module RubyLsp
         elsif File.exist?(port_db_path)
           db = JSON.load_file(port_db_path)
           TCPSocket.new("localhost", db[Dir.pwd])
-        elsif File.exist?(legacy_port_path)
-          TCPSocket.new("localhost", File.read(legacy_port_path))
         else
           # For tests that don't spawn the TCP server
           require "stringio"
@@ -129,7 +134,7 @@ module RubyLsp
     #       ["Foo", :bar, 6, 21, 6, 65] => 0
     #     }
     # }
-    #: -> Hash[String, StatementCoverage]
+    #: -> Hash[String, statement_coverage]
     def gather_coverage_results
       # Ignore coverage results inside dependencies
       bundle_path = Bundler.bundle_path.to_s
@@ -187,7 +192,7 @@ module RubyLsp
 
     #: -> void
     def at_exit
-      internal_shutdown unless invoked_shutdown
+      internal_shutdown unless @invoked_shutdown
     end
 
     class << self

data/lib/ruby_lsp/test_reporters/minitest_reporter.rb

@@ -74,12 +74,25 @@ module RubyLsp
       end
     end
 
-    #: (singleton(Minitest::Test) test_class, String method_name) -> void
-    def prerecord(test_class, method_name)
-      uri, line = LspReporter.instance.uri_and_line_for(test_class.instance_method(method_name))
+    #: (untyped, String) -> void
+    def prerecord(test_class_or_wrapper, method_name)
+      # In frameworks like Rails, they can control the Minitest execution by wrapping the test class
+      # But they conform to responding to `name`, so we can use that as a guarantee
+      # We are interested in the test class, not the wrapper
+      name = test_class_or_wrapper.name
+
+      klass = begin
+        Object.const_get(name) # rubocop:disable Sorbet/ConstantsFromStrings
+      rescue NameError
+        # Handle Minitest specs that create classes with invalid constant names like "MySpec::when something is true"
+        # If we can't resolve the constant, it means we were given the actual test class object, not the wrapper
+        test_class_or_wrapper
+      end
+
+      uri, line = LspReporter.instance.uri_and_line_for(klass.instance_method(method_name))
       return unless uri
 
-      id = "#{test_class.name}##{handle_spec_test_id(method_name, line)}"
+      id = "#{name}##{handle_spec_test_id(method_name, line)}"
       LspReporter.instance.start_test(id: id, uri: uri, line: line)
     end
 

data/lib/ruby_lsp/utils.rb

@@ -5,7 +5,6 @@ module RubyLsp
   # rubocop:disable RubyLsp/UseLanguageServerAliases
   Interface = LanguageServer::Protocol::Interface
   Constant = LanguageServer::Protocol::Constant
-  Transport = LanguageServer::Protocol::Transport
   # rubocop:enable RubyLsp/UseLanguageServerAliases
 
   # Used to indicate that a request shouldn't return a response
@@ -20,6 +19,7 @@ module RubyLsp
     "Gemfile"
   end #: String
   GUESSED_TYPES_URL = "https://shopify.github.io/ruby-lsp/#guessed-types"
+  TEST_PATH_PATTERN = "**/{test,spec,features}/**/{*_test.rb,test_*.rb,*_spec.rb,*.feature}"
 
   # Request delegation for embedded languages is not yet standardized into the language server specification. Here we
   # use this custom error class as a way to return a signal to the client that the request should be delegated to the
@@ -31,29 +31,30 @@ module RubyLsp
     CODE = -32900
   end
 
+  class AbstractMethodInvokedError < StandardError; end
+
   BUNDLE_COMPOSE_FAILED_CODE = -33000
 
   # A notification to be sent to the client
+  # @abstract
   class Message
-    extend T::Sig
-    extend T::Helpers
-
     #: String
     attr_reader :method
 
     #: Object
     attr_reader :params
 
-    abstract!
-
     #: (method: String, params: Object) -> void
     def initialize(method:, params:)
       @method = method
       @params = params
     end
 
-    sig { abstract.returns(T::Hash[Symbol, T.untyped]) }
-    def to_hash; end
+    # @abstract
+    #: -> Hash[Symbol, untyped]
+    def to_hash
+      raise AbstractMethodInvokedError
+    end
   end
 
   class Notification < Message
@@ -246,9 +247,6 @@ module RubyLsp
 
   # A request configuration, to turn on/off features
   class RequestConfig
-    #: Hash[Symbol, bool]
-    attr_accessor :configuration
-
     #: (Hash[Symbol, bool] configuration) -> void
     def initialize(configuration)
       @configuration = configuration
@@ -258,6 +256,11 @@ module RubyLsp
     def enabled?(feature)
       @configuration[:enableAll] || @configuration[feature]
     end
+
+    #: (Hash[Symbol, bool]) -> void
+    def merge!(hash)
+      @configuration.merge!(hash)
+    end
   end
 
   class SorbetLevel
@@ -302,4 +305,37 @@ module RubyLsp
     #: -> bool
     def true_or_higher? = @level == :true || @level == :strict
   end
+
+  # Reads JSON RPC messages from the given IO in a loop
+  class MessageReader
+    #: (IO) -> void
+    def initialize(io)
+      @io = io
+    end
+
+    #: () { (Hash[Symbol, untyped]) -> void } -> void
+    def each_message(&block)
+      while (headers = @io.gets("\r\n\r\n"))
+        raw_message = @io.read(headers[/Content-Length: (\d+)/i, 1].to_i) #: as !nil
+        block.call(JSON.parse(raw_message, symbolize_names: true))
+      end
+    end
+  end
+
+  # Writes JSON RPC messages to the given IO
+  class MessageWriter
+    #: (IO) -> void
+    def initialize(io)
+      @io = io
+    end
+
+    #: (Hash[Symbol, untyped]) -> void
+    def write(message)
+      message[:jsonrpc] = "2.0"
+      json_message = message.to_json
+
+      @io.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
+      @io.flush
+    end
+  end
 end

data/static_docs/break.md

@@ -0,0 +1,103 @@
+# Break
+
+In Ruby, the `break` keyword is used to exit a loop or block prematurely. Unlike `next` which skips to the next iteration, `break` terminates the loop entirely and continues with the code after the loop.
+
+```ruby
+# Basic break usage in a loop
+5.times do |i|
+  break if i == 3
+
+  puts i
+end
+# Output:
+# 0
+# 1
+# 2
+```
+
+The `break` statement can be used with any of Ruby's iteration methods or loops.
+
+```ruby
+array = [1, 2, 3, 4, 5]
+
+# Break in each iteration
+array.each do |num|
+  break if num > 3
+
+  puts "Number: #{num}"
+end
+# Output:
+# Number: 1
+# Number: 2
+# Number: 3
+
+# Break in an infinite loop
+count = 0
+loop do
+  count += 1
+  break if count >= 3
+
+  puts "Count: #{count}"
+end
+# Output:
+# Count: 1
+# Count: 2
+```
+
+## Break with a Value
+
+When used inside a block, `break` can return a value that becomes the result of the method call.
+
+```ruby
+# Break with a return value in map
+result = [1, 2, 3, 4, 5].map do |num|
+  break "Too large!" if num > 3
+
+  num * 2
+end
+puts result # Output: "Too large!"
+
+# Break with a value in find
+number = (1..10).find do |n|
+  break n if n > 5 && n.even?
+end
+puts number # Output: 6
+```
+
+## Break in Nested Loops
+
+When using `break` in nested loops, it only exits the innermost loop. To break from nested loops, you typically need to use a flag or return.
+
+```ruby
+# Break in nested iteration
+(1..3).each do |i|
+  puts "Outer: #{i}"
+
+  (1..3).each do |j|
+    break if j == 2
+
+    puts "  Inner: #{j}"
+  end
+end
+# Output:
+# Outer: 1
+#   Inner: 1
+# Outer: 2
+#   Inner: 1
+# Outer: 3
+#   Inner: 1
+
+# Breaking from nested loops with a flag
+found = false
+(1..3).each do |i|
+  (1..3).each do |j|
+    if i * j == 4
+      found = true
+      break
+    end
+  end
+  break if found
+end
+```
+
+The `break` keyword is essential for controlling loop execution and implementing early exit conditions. It's particularly useful when you've found what you're looking for and don't need to continue iterating.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.23.23
+  version: 0.26.1
 platform: ruby
 authors:
 - Shopify
@@ -63,20 +63,6 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '5'
-- !ruby/object:Gem::Dependency
-  name: sorbet-runtime
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.5.10782
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.5.10782
 description: An opinionated language server for Ruby
 email:
 - ruby@shopify.com
@@ -145,7 +131,6 @@ files:
 - lib/ruby_lsp/listeners/spec_style.rb
 - lib/ruby_lsp/listeners/test_discovery.rb
 - lib/ruby_lsp/listeners/test_style.rb
-- lib/ruby_lsp/load_sorbet.rb
 - lib/ruby_lsp/node_context.rb
 - lib/ruby_lsp/rbs_document.rb
 - lib/ruby_lsp/requests/code_action_resolve.rb
@@ -209,6 +194,7 @@ files:
 - lib/ruby_lsp/test_reporters/test_unit_reporter.rb
 - lib/ruby_lsp/type_inferrer.rb
 - lib/ruby_lsp/utils.rb
+- static_docs/break.md
 - static_docs/yield.md
 homepage: https://github.com/Shopify/ruby-lsp
 licenses:

data/lib/ruby_lsp/load_sorbet.rb

@@ -1,62 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "sorbet-runtime"
-
-begin
-  T::Configuration.default_checked_level = :never
-  # Suppresses call validation errors
-  T::Configuration.call_validation_error_handler = ->(*arg) {}
-  # Suppresses errors caused by T.cast, T.let, T.must, etc.
-  T::Configuration.inline_type_error_handler = ->(*arg) {}
-  # Suppresses errors caused by incorrect parameter ordering
-  T::Configuration.sig_validation_error_handler = ->(*arg) {}
-rescue
-  # Need this rescue so that if another gem has
-  # already set the checked level by the time we
-  # get to it, we don't fail outright.
-  nil
-end
-
-module RubyLsp
-  # No-op all inline type assertions defined in T
-  module InlineTypeAssertions
-    def absurd(value)
-      value
-    end
-
-    def any(type_a, type_b, *types)
-      T::Types::Union.new([type_a, type_b, *types])
-    end
-
-    def assert_type!(value, type, checked: true)
-      value
-    end
-
-    def bind(value, type, checked: true)
-      value
-    end
-
-    def cast(value, type, checked: true)
-      value
-    end
-
-    def let(value, type, checked: true)
-      value
-    end
-
-    def must(arg)
-      arg
-    end
-
-    def nilable(type)
-      T::Types::Union.new([type, T::Utils::Nilable::NIL_TYPE])
-    end
-
-    def unsafe(value)
-      value
-    end
-
-    T.singleton_class.prepend(self)
-  end
-end