solid-resp-ractor 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e95465d9cdecff50ce715e8150335b5f90da49121a1a047edb433210e308015c
-  data.tar.gz: 1dd82d1a8d80ea412d1ce2257f51b081dc5231718f9aaed71386d739a6bc8ac3
+  metadata.gz: 6f2f11114c1db059699754b9f59cc7f477973e8afd851a988774704491cce1d0
+  data.tar.gz: b34e06efbf004e73d426a6007666305c394b20c0b5ca98749719422ae6f2bd99
 SHA512:
-  metadata.gz: bd9661ccd7e481088936f7b3425da4bacf8a58754dab3122397bbd003d03c7704fe1e6b813be11575dab60b790548c776ca1e452998c80891b8a967c4ccfa7d2
-  data.tar.gz: 901b266a995302514ebe6f0fb4cdfd0e9641e415b908fb109b249b8ed14e0b0f2fe2572c2e902158d6af9918f50cc1ed725f1a48f1c70c825484578dbbc99a4b
+  metadata.gz: da143efb9f9261281d77b9638e4f2b21affaf1e26f2a11517934adfd8ad4c7326ad7442f6f3df8ce448ddfa7bcea0b588277bbe6eccc41111c9b5b268d92456e
+  data.tar.gz: 4970b3297c71ba673e49ea9d41effc4038b20bc69c56f4f5f71d16d33ceaab9df976f7d91946a66902cb18a3dcdd5fe614771a8a320c7ae585b942c19cfe4d74

data/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 All notable changes to this project are documented in this file.
 
+## [Unreleased]
+
+## [0.1.5] - 2026-10-04
+
+### Changed
+
+- Parse RESP integers and lengths in place from the read buffer, without
+  allocating a temporary line String. Non-decimal forms still fall back to
+  `Kernel#Integer` semantics.
+- Read nested values through an internal depth-tracked path instead of the
+  public `#read`, removing per-element `ensure` bookkeeping and subclass
+  wrappers from aggregate parsing.
+- Skip handler dispatch for scalars and plain aggregates when the built-in
+  `Compatible` or `Typed` handlers are used.
+- Clear the consumed read buffer once per reply instead of after every token.
+- Encode flat commands in a single loop with inline String and small Integer
+  fast paths for the default argument encoder.
+- Cache non-blocking IO capabilities and take only one clock reading per
+  readiness wait.
+- Ruby 4.0.1 microbenchmarks: flat command encoding +72% to +85%, bulk reply
+  parsing +51%, 10-element arrays +68% with 33 → 11 allocations, and
+  50-reply pipelines +46% with 125 → 75 allocations.
+
+### Fixed
+
+- Locate CRLF terminators by byte offset (`String#byteindex`, Ruby 3.2+) so
+  custom sources returning multibyte UTF-8 chunks are parsed correctly.
+
 ## [0.1.4] - 2026-10-01
 
 ### Changed

data/lib/solid_resp_ractor/encoder.rb

@@ -27,61 +27,77 @@ module SolidRespRactor
       Array.new(129) { |length| "*#{length}#{CRLF}".freeze },
     )
 
+    INTEGER_STRINGS = Ractor.make_shareable(
+      Array.new(1_024) { |integer| integer.to_s.freeze },
+    )
+    EMPTY_COMMAND = "RESP command cannot be empty"
+
     attr_reader :argument_encoder
 
     def initialize(argument_encoder: ArgumentEncoders::Default, expand_arrays: true)
       @argument_encoder = argument_encoder
       @expand_arrays = expand_arrays
+      @default_arguments = argument_encoder.equal?(ArgumentEncoders::Default)
       freeze
     end
 
     def encode(command)
-      unless @expand_arrays && command.any? { |argument| argument.is_a?(Array) }
-        return encode_flat(command)
-      end
-
-      length = command.sum { |argument| expanded?(argument) ? argument.length : 1 }
-      raise ArgumentError, "RESP command cannot be empty" if length.zero?
-
-      command.each_with_object(+"*#{length}#{CRLF}") do |argument, buffer|
-        if expanded?(argument)
-          argument.each { |value| append_argument(buffer, value) }
+      length = command.length
+      raise ArgumentError, EMPTY_COMMAND if length.zero?
+
+      buffer = +(ARRAY_HEADERS[length] || "*#{length}#{CRLF}")
+      index = 0
+      while index < length
+        argument = command[index]
+        if @default_arguments && argument.is_a?(String)
+          value = argument
+        elsif @expand_arrays && argument.is_a?(Array)
+          return encode_expanded(command)
         else
-          append_argument(buffer, argument)
+          value = encode_argument(argument)
         end
+        bytesize = value.bytesize
+        buffer << (BULK_HEADERS[bytesize] || "$#{bytesize}#{CRLF}") << value << CRLF
+        index += 1
       end
+      buffer
     end
 
     private
 
-    def encode_flat(command)
-      length = command.length
-      raise ArgumentError, "RESP command cannot be empty" if length.zero?
+    def encode_expanded(command)
+      length = command.sum { |argument| argument.is_a?(Array) ? argument.length : 1 }
+      raise ArgumentError, EMPTY_COMMAND if length.zero?
 
-      command.each_with_object(+array_header(length)) do |argument, buffer|
-        append_argument(buffer, argument)
+      command.each_with_object(+"*#{length}#{CRLF}") do |argument, buffer|
+        if argument.is_a?(Array)
+          argument.each { |value| append_argument(buffer, value) }
+        else
+          append_argument(buffer, argument)
+        end
       end
     end
 
-    def array_header(length)
-      ARRAY_HEADERS[length] || "*#{length}#{CRLF}"
+    def append_argument(buffer, argument)
+      value = encode_argument(argument)
+      bytesize = value.bytesize
+      buffer << (BULK_HEADERS[bytesize] || "$#{bytesize}#{CRLF}") << value << CRLF
     end
 
-    def expanded?(argument)
-      @expand_arrays && argument.is_a?(Array)
-    end
+    def encode_argument(argument)
+      if @default_arguments
+        return argument if argument.is_a?(String)
+        if argument.is_a?(Integer) && argument >= 0 && argument < 1_024
+          return INTEGER_STRINGS[argument]
+        end
+      end
 
-    def append_argument(buffer, argument)
       value = @argument_encoder.call(argument)
       unless value.is_a?(String)
         raise TypeError, "argument encoder must return a String, got #{value.class}"
       end
 
-      buffer << bulk_header(value.bytesize) << value << CRLF
-    end
-
-    def bulk_header(length)
-      BULK_HEADERS[length] || "$#{length}#{CRLF}"
+      value
     end
   end
 

data/lib/solid_resp_ractor/reader.rb

@@ -4,6 +4,7 @@ module SolidRespRactor
   class Reader
     CRLF = "\r\n"
     COMPACT_THRESHOLD = 16 * 1024
+    PASSTHROUGH_HANDLERS = Ractor.make_shareable([Handlers::Compatible, Handlers::Typed])
 
     attr_reader :source
 
@@ -31,11 +32,15 @@ module SolidRespRactor
       )
       @read_timeout = read_timeout
       @handler = handler
+      # Built-in handlers return scalars and plain aggregates unchanged, so
+      # the hot path can skip the dispatch for those types.
+      @passthrough = PASSTHROUGH_HANDLERS.include?(handler)
       @error_mapper = error_mapper
       @limits = limits
+      @max_line_size = limits.max_line_size
+      @max_nesting_depth = limits.max_nesting_depth
       @buffer = +""
       @offset = 0
-      @read_depth = 0
       @captured_error = nil
     end
 
@@ -55,116 +60,139 @@ module SolidRespRactor
     end
 
     def read(exception: true)
-      top_level = @read_depth.zero?
-      @captured_error = nil if top_level
-      @read_depth += 1
-      if @read_depth > @limits.max_nesting_depth
-        raise ProtocolError, "RESP nesting exceeds #{@limits.max_nesting_depth}"
-      end
-      value = read_type(read_byte)
-      raise @captured_error if top_level && exception && @captured_error
+      @captured_error = nil
+      value = read_value(1)
+      clear_consumed_buffer
+      raise @captured_error if exception && @captured_error
 
       value
     rescue EOFError
       raise ConnectionError, "RESP stream closed"
-    ensure
-      @read_depth -= 1
     end
 
     private
 
-    def read_type(type)
+    def read_value(depth)
+      if depth > @max_nesting_depth
+        raise ProtocolError, "RESP nesting exceeds #{@max_nesting_depth}"
+      end
+
+      fill_buffer if @offset >= @buffer.bytesize
+      type = @buffer.getbyte(@offset)
+      @offset += 1
+      read_type(type, depth)
+    end
+
+    def read_type(type, depth)
       case type
-      when 43 then handle(:simple_string, read_line)
-      when 45 then error_response(read_line, blob: false)
-      when 58 then handle(:integer, parse_integer(read_line))
       when 36 then read_blob
-      when 42 then read_array
+      when 43
+        value = read_line
+        @passthrough ? value : handle(:simple_string, value)
+      when 58
+        value = read_integer
+        @passthrough ? value : handle(:integer, value)
+      when 42 then read_array(depth)
+      when 45 then error_response(read_line, blob: false)
       when 95 then read_null
       when 35 then read_boolean
       when 44 then handle(:double, parse_float(read_line))
-      when 40 then handle(:big_number, parse_integer(read_line))
-      when 37 then read_map
-      when 126 then read_collection(:set)
-      when 62 then read_collection(:push)
+      when 40 then handle(:big_number, read_integer)
+      when 37 then read_map(depth)
+      when 126 then read_collection(:set, depth)
+      when 62 then read_collection(:push, depth)
       when 61 then read_verbatim
-      when 33 then error_response(read_sized_string(streamed: true), blob: true)
-      when 124 then read_attribute
+      when 33 then error_response(read_sized_string(true), blob: true)
+      when 124 then read_attribute(depth)
       else raise ProtocolError, "Unknown RESP type byte: #{type.chr.inspect}"
       end
     end
 
     def read_blob
-      length = read_length(nullable: true, streamed: true)
-      return handle(:blob_string, nil) unless length
-
-      validate_blob_length(length) unless length == :streamed
-      value = length == :streamed ? read_chunked_string : read_sized_value(length)
-      handle(:blob_string, value)
+      length = read_length(true, true)
+      if length.nil?
+        value = nil
+      elsif length == :streamed
+        value = read_chunked_string
+      else
+        validate_blob_length(length)
+        value = read_sized_value(length)
+      end
+      @passthrough ? value : handle(:blob_string, value)
     end
 
-    def read_array
-      length = read_length(nullable: true, streamed: true)
-      return handle(:array, nil) unless length
-
-      validate_collection_length(length) unless length == :streamed
-      value = if length == :streamed
-        read_streamed_collection
+    def read_array(depth)
+      length = read_length(true, true)
+      if length.nil?
+        value = nil
+      elsif length == :streamed
+        value = read_streamed_collection(depth)
       else
-        Array.new(length) { read(exception: false) }
+        validate_collection_length(length)
+        value = read_elements(length, depth + 1)
+      end
+      @passthrough ? value : handle(:array, value)
+    end
+
+    def read_elements(length, depth)
+      values = Array.new(length)
+      index = 0
+      while index < length
+        values[index] = read_value(depth)
+        index += 1
       end
-      handle(:array, value)
+      values
     end
 
-    def read_collection(type)
-      length = read_length(streamed: true)
-      validate_collection_length(length) unless length == :streamed
+    def read_collection(type, depth)
+      length = read_length(false, true)
       value = if length == :streamed
-        read_streamed_collection
+        read_streamed_collection(depth)
       else
-        Array.new(length) { read(exception: false) }
+        validate_collection_length(length)
+        read_elements(length, depth + 1)
       end
       handle(type, value)
     end
 
-    def read_map
-      length = read_length(streamed: true)
-      validate_collection_length(length) unless length == :streamed
+    def read_map(depth)
+      length = read_length(false, true)
       value = if length == :streamed
-        read_streamed_map
+        read_streamed_map(depth)
       else
-        {}.tap do |result|
-          length.times { result[read(exception: false)] = read(exception: false) }
-        end
+        validate_collection_length(length)
+        result = {}
+        length.times { result[read_value(depth + 1)] = read_value(depth + 1) }
+        result
       end
       handle(:map, value)
     end
 
-    def read_streamed_collection
+    def read_streamed_collection(depth)
       values = []
       loop do
         type = read_byte
         break if aggregate_end?(type)
 
-        values << read_type(type)
+        values << read_type(type, depth)
         validate_collection_length(values.length)
       end
       values
     end
 
-    def read_streamed_map
-      {}.tap do |result|
-        count = 0
-        loop do
-          type = read_byte
-          break if aggregate_end?(type)
+    def read_streamed_map(depth)
+      result = {}
+      count = 0
+      loop do
+        type = read_byte
+        break if aggregate_end?(type)
 
-          key = read_type(type)
-          result[key] = read(exception: false)
-          count += 1
-          validate_collection_length(count)
-        end
+        key = read_type(type, depth)
+        result[key] = read_value(depth + 1)
+        count += 1
+        validate_collection_length(count)
       end
+      result
     end
 
     def aggregate_end?(type)
@@ -176,9 +204,9 @@ module SolidRespRactor
       true
     end
 
-    def read_attribute
-      attributes = read_map
-      value = read(exception: false)
+    def read_attribute(depth)
+      attributes = read_map(depth)
+      value = read_value(depth + 1)
       handle(:attribute, [attributes, value])
     end
 
@@ -186,7 +214,7 @@ module SolidRespRactor
       value = read_line
       raise ProtocolError, "RESP null must not contain data" unless value.empty?
 
-      handle(:null, nil)
+      @passthrough ? nil : handle(:null, nil)
     end
 
     def read_boolean
@@ -198,7 +226,7 @@ module SolidRespRactor
     end
 
     def read_verbatim
-      value = read_sized_string(streamed: true)
+      value = read_sized_string(true)
       unless value.bytesize >= 4 && value.byteslice(3, 1) == ":"
         raise ProtocolError, "Invalid RESP verbatim string"
       end
@@ -206,10 +234,12 @@ module SolidRespRactor
       handle(:verbatim, [value.byteslice(0, 3).freeze, value.byteslice(4..)])
     end
 
-    def read_sized_string(streamed: false)
-      length = read_length(streamed: streamed)
-      validate_blob_length(length) unless length == :streamed
-      length == :streamed ? read_chunked_string : read_sized_value(length)
+    def read_sized_string(streamed = false)
+      length = read_length(false, streamed)
+      return read_chunked_string if length == :streamed
+
+      validate_blob_length(length)
+      read_sized_value(length)
     end
 
     def read_chunked_string
@@ -230,22 +260,65 @@ module SolidRespRactor
     end
 
     def read_sized_value(length)
+      offset = @offset
+      buffer = @buffer
+      if buffer.bytesize - offset >= length + 2 &&
+          buffer.getbyte(offset + length) == 13 &&
+          buffer.getbyte(offset + length + 1) == 10
+        @offset = offset + length + 2
+        return buffer.byteslice(offset, length)
+      end
+
       value = read_bytes(length)
       read_crlf
       value
     end
 
-    def read_length(nullable: false, streamed: false)
-      value = read_line
-      return :streamed if streamed && value == "?"
+    def read_length(nullable = false, streamed = false)
+      length = scan_integer
+      unless length
+        value = read_line
+        return :streamed if streamed && value == "?"
 
-      length = parse_integer(value)
+        length = parse_integer(value)
+      end
       return if nullable && length == -1
       raise ProtocolError, "Invalid RESP length: #{length}" if length.negative?
 
       length
     end
 
+    def read_integer
+      scan_integer || parse_integer(read_line)
+    end
+
+    # Parses a plain decimal line in place, without allocating the line.
+    # Returns nil whenever the line is incomplete or not a plain decimal so
+    # the caller falls back to the exact Kernel#Integer semantics.
+    def scan_integer
+      buffer = @buffer
+      offset = @offset
+      index = find_crlf(buffer, offset)
+      return unless index && index - offset <= @max_line_size
+
+      position = offset
+      negative = buffer.getbyte(position) == 45
+      position += 1 if negative
+      return if position >= index
+      return if buffer.getbyte(position) == 48 && position + 1 < index
+
+      value = 0
+      while position < index
+        byte = buffer.getbyte(position)
+        return unless byte >= 48 && byte <= 57
+
+        value = (value * 10) + (byte - 48)
+        position += 1
+      end
+      @offset = index + 2
+      negative ? -value : value
+    end
+
     def parse_integer(value)
       Integer(value)
     rescue ArgumentError
@@ -264,36 +337,43 @@ module SolidRespRactor
 
     def read_line
       loop do
-        if (index = @buffer.index(CRLF, @offset))
-          line_length = index - @offset
-          if line_length > @limits.max_line_size
-            raise ProtocolError, "RESP line exceeds #{@limits.max_line_size} bytes"
+        offset = @offset
+        if (index = find_crlf(@buffer, offset))
+          line_length = index - offset
+          if line_length > @max_line_size
+            raise ProtocolError, "RESP line exceeds #{@max_line_size} bytes"
           end
-          value = @buffer.byteslice(@offset, line_length)
           @offset = index + 2
-          clear_consumed_buffer
-          return value
+          return @buffer.byteslice(offset, line_length)
         end
-        if available_bytes > @limits.max_line_size
-          raise ProtocolError, "RESP line exceeds #{@limits.max_line_size} bytes"
+        if available_bytes > @max_line_size
+          raise ProtocolError, "RESP line exceeds #{@max_line_size} bytes"
         end
         fill_buffer
       end
     end
 
+    if "".respond_to?(:byteindex)
+      def find_crlf(buffer, offset)
+        buffer.byteindex(CRLF, offset)
+      end
+    else
+      def find_crlf(buffer, offset)
+        buffer.index(CRLF, offset)
+      end
+    end
+
     def read_bytes(length)
       fill_buffer while available_bytes < length
       value = @buffer.byteslice(@offset, length)
       @offset += length
-      clear_consumed_buffer
       value
     end
 
     def read_byte
-      fill_buffer while available_bytes < 1
+      fill_buffer if @offset >= @buffer.bytesize
       value = @buffer.getbyte(@offset)
       @offset += 1
-      clear_consumed_buffer
       value
     end
 
@@ -306,11 +386,14 @@ module SolidRespRactor
       end
 
       @offset += 2
-      clear_consumed_buffer
     end
 
     def fill_buffer
-      compact_buffer
+      if @offset == @buffer.bytesize
+        clear_consumed_buffer
+      else
+        compact_buffer
+      end
       chunk = @source.read(timeout: @read_timeout)
       raise EOFError if chunk.nil?
       unless chunk.is_a?(String)

data/lib/solid_resp_ractor/source.rb

@@ -48,28 +48,18 @@ module SolidRespRactor
         @selector = selector
         @clock = clock
         @read_buffer = +""
+        @nonblocking = io.respond_to?(:read_nonblock)
+        @selector_waits = selector.respond_to?(:wait)
+        @selectable = nil
       end
 
       def read(timeout:)
-        return blocking_read unless @io.respond_to?(:read_nonblock)
+        return blocking_read unless @nonblocking
 
-        deadline = nil
-        loop do
-          chunk = @io.read_nonblock(
-            @chunk_size,
-            @read_buffer,
-            exception: false,
-          )
-          return chunk unless chunk == :wait_readable || chunk == :wait_writable
-
-          deadline ||= @clock.now + timeout if timeout
-          remaining = deadline && deadline - @clock.now
-          raise_timeout(timeout) if remaining && remaining <= 0
+        chunk = @io.read_nonblock(@chunk_size, @read_buffer, exception: false)
+        return chunk unless chunk == :wait_readable || chunk == :wait_writable
 
-          selectable = @io.respond_to?(:to_io) ? @io.to_io : @io
-          event = chunk == :wait_readable ? :read : :write
-          raise_timeout(timeout) unless wait(selectable, event, remaining)
-        end
+        wait_for_chunk(chunk, timeout)
       rescue IOError, SystemCallError => error
         raise ConnectionError, error.message, cause: error
       end
@@ -84,12 +74,29 @@ module SolidRespRactor
 
       private
 
+      def wait_for_chunk(chunk, timeout)
+        selectable = (@selectable ||= @io.respond_to?(:to_io) ? @io.to_io : @io)
+        deadline = timeout && @clock.now + timeout
+        remaining = timeout
+        loop do
+          raise_timeout(timeout) if remaining && remaining <= 0
+
+          event = chunk == :wait_readable ? :read : :write
+          raise_timeout(timeout) unless wait(selectable, event, remaining)
+
+          chunk = @io.read_nonblock(@chunk_size, @read_buffer, exception: false)
+          return chunk unless chunk == :wait_readable || chunk == :wait_writable
+
+          remaining = deadline && deadline - @clock.now
+        end
+      end
+
       def blocking_read
         @io.read(@chunk_size)
       end
 
       def wait(io, event, timeout)
-        return @selector.wait(io, event, timeout) if @selector.respond_to?(:wait)
+        return @selector.wait(io, event, timeout) if @selector_waits
 
         readers = event == :read ? [io] : nil
         writers = event == :write ? [io] : nil

data/lib/solid_resp_ractor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidRespRactor
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solid-resp-ractor
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Nicolas Vandenbogaerde