ruby-lsp 0.23.11 → 0.26.1

data/lib/ruby_lsp/utils.rb

@@ -5,27 +5,21 @@ 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
-  BUNDLE_PATH = T.let(
-    begin
-      Bundler.bundle_path.to_s
-    rescue Bundler::GemfileNotFound
-      nil
-    end,
-    T.nilable(String),
-  )
-  GEMFILE_NAME = T.let(
-    begin
-      Bundler.with_original_env { Bundler.default_gemfile.basename.to_s }
-    rescue Bundler::GemfileNotFound
-      "Gemfile"
-    end,
-    String,
-  )
+  BUNDLE_PATH = begin
+    Bundler.bundle_path.to_s
+  rescue Bundler::GemfileNotFound
+    nil
+  end #: String?
+  GEMFILE_NAME = begin
+    Bundler.with_original_env { Bundler.default_gemfile.basename.to_s }
+  rescue Bundler::GemfileNotFound
+    "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
@@ -37,36 +31,35 @@ 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
-
-    sig { returns(String) }
+    #: String
     attr_reader :method
 
-    sig { returns(Object) }
+    #: Object
     attr_reader :params
 
-    abstract!
-
-    sig { params(method: String, params: Object).void }
+    #: (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
     class << self
-      extend T::Sig
-
-      sig { params(message: String, type: Integer).returns(Notification) }
+      #: (String message, ?type: Integer) -> Notification
       def window_show_message(message, type: Constant::MessageType::INFO)
         new(
           method: "window/showMessage",
@@ -74,7 +67,7 @@ module RubyLsp
         )
       end
 
-      sig { params(message: String, type: Integer).returns(Notification) }
+      #: (String message, ?type: Integer) -> Notification
       def window_log_message(message, type: Constant::MessageType::LOG)
         new(
           method: "window/logMessage",
@@ -82,7 +75,7 @@ module RubyLsp
         )
       end
 
-      sig { params(data: T::Hash[Symbol, T.untyped]).returns(Notification) }
+      #: (Hash[Symbol, untyped] data) -> Notification
       def telemetry(data)
         new(
           method: "telemetry/event",
@@ -90,14 +83,7 @@ module RubyLsp
         )
       end
 
-      sig do
-        params(
-          id: String,
-          title: String,
-          percentage: T.nilable(Integer),
-          message: T.nilable(String),
-        ).returns(Notification)
-      end
+      #: (String id, String title, ?percentage: Integer?, ?message: String?) -> Notification
       def progress_begin(id, title, percentage: nil, message: nil)
         new(
           method: "$/progress",
@@ -113,13 +99,7 @@ module RubyLsp
         )
       end
 
-      sig do
-        params(
-          id: String,
-          percentage: T.nilable(Integer),
-          message: T.nilable(String),
-        ).returns(Notification)
-      end
+      #: (String id, ?percentage: Integer?, ?message: String?) -> Notification
       def progress_report(id, percentage: nil, message: nil)
         new(
           method: "$/progress",
@@ -134,7 +114,7 @@ module RubyLsp
         )
       end
 
-      sig { params(id: String).returns(Notification) }
+      #: (String id) -> Notification
       def progress_end(id)
         Notification.new(
           method: "$/progress",
@@ -145,13 +125,7 @@ module RubyLsp
         )
       end
 
-      sig do
-        params(
-          uri: String,
-          diagnostics: T::Array[Interface::Diagnostic],
-          version: T.nilable(Integer),
-        ).returns(Notification)
-      end
+      #: (String uri, Array[Interface::Diagnostic] diagnostics, ?version: Integer?) -> Notification
       def publish_diagnostics(uri, diagnostics, version: nil)
         new(
           method: "textDocument/publishDiagnostics",
@@ -160,30 +134,23 @@ module RubyLsp
       end
     end
 
-    extend T::Sig
-
-    sig { override.returns(T::Hash[Symbol, T.untyped]) }
+    # @override
+    #: -> Hash[Symbol, untyped]
     def to_hash
       hash = { method: @method }
-      hash[:params] = T.unsafe(@params).to_hash if @params
+
+      if @params
+        hash[:params] = @params #: as untyped
+          .to_hash
+      end
+
       hash
     end
   end
 
   class Request < Message
-    extend T::Sig
-
     class << self
-      extend T::Sig
-
-      sig do
-        params(
-          id: Integer,
-          pattern: T.any(Interface::RelativePattern, String),
-          kind: Integer,
-          registration_id: T.nilable(String),
-        ).returns(Request)
-      end
+      #: (Integer id, (Interface::RelativePattern | String) pattern, ?kind: Integer, ?registration_id: String?) -> Request
       def register_watched_files(
         id,
         pattern,
@@ -210,30 +177,34 @@ module RubyLsp
       end
     end
 
-    sig { params(id: T.any(Integer, String), method: String, params: Object).void }
+    #: (id: (Integer | String), method: String, params: Object) -> void
     def initialize(id:, method:, params:)
       @id = id
       super(method: method, params: params)
     end
 
-    sig { override.returns(T::Hash[Symbol, T.untyped]) }
+    # @override
+    #: -> Hash[Symbol, untyped]
     def to_hash
       hash = { id: @id, method: @method }
-      hash[:params] = T.unsafe(@params).to_hash if @params
+
+      if @params
+        hash[:params] = @params #: as untyped
+          .to_hash
+      end
+
       hash
     end
   end
 
   class Error
-    extend T::Sig
-
-    sig { returns(String) }
+    #: String
     attr_reader :message
 
-    sig { returns(Integer) }
+    #: Integer
     attr_reader :code
 
-    sig { params(id: Integer, code: Integer, message: String, data: T.nilable(T::Hash[Symbol, T.untyped])).void }
+    #: (id: Integer, code: Integer, message: String, ?data: Hash[Symbol, untyped]?) -> void
     def initialize(id:, code:, message:, data: nil)
       @id = id
       @code = code
@@ -241,7 +212,7 @@ module RubyLsp
       @data = data
     end
 
-    sig { returns(T::Hash[Symbol, T.untyped]) }
+    #: -> Hash[Symbol, untyped]
     def to_hash
       {
         id: @id,
@@ -256,21 +227,19 @@ module RubyLsp
 
   # The final result of running a request before its IO is finalized
   class Result
-    extend T::Sig
-
-    sig { returns(T.untyped) }
+    #: untyped
     attr_reader :response
 
-    sig { returns(Integer) }
+    #: Integer
     attr_reader :id
 
-    sig { params(id: Integer, response: T.untyped).void }
+    #: (id: Integer, response: untyped) -> void
     def initialize(id:, response:)
       @id = id
       @response = response
     end
 
-    sig { returns(T::Hash[Symbol, T.untyped]) }
+    #: -> Hash[Symbol, untyped]
     def to_hash
       { id: @id, result: @response }
     end
@@ -278,19 +247,95 @@ module RubyLsp
 
   # A request configuration, to turn on/off features
   class RequestConfig
-    extend T::Sig
-
-    sig { returns(T::Hash[Symbol, T::Boolean]) }
-    attr_accessor :configuration
-
-    sig { params(configuration: T::Hash[Symbol, T::Boolean]).void }
+    #: (Hash[Symbol, bool] configuration) -> void
     def initialize(configuration)
       @configuration = configuration
     end
 
-    sig { params(feature: Symbol).returns(T.nilable(T::Boolean)) }
+    #: (Symbol feature) -> bool?
     def enabled?(feature)
       @configuration[:enableAll] || @configuration[feature]
     end
+
+    #: (Hash[Symbol, bool]) -> void
+    def merge!(hash)
+      @configuration.merge!(hash)
+    end
+  end
+
+  class SorbetLevel
+    class << self
+      #: -> SorbetLevel
+      def ignore
+        new("ignore")
+      end
+    end
+
+    #: (String?) -> void
+    def initialize(sigil)
+      @level = case sigil
+      when "ignore"
+        :ignore
+      when "false"
+        :false
+      when "true"
+        :true
+      when "strict", "strong"
+        :strict
+      else
+        :none
+      end #: Symbol
+    end
+
+    #: -> bool
+    def ignore? = @level == :ignore
+
+    #: -> bool
+    def false? = @level == :false
+
+    #: -> bool
+    def true? = @level == :true
+
+    #: -> bool
+    def strict? = @level == :strict
+
+    #: -> bool
+    def none? = @level == :none
+
+    #: -> 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,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.23.11
+  version: 0.26.1
 platform: ruby
 authors:
 - Shopify
 bindir: exe
 cert_chain: []
-date: 2025-02-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -52,7 +52,7 @@ dependencies:
         version: '3'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -62,21 +62,7 @@ dependencies:
         version: '3'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4'
-- !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
+        version: '5'
 description: An opinionated language server for Ruby
 email:
 - ruby@shopify.com
@@ -84,6 +70,7 @@ executables:
 - ruby-lsp
 - ruby-lsp-check
 - ruby-lsp-launcher
+- ruby-lsp-test-exec
 extensions: []
 extra_rdoc_files: []
 files:
@@ -93,6 +80,7 @@ files:
 - exe/ruby-lsp
 - exe/ruby-lsp-check
 - exe/ruby-lsp-launcher
+- exe/ruby-lsp-test-exec
 - lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb
 - lib/rubocop/cop/ruby_lsp/use_register_with_handler_method.rb
 - lib/ruby-lsp.rb
@@ -140,8 +128,9 @@ files:
 - lib/ruby_lsp/listeners/inlay_hints.rb
 - lib/ruby_lsp/listeners/semantic_highlighting.rb
 - lib/ruby_lsp/listeners/signature_help.rb
+- 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
@@ -157,6 +146,7 @@ files:
 - lib/ruby_lsp/requests/document_symbol.rb
 - lib/ruby_lsp/requests/folding_ranges.rb
 - lib/ruby_lsp/requests/formatting.rb
+- lib/ruby_lsp/requests/go_to_relevant_file.rb
 - lib/ruby_lsp/requests/hover.rb
 - lib/ruby_lsp/requests/inlay_hints.rb
 - lib/ruby_lsp/requests/on_type_formatting.rb
@@ -199,8 +189,12 @@ files:
 - lib/ruby_lsp/static_docs.rb
 - lib/ruby_lsp/store.rb
 - lib/ruby_lsp/test_helper.rb
+- lib/ruby_lsp/test_reporters/lsp_reporter.rb
+- lib/ruby_lsp/test_reporters/minitest_reporter.rb
+- 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:
@@ -222,7 +216,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.6.9
 specification_version: 4
 summary: An opinionated language server for Ruby
 test_files: []

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