solid-redis 1.0.7 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bec7101ec6b158672f2419765b2d7aaad5ed70ca2c80062dd68a6fc57a0b4c5
-  data.tar.gz: bc629f38d3cf771b7948d475c962e183cc6abd791b8195995bc93ae033c96443
+  metadata.gz: '068ad360bb74b73918a5c3ea54efadb9c54d2b60299c9727e0b419f65e9f7222'
+  data.tar.gz: 81a8967caed43336537bd71405c4ca08fc31f1d7d281e8c1e8cc3346221ec834
 SHA512:
-  metadata.gz: 590521ea57999193e9310448445ff843c602ed0f41064329c4ec5e1d6958d390e7d4fe1246a34b1566a861bc015e90b9bec61e37b922e4f056b6ab1650bf31d6
-  data.tar.gz: d82981e8ca5ab260d0efa7413392fdb69cc8e3fc33a12b45c4ed5f847d1196917a4f12a84f453162a576c87fdc7accf5e9a86e9d1fae19982b7fdcbc61eca10a
+  metadata.gz: 5b655ca4855ecbbd882beb95dcbc8f9f77323ae9b40efa0cf78bf639a71605d46e8868586960b98c8fd9fdd109f3011c7da0028e74cafda24f54dfb65e4fb40e
+  data.tar.gz: 1bac6bf305f29200e8441ce27d36f4938512bf4e74211932d58c9480132480169635cfd18bb5b8ea7db671385f2ac1aef45a87121843c0c3d5136a307c7cac90

data/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project are documented in this file. The format
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the
 project adheres to [Semantic Versioning](https://semver.org/).
 
+## [1.0.8] - 2026-09-29
+
+### Changed
+
+- Use `solid-resp-ractor` for RESP2/RESP3 encoding and parsing while
+  preserving SolidRedis's existing error classes and `SolidRedis::RESP`
+  compatibility API.
+
 ## [1.0.7] - 2026-09-29
 
 ### Changed
@@ -140,6 +148,7 @@ project adheres to [Semantic Versioning](https://semver.org/).
   TLS, reconnection), `Pool` owned by a single Ractor, pipelines, and
   lifecycle callbacks via `callback-collection`.
 
+[1.0.8]: https://github.com/nicolasva/solid-redis/compare/v1.0.7...v1.0.8
 [1.0.7]: https://github.com/nicolasva/solid-redis/compare/v1.0.6...v1.0.7
 [1.0.6]: https://github.com/nicolasva/solid-redis/compare/v1.0.5...v1.0.6
 [1.0.5]: https://github.com/nicolasva/solid-redis/compare/v1.0.4...v1.0.5

data/lib/solid_redis/resp.rb

@@ -2,253 +2,52 @@
 
 module SolidRedis
   module RESP
-    CRLF = "\r\n"
+    CRLF = SolidRespRactor::Encoder::CRLF
 
-    module_function
-
-    def encode(command)
-      length = command.sum { |argument| argument.is_a?(Array) ? argument.length : 1 }
-      raise ArgumentError, "Redis command cannot be empty" if length.zero?
+    module ErrorMapper
+      module_function
 
-      command.each_with_object(+"*#{length}#{CRLF}") do |argument, buffer|
-        if argument.is_a?(Array)
-          argument.each { |value| append_argument(buffer, value) }
+      def call(message, blob:)
+        error_class = if message.start_with?("NOAUTH", "WRONGPASS")
+          AuthenticationError
         else
-          append_argument(buffer, argument)
+          CommandError
         end
+        error_class.new(message)
       end
     end
 
-    def append_argument(buffer, argument)
-      value = encode_argument(argument)
-      buffer << "$#{value.bytesize}#{CRLF}#{value}#{CRLF}"
-    end
+    CODEC = SolidRespRactor::Codec.new(error_mapper: ErrorMapper)
+    Ractor.make_shareable(CODEC)
 
-    def encode_argument(value)
-      case value
-      when String then value
-      when Symbol, Integer, Float then value.to_s
-      when true then "1"
-      when false then "0"
-      when nil then ""
-      else value.to_s
-      end
+    module_function
+
+    def encode(command)
+      CODEC.encode(command)
     end
 
-    class Reader
+    class Reader < SolidRespRactor::Reader
       def initialize(io, read_timeout:)
-        @io = io
-        @read_timeout = read_timeout
-        @buffer = +""
-        @offset = 0
+        super(io, read_timeout: read_timeout, error_mapper: ErrorMapper)
       end
 
-      # Temporarily overrides the read timeout. +nil+ waits forever, which is
-      # what blocking commands such as BLPOP with a 0 timeout require.
-      def with_timeout(timeout)
-        previous = @read_timeout
-        @read_timeout = timeout
-        yield
-      ensure
-        @read_timeout = previous
-      end
-
-      # Waits until at least one byte is available without consuming it.
-      # Returns +false+ on timeout. Unlike a timed-out +read+, this never
-      # leaves a partially consumed frame behind, so it is the safe way to
-      # poll for the next Pub/Sub message.
-      def wait_readable(timeout)
-        return true if available_bytes.positive?
-        return true unless @io.respond_to?(:to_io)
-
-        !IO.select([@io], nil, nil, timeout).nil?
-      rescue IOError, SystemCallError => error
+      def read(...)
+        super
+      rescue SolidRespRactor::ProtocolError => error
+        raise ProtocolError, error.message, cause: error
+      rescue SolidRespRactor::TimeoutError => error
+        raise TimeoutError, error.message, cause: error
+      rescue SolidRespRactor::ConnectionError => error
         raise ConnectionError, error.message, cause: error
       end
 
-      def read(exception: true)
-        case (type = read_bytes(1))
-        when "+" then read_line
-        when "-" then error_response(read_line, exception)
-        when ":" then Integer(read_line)
-        when "$" then read_bulk
-        when "*" then read_array(exception)
-        when "_" then read_line && nil
-        when "#" then read_line == "t"
-        when "," then Float(read_line)
-        when "(" then Integer(read_line)
-        when "%" then read_map(exception)
-        when "~", ">" then read_collection(exception)
-        when "=" then read_verbatim
-        when "!" then error_response(read_sized_string, exception)
-        when "|" then read_attribute(exception)
-        else raise ProtocolError, "Unknown RESP type byte: #{type.inspect}"
-        end
-      rescue EOFError
-        raise ConnectionError, "Redis closed the connection"
-      rescue ArgumentError => error
-        raise ProtocolError, "Invalid Redis response: #{error.message}", cause: error
-      end
-
-      private
-
-      def read_bulk
-        length = Integer(read_line)
-        return if length == -1
-
-        read_sized_value(length)
-      end
-
-      def read_array(exception)
-        length = Integer(read_line)
-        return if length == -1
-
-        finish_collection(Array.new(length) { read(exception: false) }, exception)
-      end
-
-      def read_collection(exception)
-        length = Integer(read_line)
-        finish_collection(Array.new(length) { read(exception: false) }, exception)
-      end
-
-      def read_map(exception)
-        length = Integer(read_line)
-        map = {}.tap do |result|
-          length.times { result[read(exception: false)] = read(exception: false) }
-        end
-        finish_collection(map, exception)
-      end
-
-      def read_attribute(exception)
-        attributes = read_map(false)
-        value = read(exception: false)
-        raise_nested_error(attributes) if exception
-        raise_nested_error(value) if exception
-        value
-      end
-
-      def finish_collection(value, exception)
-        raise_nested_error(value) if exception
-        value
-      end
-
-      def raise_nested_error(value)
-        case value
-        when CommandError
-          raise value
-        when Array
-          value.each { |element| raise_nested_error(element) }
-        when Hash
-          value.each do |key, element|
-            raise_nested_error(key)
-            raise_nested_error(element)
-          end
-        end
-      end
-
-      def read_verbatim
-        read_sized_string.byteslice(4..)
-      end
-
-      def read_sized_string
-        read_sized_value(Integer(read_line))
-      end
-
-      def read_sized_value(length)
-        value = read_bytes(length)
-        actual = read_bytes(2)
-        raise ProtocolError, "Expected CRLF, got #{actual.inspect}" unless actual == CRLF
-
-        value
-      end
-
-      def read_line
-        loop do
-          if (index = @buffer.index(CRLF, @offset))
-            value = @buffer.byteslice(@offset, index - @offset)
-            @offset = index + 2
-            clear_consumed_buffer
-            return value
-          end
-          fill_buffer
-        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 fill_buffer
-        compact_buffer
-        wait_for = :readable
-        deadline = nil
-        loop do
-          if @io.respond_to?(:to_io)
-            chunk = @io.read_nonblock(16_384, exception: false)
-          else
-            chunk = @io.read(16_384)
-          end
-
-          if chunk == :wait_readable || chunk == :wait_writable
-            wait_for = chunk == :wait_readable ? :readable : :writable
-            deadline ||= monotonic_time + @read_timeout if @read_timeout
-            remaining = deadline && deadline - monotonic_time
-            if remaining && remaining <= 0
-              raise TimeoutError, "Redis read timed out after #{@read_timeout}s"
-            end
-
-            readers = wait_for == :readable ? [@io] : nil
-            writers = wait_for == :writable ? [@io] : nil
-            unless IO.select(readers, writers, nil, remaining)
-              raise TimeoutError, "Redis read timed out after #{@read_timeout}s"
-            end
-            next
-          end
-          raise EOFError if chunk.nil?
-
-          @buffer << chunk
-          return
-        end
-      rescue IOError, SystemCallError => error
+      def wait_readable(...)
+        super
+      rescue SolidRespRactor::TimeoutError => error
+        raise TimeoutError, error.message, cause: error
+      rescue SolidRespRactor::ConnectionError => error
         raise ConnectionError, error.message, cause: error
       end
-
-      def available_bytes
-        @buffer.bytesize - @offset
-      end
-
-      def clear_consumed_buffer
-        return unless @offset == @buffer.bytesize
-
-        @buffer.clear
-        @offset = 0
-      end
-
-      def compact_buffer
-        return if @offset.zero?
-
-        @buffer = @buffer.byteslice(@offset..) || +""
-        @offset = 0
-      end
-
-      def monotonic_time
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      def error_response(message, exception)
-        error = if message.start_with?("NOAUTH", "WRONGPASS")
-          AuthenticationError.new(message)
-        else
-          CommandError.new(message)
-        end
-        raise error if exception
-
-        error
-      end
     end
   end
 end

data/lib/solid_redis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidRedis
-  VERSION = "1.0.7"
+  VERSION = "1.0.8"
 end

data/lib/solid_redis.rb

@@ -2,6 +2,7 @@
 
 require "base_service"
 require "callback_collection"
+require "solid_resp_ractor"
 
 require_relative "solid_redis/version"
 require_relative "solid_redis/errors"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solid-redis
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.0.8
 platform: ruby
 authors:
 - Nicolas Vandenbogaerde
@@ -37,6 +37,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: solid-resp-ractor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -104,7 +118,7 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-  documentation_uri: https://www.rubydoc.info/gems/solid-redis/1.0.7
+  documentation_uri: https://www.rubydoc.info/gems/solid-redis/1.0.8
   source_code_uri: https://github.com/nicolasva/solid-redis
   changelog_uri: https://github.com/nicolasva/solid-redis/blob/main/CHANGELOG.md
 rdoc_options: []