solid-redis 1.0.6 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9e503f8659d6619a0893c09fa07a4a5f116f42803e0e63938bb1c412c6f81ed
-  data.tar.gz: d2a9a80c9613623f0d91396c9c228fca1350924cae229edb68473caba01f9f5d
+  metadata.gz: '068ad360bb74b73918a5c3ea54efadb9c54d2b60299c9727e0b419f65e9f7222'
+  data.tar.gz: 81a8967caed43336537bd71405c4ca08fc31f1d7d281e8c1e8cc3346221ec834
 SHA512:
-  metadata.gz: e55106efecb61a543eb5dd527cde5d0208b2288f4b533a825c48fbcbe78a0ec4a8b2501b7aecb428db2b81729030ee773a684662968f8d25fe96974d829757ca
-  data.tar.gz: 64889bc487b8a22fbc6e3f4b624915a9d9e20b60310517bd3eca433d7ce67bdd036e4ef2243c8e9febcdac646026d2a4075dc064d1110f521b8caf2562d46bca
+  metadata.gz: 5b655ca4855ecbbd882beb95dcbc8f9f77323ae9b40efa0cf78bf639a71605d46e8868586960b98c8fd9fdd109f3011c7da0028e74cafda24f54dfb65e4fb40e
+  data.tar.gz: 1bac6bf305f29200e8441ce27d36f4938512bf4e74211932d58c9480132480169635cfd18bb5b8ea7db671385f2ac1aef45a87121843c0c3d5136a307c7cac90

data/CHANGELOG.md

@@ -4,6 +4,23 @@ 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
+
+- Document how to install and run the standalone `bench_mark_redis` project
+  against a local SolidRedis checkout.
+- Document how to regenerate SolidRedis's benchmark tables from the external
+  benchmark project.
+
 ## [1.0.6] - 2026-09-29
 
 ### Changed
@@ -131,6 +148,8 @@ 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
 [1.0.4]: https://github.com/nicolasva/solid-redis/compare/v1.0.3...v1.0.4

data/README.md

@@ -617,10 +617,21 @@ harness used for both clients, so they are comparative rather than
 intrinsic library-only costs. `redis-cluster-client` uses its default
 synchronous routing model (`concurrency: { model: :none }`).
 
-Reproduce the full run (requires `redis-server` and `redis-cli`):
+The benchmark suite now lives in the separate `bench_mark_redis` project.
+From a checkout where both repositories are siblings, run the full matrix
+(requires `redis-server` and `redis-cli`) with:
 
 ```sh
-BENCHMARK_README=README.md bundle exec rake benchmark:comparison
+cd ../bench_mark_redis
+SOLID_REDIS_PATH=../solid-redis bundle install
+bundle exec rake comparison
+```
+
+To regenerate this README's benchmark tables:
+
+```sh
+cd ../bench_mark_redis
+BENCHMARK_README=../solid-redis/README.md bundle exec rake comparison
 ```
 
 ### GET / SET
@@ -696,14 +707,18 @@ bundle install
 bundle exec rake
 ```
 
-The default task runs the Minitest suite, a deterministic local throughput
-benchmark, and builds the gem in `pkg/`. CI runs all three on Ruby 3.1 through
-4.0. The test suite includes bounded thread/Ractor stress and fault injection
-for truncated responses, timeouts, reconnects, Sentinel, and Cluster errors.
-Run only the benchmark with:
+The default task runs the Minitest suite and builds the gem in `pkg/`. CI runs
+both on Ruby 3.1 through 4.0. The test suite includes bounded thread/Ractor
+stress and fault injection for truncated responses, timeouts, reconnects,
+Sentinel, and Cluster errors.
+
+Benchmarks and their comparison-only dependencies are maintained in the
+sibling `bench_mark_redis` project. Run its short throughput smoke test with:
 
 ```sh
-bundle exec rake benchmark
+cd ../bench_mark_redis
+SOLID_REDIS_PATH=../solid-redis bundle install
+bundle exec rake throughput
 ```
 
 The suite needs no running Redis: it uses an in-process fake server

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.6"
+  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.6
+  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.6
+  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: []