ruby-lsp 0.24.1 → 0.24.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 981f87e306aa96edd6d2e04fc274d5da24ede96d3e3333bcfdeb63039e86c9ab
-  data.tar.gz: 5405216e985bed5ec6bce692baeeca9611980edc53fadf4655d00503488c277d
+  metadata.gz: 11ac9bfd9d255db5feb97c0f1d88a98dd966572ca6d60b6007384169f1b060b2
+  data.tar.gz: fbdc59855c67ba1741be48ccf49bd94359d5aa8aca2fb38f41e45174e4383988
 SHA512:
-  metadata.gz: a749ebc7c81100f0c76431d68865960ad8aeb04ed3aad37dad18c008e885a50d224157a2fdcd44b15abc2d5d5f8d7a4a2345f187662707478dbc66d191c214a2
-  data.tar.gz: 19a288a8121a4cf86b5fd60b9c6d11c4fd3cb26330f7667ac59b4742dbe91328b9f742dca5fb371bb58ad565afb9ec58516eb6b68dd85e641a800f89a23f81e9
+  metadata.gz: 0364d0f1049a03f9ade581ca98ddc209dd441f3e706561141ae1995903bf53e08e6d893f0650b31c7494a8333645030e1455023416b38a59002f177e3f024fcd
+  data.tar.gz: d4298637f7c8ba3acc70859a922ed43e4daadb3ad8d8885eb7ddb1fbadbfe078e9afe6f4fc22e60f854d5d5a16b76b9013fa36f5e3cceb62b5032bf6b17f934d

data/VERSION

@@ -1 +1 @@
-0.24.1
+0.24.2

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -266,7 +266,7 @@ module RubyIndexer
     def constant_completion_candidates(name, nesting)
       # If we have a top level reference, then we don't need to include completions inside the current nesting
       if name.start_with?("::")
-        return @entries_tree.search(name.delete_prefix("::")) #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]] # rubocop:disable Layout/LineLength
+        return @entries_tree.search(name.delete_prefix("::")) #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]]
       end
 
       # Otherwise, we have to include every possible constant the user might be referring to. This is essentially the
@@ -292,7 +292,7 @@ module RubyIndexer
       # Top level constants
       entries.concat(@entries_tree.search(name))
       entries.uniq!
-      entries #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]] # rubocop:disable Layout/LineLength
+      entries #: as Array[Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]]
     end
 
     # Resolve a constant to its declaration based on its name and the nesting where the reference was found. Parameter

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -232,8 +232,8 @@ module RubyIndexer
       signatures = entry.signatures
       assert_equal(2, signatures.length)
 
-      # def self.select: [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array) -> [ Array[X], Array[Y], Array[Z] ] # rubocop:disable Layout/LineLength
-      #   | [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array, Time::_Timeout? timeout) -> [ Array[X], Array[Y], Array[Z] ]? # rubocop:disable Layout/LineLength
+      # def self.select: [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array) -> [ Array[X], Array[Y], Array[Z] ]
+      #   | [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array, Time::_Timeout? timeout) -> [ Array[X], Array[Y], Array[Z] ]?
 
       parameters = signatures[0]&.parameters #: as !nil
       assert_equal([:read_array, :write_array, :error_array], parameters.map(&:name))

data/lib/ruby_lsp/addon.rb

@@ -56,7 +56,13 @@ module RubyLsp
         addon_files = Gem.find_files("ruby_lsp/**/addon.rb")
 
         if include_project_addons
-          addon_files.concat(Dir.glob(File.join(global_state.workspace_path, "**", "ruby_lsp/**/addon.rb")))
+          project_addons = Dir.glob("#{global_state.workspace_path}/**/ruby_lsp/**/addon.rb")
+
+          # Ignore add-ons from dependencies if the bundle is stored inside the project. We already found those with
+          # `Gem.find_files`
+          bundle_path = Bundler.bundle_path.to_s
+          project_addons.reject! { |path| path.start_with?(bundle_path) }
+          addon_files.concat(project_addons)
         end
 
         errors = addon_files.filter_map do |addon_path|

data/lib/ruby_lsp/document.rb

@@ -7,6 +7,7 @@ module RubyLsp
   class Document
     extend T::Generic
 
+    class InvalidLocationError < StandardError; end
     # This maximum number of characters for providing expensive features, like semantic highlighting and diagnostics.
     # This is the same number used by the TypeScript extension in VS Code
     MAXIMUM_CHARACTERS_FOR_EXPENSIVE_FEATURES = 100_000
@@ -145,7 +146,14 @@ module RubyLsp
 
     #: -> Scanner
     def create_scanner
-      Scanner.new(@source, @encoding)
+      case @encoding
+      when Encoding::UTF_8
+        Utf8Scanner.new(@source)
+      when Encoding::UTF_16LE
+        Utf16Scanner.new(@source)
+      else
+        Utf32Scanner.new(@source)
+      end
     end
 
     # @abstract
@@ -163,6 +171,11 @@ module RubyLsp
     class Replace < Edit; end
     class Delete < Edit; end
 
+    # Parent class for all position scanners. Scanners are used to translate a position given by the editor into a
+    # string index that we can use to find the right place in the document source. The logic for finding the correct
+    # index depends on the encoding negotiated with the editor, so we have different subclasses for each encoding.
+    # See https://microsoft.github.io/language-server-protocol/specification/#positionEncodingKind for more information
+    # @abstract
     class Scanner
       extend T::Sig
 
@@ -170,74 +183,157 @@ module RubyLsp
       # After character 0xFFFF, UTF-16 considers characters to have length 2 and we have to account for that
       SURROGATE_PAIR_START = 0xFFFF #: Integer
 
-      #: (String source, Encoding encoding) -> void
-      def initialize(source, encoding)
+      #: -> void
+      def initialize
         @current_line = 0 #: Integer
         @pos = 0 #: Integer
-        @bytes_or_codepoints = encoding == Encoding::UTF_8 ? source.bytes : source.codepoints #: Array[Integer]
-        @encoding = encoding
       end
 
-      # Finds the character index inside the source string for a given line and column
+      # Finds the character index inside the source string for a given line and column. This method always returns the
+      # character index regardless of whether we are searching positions based on bytes, code units, or codepoints.
+      # @abstract
+      #: (Hash[Symbol, untyped] position) -> Integer
+      def find_char_position(position); end
+    end
+
+    # For the UTF-8 encoding, positions correspond to bytes
+    class Utf8Scanner < Scanner
+      #: (String source) -> void
+      def initialize(source)
+        super()
+        @bytes = source.bytes #: Array[Integer]
+        @character_length = 0 #: Integer
+      end
+
+      # @override
       #: (Hash[Symbol, untyped] position) -> Integer
       def find_char_position(position)
-        # Find the character index for the beginning of the requested line
+        # Each group of bytes is a character. We advance based on the number of bytes to count how many full characters
+        # we have in the requested offset
         until @current_line == position[:line]
-          @pos += 1 until LINE_BREAK == @bytes_or_codepoints[@pos]
+          byte = @bytes[@pos] #: Integer?
+          raise InvalidLocationError unless byte
+
+          until LINE_BREAK == byte
+            @pos += character_byte_length(byte)
+            @character_length += 1
+            byte = @bytes[@pos]
+            raise InvalidLocationError unless byte
+          end
+
           @pos += 1
+          @character_length += 1
           @current_line += 1
         end
 
-        # For UTF-8, the code unit length is the same as bytes, but we want to return the character index
-        requested_position = if @encoding == Encoding::UTF_8
-          character_offset = 0
-          i = @pos
-
-          # Each group of bytes is a character. We advance based on the number of bytes to count how many full
-          # characters we have in the requested offset
-          while i < @pos + position[:character] && i < @bytes_or_codepoints.length
-            byte = @bytes_or_codepoints[i] #: as !nil
-            i += if byte < 0x80 # 1-byte character
-              1
-            elsif byte < 0xE0 # 2-byte character
-              2
-            elsif byte < 0xF0 # 3-byte character
-              3
-            else # 4-byte character
-              4
-            end
-
-            character_offset += 1
+        # @character_length has the number of characters until the beginning of the line. We don't accumulate on it for
+        # the character part because locating the same position twice must return the same value
+        line_byte_offset = 0
+        line_characters = 0
+
+        while line_byte_offset < position[:character]
+          byte = @bytes[@pos + line_byte_offset] #: Integer?
+          raise InvalidLocationError unless byte
+
+          line_byte_offset += character_byte_length(byte)
+          line_characters += 1
+        end
+
+        @character_length + line_characters
+      end
+
+      private
+
+      #: (Integer) -> Integer
+      def character_byte_length(byte)
+        if byte < 0x80 # 1-byte character
+          1
+        elsif byte < 0xE0 # 2-byte character
+          2
+        elsif byte < 0xF0 # 3-byte character
+          3
+        else # 4-byte character
+          4
+        end
+      end
+    end
+
+    # For the UTF-16 encoding, positions correspond to UTF-16 code units, which count characters beyond the surrogate
+    # pair as length 2
+    class Utf16Scanner < Scanner
+      #: (String) -> void
+      def initialize(source)
+        super()
+        @codepoints = source.codepoints #: Array[Integer]
+      end
+
+      # @override
+      #: (Hash[Symbol, untyped] position) -> Integer
+      def find_char_position(position)
+        # Find the character index for the beginning of the requested line
+        until @current_line == position[:line]
+          codepoint = @codepoints[@pos] #: Integer?
+          raise InvalidLocationError unless codepoint
+
+          until LINE_BREAK == @codepoints[@pos]
+            @pos += 1
+            codepoint = @codepoints[@pos] #: Integer?
+            raise InvalidLocationError unless codepoint
           end
 
-          @pos + character_offset
-        else
-          @pos + position[:character]
+          @pos += 1
+          @current_line += 1
         end
 
         # The final position is the beginning of the line plus the requested column. If the encoding is UTF-16, we also
         # need to adjust for surrogate pairs
-        if @encoding == Encoding::UTF_16LE
-          requested_position -= utf_16_character_position_correction(@pos, requested_position)
+        line_characters = 0
+        line_code_units = 0
+
+        while line_code_units < position[:character]
+          code_point = @codepoints[@pos + line_characters]
+          raise InvalidLocationError unless code_point
+
+          line_code_units += if code_point > SURROGATE_PAIR_START
+            2 # Surrogate pair, so we skip the next code unit
+          else
+            1 # Single code unit character
+          end
+
+          line_characters += 1
         end
 
-        requested_position
+        @pos + line_characters
       end
+    end
 
-      # Subtract 1 for each character after 0xFFFF in the current line from the column position, so that we hit the
-      # right character in the UTF-8 representation
-      #: (Integer current_position, Integer requested_position) -> Integer
-      def utf_16_character_position_correction(current_position, requested_position)
-        utf16_unicode_correction = 0
+    # For the UTF-32 encoding, positions correspond directly to codepoints
+    class Utf32Scanner < Scanner
+      #: (String) -> void
+      def initialize(source)
+        super()
+        @codepoints = source.codepoints #: Array[Integer]
+      end
 
-        until current_position == requested_position
-          codepoint = @bytes_or_codepoints[current_position]
-          utf16_unicode_correction += 1 if codepoint && codepoint > SURROGATE_PAIR_START
+      # @override
+      #: (Hash[Symbol, untyped] position) -> Integer
+      def find_char_position(position)
+        # Find the character index for the beginning of the requested line
+        until @current_line == position[:line]
+          codepoint = @codepoints[@pos] #: Integer?
+          raise InvalidLocationError unless codepoint
+
+          until LINE_BREAK == @codepoints[@pos]
+            @pos += 1
+            codepoint = @codepoints[@pos] #: Integer?
+            raise InvalidLocationError unless codepoint
+          end
 
-          current_position += 1
+          @pos += 1
+          @current_line += 1
         end
 
-        utf16_unicode_correction
+        @pos + position[:character]
       end
     end
   end

data/lib/ruby_lsp/listeners/hover.rb

@@ -7,6 +7,7 @@ module RubyLsp
       include Requests::Support::Common
 
       ALLOWED_TARGETS = [
+        Prism::BreakNode,
         Prism::CallNode,
         Prism::ConstantReadNode,
         Prism::ConstantWriteNode,
@@ -54,6 +55,7 @@ module RubyLsp
 
         dispatcher.register(
           self,
+          :on_break_node_enter,
           :on_constant_read_node_enter,
           :on_constant_write_node_enter,
           :on_constant_path_node_enter,
@@ -84,6 +86,11 @@ module RubyLsp
         )
       end
 
+      #: (Prism::BreakNode node) -> void
+      def on_break_node_enter(node)
+        handle_keyword_documentation(node.keyword)
+      end
+
       #: (Prism::StringNode node) -> void
       def on_string_node_enter(node)
         if @path && File.basename(@path) == GEMFILE_NAME

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -365,7 +365,7 @@ module RubyLsp
           end
         end
 
-        node = node #: as Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode # rubocop:disable Layout/LineLength
+        node = node #: as Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode
 
         node_context = @document.locate_node(
           {

data/lib/ruby_lsp/requests/references.rb

@@ -55,7 +55,7 @@ module RubyLsp
           )
         end
 
-        target = target #: as Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode | Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode | Prism::CallNode | Prism::DefNode, # rubocop:disable Layout/LineLength
+        target = target #: as Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode | Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode | Prism::CallNode | Prism::DefNode,
 
         reference_target = create_reference_target(target, node_context)
         return @locations unless reference_target

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

@@ -111,7 +111,11 @@ module RubyLsp
         rescue ::RuboCop::ValidationError => error
           raise ConfigurationError, error.message
         rescue StandardError => error
-          raise InternalRuboCopError, error
+          # Maintain the original backtrace so that debugging cops that are breaking is easier, but re-raise as a
+          # different error class
+          internal_error = InternalRuboCopError.new(error)
+          internal_error.set_backtrace(error.backtrace)
+          raise internal_error
         end
 
         #: -> String

data/lib/ruby_lsp/ruby_document.rb

@@ -26,7 +26,7 @@ module RubyLsp
         queue = node.child_nodes.compact #: Array[Prism::Node?]
         closest = node
         parent = nil #: Prism::Node?
-        nesting_nodes = [] #: Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)] # rubocop:disable Layout/LineLength
+        nesting_nodes = [] #: Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)]
 
         nesting_nodes << node if node.is_a?(Prism::ProgramNode)
         call_node = nil #: Prism::CallNode?

data/lib/ruby_lsp/server.rb

@@ -115,7 +115,7 @@ module RubyLsp
       end
     rescue DelegateRequestError
       send_message(Error.new(id: message[:id], code: DelegateRequestError::CODE, message: "DELEGATE_REQUEST"))
-    rescue StandardError, LoadError => e
+    rescue StandardError, LoadError, SystemExit => e
       # If an error occurred in a request, we have to return an error response or else the editor will hang
       if message[:id]
         # If a document is deleted before we are able to process all of its enqueued requests, we will try to read it

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/test_reporters/lsp_reporter.rb

@@ -20,8 +20,6 @@ module RubyLsp
       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 +30,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"

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/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.24.1
+  version: 0.24.2
 platform: ruby
 authors:
 - Shopify
@@ -209,6 +209,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: