valkey-glide-rb 0.9.2 → 0.9.3.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17396d39342cbcc8a293f5e8b252e1689841b436664c630e330d06b0a1cff9c9
-  data.tar.gz: 7fa260b6afbb060a1c79a8dcb264aae5b211a24e69b042c720e242d39b7b3ab9
+  metadata.gz: f4e7169668b8720263d645f4a69385454d5c19ec621a9be173fff853becc4188
+  data.tar.gz: 9c314946080eb5ca6bb0c7e90a0cb29bef087c9fe6af5465310c3699ec4238db
 SHA512:
-  metadata.gz: e96a09b0077bd54a30722201d03ccd8bb8baf7a47c0005d5c3d87441bfeb015479181548dce68bd1e882ee9e266be4658e68b2562e32dca6c48c101ca4e0e2cc
-  data.tar.gz: dbee972964d0a2e54dbf7f4916c2bab6427525ace1d97a679845409b9d55390419631c8407df7502ca9b3561bd51ea0bba1ebecd8bbef680cdaa45b5ba28f405
+  metadata.gz: ca9bc3c4e73bd4b1c2fa09bb16aeca1f4a87d6af0522c2d1c1c34b7e9d5609cf3efe832850bc610cee9a2d8fa615b59ec81f1736f692fe6e849f74c03e6fa466
+  data.tar.gz: 9d2090d9f27e8876127eb5996f6be912c11532c02e2b1889c2007323fa4023b7a3a55058cdd3659d02993aef874bc97cb2f9f264632cced052f25ba43ba03d06

data/docker/manylinux2014/Dockerfile

@@ -0,0 +1,18 @@
+# Builds libglide_ffi.so against glibc 2.17 (CentOS 7 baseline), so the
+# resulting binary loads on anything with glibc >= 2.17 — covers
+# amazonlinux:2018.03 (2.17), amazonlinux:2 (2.26), amazonlinux:2023 (2.34).
+FROM quay.io/pypa/manylinux2014_x86_64
+
+ARG PROTOC_VERSION=29.1
+
+RUN yum install -y unzip && yum clean all
+
+RUN curl -sSL -o /tmp/protoc.zip \
+      "https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOC_VERSION}/protoc-${PROTOC_VERSION}-linux-x86_64.zip" \
+    && unzip -q /tmp/protoc.zip -d /usr/local \
+    && rm /tmp/protoc.zip
+
+ENV PATH="/root/.cargo/bin:${PATH}"
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain stable
+
+WORKDIR /workspace

data/lib/valkey/commands/generic_commands.rb

@@ -581,7 +581,10 @@ class Valkey
       private
 
       # Flattens Arrays and Hashes (to alternating key/value) and stringifies
-      # Integers/Floats, matching `redis-client`'s documented `#call`/`#call_v` behavior.
+      # Integers/Floats/Symbols, matching `redis-client`'s documented
+      # `#call`/`#call_v` behavior - including its type check: any leaf that
+      # isn't a String/Symbol/Integer/Float (e.g. `nil`) raises `TypeError`
+      # instead of being silently coerced to `""` via `#to_s`.
       #
       # @example
       #   flatten_call_args(["CMD", [1, [2, 3]], { "a" => 1, "b" => [2, 3] }])
@@ -600,8 +603,10 @@ class Valkey
             stack.concat(arg.reverse)
           when Hash
             arg.to_a.reverse_each { |pair| stack.concat(pair.reverse) }
-          else
+          when String, Symbol, Integer, Float
             acc << arg.to_s
+          else
+            raise TypeError, "Unsupported command argument type: #{arg.class}"
           end
         end
 

data/lib/valkey/commands/scripting_commands.rb

@@ -271,8 +271,13 @@ class Valkey
       end
 
       def invoke_script(script, args: [], keys: [])
-        arg_ptrs, arg_lens = build_command_args(args)
-        keys_ptrs, keys_lens = build_command_args(keys)
+        # Must hold onto the returned buffers (_arg_bufs/_keys_bufs) for the
+        # lifetime of this method - they back arg_ptrs/keys_ptrs, and letting
+        # them go out of scope (e.g. by only capturing the first 2 return
+        # values) makes them eligible for GC before the native call below
+        # reads through those pointers, corrupting ARGV/KEYS with freed memory.
+        arg_ptrs, arg_lens, _arg_bufs, flattened_args = build_command_args(args)
+        keys_ptrs, keys_lens, _keys_bufs, flattened_keys = build_command_args(keys)
 
         route = ""
         route_buf = FFI::MemoryPointer.from_string(route)
@@ -285,10 +290,10 @@ class Valkey
             @connection,
             0,
             sha,
-            keys.size,
+            flattened_keys.size,
             keys_ptrs,
             keys_lens,
-            args.size,
+            flattened_args.size,
             arg_ptrs,
             arg_lens,
             route_buf,

data/lib/valkey/commands/string_commands.rb

@@ -29,7 +29,7 @@ class Valkey
       # @param [Integer] decrement
       # @return [Integer] value after decrementing it
       def decrby(key, decrement)
-        send_command(RequestType::DECR_BY, [key, decrement])
+        send_command(RequestType::DECR_BY, [key, Integer(decrement)])
       end
 
       # Increment the integer value of a key by one.
@@ -54,7 +54,7 @@ class Valkey
       # @param [Integer] increment
       # @return [Integer] value after incrementing it
       def incrby(key, increment)
-        send_command(RequestType::INCR_BY, [key, increment])
+        send_command(RequestType::INCR_BY, [key, Integer(increment)])
       end
 
       # Increment the numeric value of a key by the given float number.
@@ -85,11 +85,16 @@ class Valkey
       #   - `:get => true`: Return the old string stored at key, or nil if key did not exist.
       # @return [String, Boolean] `"OK"` or true, false if `:nx => true` or `:xx => true`
       def set(key, value, ex: nil, px: nil, exat: nil, pxat: nil, nx: nil, xx: nil, keepttl: nil, get: nil)
-        args = [key, value]
-        args << "EX" << ex if ex
-        args << "PX" << px if px
-        args << "EXAT" << exat if exat
-        args << "PXAT" << pxat if pxat
+        # value.to_s (matching redis-rb): a non-String value (e.g. an Array,
+        # in test_set_and_get_with_non_string_value) must become ONE opaque
+        # value here, not get flattened as if it were a multi-value list -
+        # see build_command_args's flat_map fix for why this must happen
+        # before command_args is built, not be left to that generic layer.
+        args = [key, value.to_s]
+        args << "EX" << Integer(ex) if ex
+        args << "PX" << Integer(px) if px
+        args << "EXAT" << Integer(exat) if exat
+        args << "PXAT" << Integer(pxat) if pxat
         args << "NX" if nx
         args << "XX" if xx
         args << "KEEPTTL" if keepttl
@@ -110,7 +115,7 @@ class Valkey
       # @param [String] value
       # @return [String] `"OK"`
       def setex(key, ttl, value)
-        send_command(RequestType::SET_EX, [key, ttl, value])
+        send_command(RequestType::SET_EX, [key, Integer(ttl), value.to_s])
       end
 
       # Set the time to live in milliseconds of a key.
@@ -120,7 +125,7 @@ class Valkey
       # @param [String] value
       # @return [String] `"OK"`
       def psetex(key, ttl, value)
-        send_command(RequestType::PSET_EX, [key, Integer(ttl), value])
+        send_command(RequestType::PSET_EX, [key, Integer(ttl), value.to_s])
       end
 
       # Set the value of a key, only if the key does not exist.
@@ -136,7 +141,7 @@ class Valkey
         # other GLIDE bindings' existing contracts expect to keep returning a
         # plain 0/1 integer. Doing the conversion here keeps it scoped to this
         # one Ruby-level method - see hexists/hsetnx for the same pattern.
-        send_command(RequestType::SET_NX, [key, value], &Utils::Boolify)
+        send_command(RequestType::SET_NX, [key, value.to_s], &Utils::Boolify)
       end
 
       # Set one or more values.
@@ -259,7 +264,7 @@ class Valkey
       # @param [String] value
       # @return [Integer] length of the string after it was modified
       def setrange(key, offset, value)
-        send_command(RequestType::SET_RANGE, [key, offset, value])
+        send_command(RequestType::SET_RANGE, [key, Integer(offset), value.to_s])
       end
 
       # Get a substring of the string stored at key.
@@ -301,10 +306,10 @@ class Valkey
       # @return [String, nil] the value of key, or nil when key does not exist
       def getex(key, ex: nil, px: nil, exat: nil, pxat: nil, persist: false)
         args = [key]
-        args << "EX" << ex if ex
-        args << "PX" << px if px
-        args << "EXAT" << exat if exat
-        args << "PXAT" << pxat if pxat
+        args << "EX" << Integer(ex) if ex
+        args << "PX" << Integer(px) if px
+        args << "EXAT" << Integer(exat) if exat
+        args << "PXAT" << Integer(pxat) if pxat
         args << "PERSIST" if persist
 
         send_command(RequestType::GET_EX, args)

data/lib/valkey/commands/transaction_commands.rb

@@ -20,7 +20,17 @@ class Valkey
       #   single atomic batch once the block returns - GLIDE wraps them in a real
       #   MULTI/EXEC transaction internally. If the block raises, nothing has been
       #   sent to the server yet, so the exception simply propagates - there is no
-      #   transaction to discard.
+      #   transaction to discard. Each in-block command call returns a
+      #   {Valkey::Future} immediately; capture it and call `#value` on it once
+      #   the block has returned to read that command's own reply:
+      #
+      #   @example Capturing a per-command reply
+      #     future = nil
+      #     valkey.multi do |multi|
+      #       future = multi.incr("counter")
+      #       multi.expire("counter", 60)
+      #     end
+      #     future.value # => 6
       # @yieldparam [Valkey::Pipeline] multi collects the block's commands
       #
       # @return [Array<...>]
@@ -31,11 +41,19 @@ class Valkey
       def multi
         if block_given?
           pipeline = Pipeline.new
-          yield pipeline
 
-          return [] if pipeline.commands.empty?
+          begin
+            yield pipeline
+
+            return [] if pipeline.commands.empty?
 
-          send_batch_commands(pipeline.commands, exception: true, is_atomic: true)
+            results = send_batch_commands(pipeline.commands, exception: true, is_atomic: true)
+            pipeline.resolve_futures!(results)
+            results
+          rescue StandardError
+            pipeline.abort_futures!
+            raise
+          end
         else
           start_multi
           self

data/lib/valkey/future.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+class Valkey
+  # Raised by Future#value when the pipeline/multi block has not finished
+  # executing yet (e.g. called from inside the block itself).
+  class FutureNotReady < BaseError
+    def initialize(msg = "Value will be available once the pipeline executes.")
+      super
+    end
+  end
+
+  # Raised by Future#value when the owning pipeline/multi block raised (or a
+  # sequential MULTI/EXEC/DISCARD fallback batch failed partway through)
+  # before this command's slot could ever be resolved. Distinct from
+  # FutureNotReady (still a subclass, so `rescue FutureNotReady` still catches
+  # it) to give a much clearer diagnostic than "not ready yet" for something
+  # that in fact will never become ready.
+  class FutureAborted < FutureNotReady
+    def initialize(msg = "This pipeline/multi block raised (or a sequential " \
+                         "fallback batch failed partway through) before this " \
+                         "command's result could be resolved.")
+      super
+    end
+  end
+
+  # A placeholder for the reply to a command queued inside Valkey#pipelined
+  # or the block form of Valkey::Commands::TransactionCommands#multi.
+  #
+  # Deliberately a plain Object, not BasicObject (unlike redis-rb's
+  # Redis::Future): #value is always called explicitly by callers, never as a
+  # transparent proxy, so BasicObject's stripped-down method surface buys
+  # nothing here.
+  #
+  # Coercion (Utils::Boolify, etc.) is intentionally not duplicated here: by
+  # the time Pipeline#resolve_futures! calls #_set, send_batch_commands has
+  # already applied it to the corresponding results[i].
+  class Future
+    NOT_READY = Object.new.freeze
+    private_constant :NOT_READY
+
+    def initialize(command_type, command_args)
+      @command_type = command_type
+      @command_args = command_args
+      @object = NOT_READY
+      @aborted = false
+    end
+
+    # @api private
+    def _set(object)
+      @object = object
+    end
+
+    # @api private
+    def _abort!
+      @aborted = true if @object.equal?(NOT_READY)
+    end
+
+    # @return [Boolean] whether #value can be called right now without
+    #   raising FutureNotReady/FutureAborted.
+    def ready?
+      !@aborted && !@object.equal?(NOT_READY)
+    end
+
+    # @return [Object] the resolved reply, already coerced the same way a
+    #   live (non-pipelined) call to the same command would be.
+    # @raise [FutureAborted] if the owning pipeline never got to resolve this
+    #   command (block raised, or the batch failed partway through)
+    # @raise [FutureNotReady] if called before the pipeline/multi block has
+    #   returned and its batch has been sent
+    # @raise [CommandError] if this slot's reply was itself an inline error
+    #   (e.g. WRONGTYPE inside a batch) - matches Valkey#convert_response's
+    #   "no rollback on runtime error" semantics.
+    def value
+      raise FutureAborted if @aborted
+      raise FutureNotReady if @object.equal?(NOT_READY)
+      raise @object if @object.is_a?(StandardError)
+
+      @object
+    end
+
+    def inspect
+      "#<Valkey::Future #{@command_type.inspect} #{@command_args.inspect}>"
+    end
+  end
+end

data/lib/valkey/pipeline.rb

@@ -4,10 +4,11 @@ class Valkey
   class Pipeline
     include Commands
 
-    attr_reader :commands
+    attr_reader :commands, :futures
 
     def initialize
       @commands = []
+      @futures = []
       # Keep transactional state consistent with the main client so that
       # helpers like `multi`/`exec` can safely consult `@in_multi`.
       @in_multi = false
@@ -15,6 +16,33 @@ class Valkey
 
     def send_command(command_type, command_args = [], &block)
       @commands << [command_type, command_args, block]
+      future = Future.new(command_type, command_args)
+      @futures << future
+      future
+    end
+
+    # @api private - called by Valkey#pipelined / the block form of #multi
+    # once send_batch_commands' final results are available. Purely
+    # positional, mirroring send_batch_commands' own per-command block
+    # re-application - safe for both the real-batch and the sequential
+    # MULTI/EXEC/DISCARD fallback branch, since both produce the same
+    # shape/order of results.
+    #
+    # `results` is `nil` when a watched key was modified, aborting the whole
+    # transaction server-side before any queued command actually ran - none
+    # of these futures were ever really resolved, so treat it the same as
+    # abort_futures! instead of raising NoMethodError on a nil index.
+    def resolve_futures!(results)
+      return abort_futures! if results.nil?
+
+      @futures.each_with_index { |future, i| future._set(results[i]) }
+    end
+
+    # @api private - called when an exception escapes pipelined/multi before
+    # resolve_futures! ran, so every still-unresolved future raises a clear
+    # FutureAborted instead of hanging on FutureNotReady forever.
+    def abort_futures!
+      @futures.each(&:_abort!)
     end
   end
 end

data/lib/valkey/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Valkey
-  VERSION = "0.9.2"
+  VERSION = "0.9.3-rc1"
 end

data/lib/valkey.rb

@@ -13,6 +13,7 @@ require "valkey/bindings"
 require "valkey/utils"
 require "valkey/commands"
 require "valkey/errors"
+require "valkey/future"
 require "valkey/pubsub_callback"
 require "valkey/pipeline"
 require "valkey/opentelemetry"
@@ -26,11 +27,18 @@ class Valkey
   def pipelined(exception: true)
     pipeline = Pipeline.new
 
-    yield pipeline
+    begin
+      yield pipeline
 
-    return [] if pipeline.commands.empty?
+      return [] if pipeline.commands.empty?
 
-    send_batch_commands(pipeline.commands, exception: exception)
+      results = send_batch_commands(pipeline.commands, exception: exception)
+      pipeline.resolve_futures!(results)
+      results
+    rescue StandardError
+      pipeline.abort_futures!
+      raise
+    end
   end
 
   def initialize(options = {})
@@ -377,8 +385,9 @@ class Valkey
       arg_ptrs.put_pointer(0, FFI::MemoryPointer.new(1))
       arg_lens.put_ulong(0, 0)
       _buffers = [] # nothing to keep alive
+      flattened_args = command_args
     else
-      arg_ptrs, arg_lens, _buffers = build_command_args(command_args)
+      arg_ptrs, arg_lens, _buffers, flattened_args = build_command_args(command_args)
     end
 
     # Create OpenTelemetry span if sampling is enabled, as a child of the app's current
@@ -410,7 +419,7 @@ class Valkey
           @connection,
           channel,
           command_type,
-          command_args.size,
+          flattened_args.size,
           arg_ptrs,
           arg_lens,
           route_info.to_ptr,
@@ -426,7 +435,7 @@ class Valkey
           @connection,
           channel,
           command_type,
-          command_args.size,
+          flattened_args.size,
           arg_ptrs,
           arg_lens,
           route_buf,
@@ -497,12 +506,12 @@ class Valkey
     buffers = [] # Keep references to prevent GC
 
     commands.each do |command_type, command_args, block|
-      arg_ptrs, arg_lens, arg_bufs = build_command_args(command_args)
+      arg_ptrs, arg_lens, arg_bufs, flattened_args = build_command_args(command_args)
 
       cmd = Bindings::CmdInfo.new
       cmd[:request_type] = command_type
       cmd[:args] = arg_ptrs
-      cmd[:arg_count] = command_args.size
+      cmd[:arg_count] = flattened_args.size
       cmd[:args_len] = arg_lens
 
       cmds << cmd
@@ -572,8 +581,12 @@ class Valkey
       end
     end
 
+    # An inline error slot (see the ResponseType::ERROR case in
+    # convert_response above) must be left alone here - e.g. Utils::Boolify
+    # would otherwise silently coerce a CommandError object to `true`
+    # (`value != 0` is true for any non-numeric object), hiding the error.
     blocks.each_with_index do |block, i|
-      results[i] = block.call(results[i]) if block
+      results[i] = block.call(results[i]) if block && !results[i].is_a?(CommandError)
     end
 
     results
@@ -601,25 +614,43 @@ class Valkey
     { "manual_interval" => { "duration_in_sec" => duration_in_sec } }
   end
 
+  # Builds the FFI arg_ptrs/arg_lens/buffers for command_args, flattening nested
+  # Array/Hash elements first (mirroring redis-client's CommandBuilder#generate)
+  # so callers like hset(key, [field, value]) serialize correctly instead of
+  # collapsing into one garbled Array#to_s/Hash#to_s string. Returns the
+  # flattened command_args too - callers must size arg_count off this returned
+  # array, not their original pre-flatten one, or arg_count goes out of sync
+  # with arg_ptrs/arg_lens. Each element's type is checked against the same
+  # allow-list redis-client's CommandBuilder#generate uses (String, Symbol,
+  # Integer, Float) - anything else, including nil, raises TypeError instead
+  # of being silently coerced via #to_s (e.g. nil.to_s => "").
   def build_command_args(command_args)
+    # Flatten nested Arrays/Hashes to match redis-client's behavior.
+    command_args = command_args.flat_map { |el| el.is_a?(Hash) ? el.flatten : el }
+
     # For empty arrays, pass NULL pointers as per Rust FFI contract
     # This matches Go's approach which successfully uses nil pointers
-    return [FFI::Pointer::NULL, FFI::Pointer::NULL, []] if command_args.empty?
+    return [FFI::Pointer::NULL, FFI::Pointer::NULL, [], []] if command_args.empty?
 
     arg_ptrs = FFI::MemoryPointer.new(:pointer, command_args.size)
     arg_lens = FFI::MemoryPointer.new(:ulong, command_args.size)
     buffers = []
 
     command_args.each_with_index do |arg, i|
-      arg = arg.to_s # Ensure we convert to string
-
-      buf = FFI::MemoryPointer.from_string(arg.to_s)
+      arg = case arg
+            when String, Symbol, Integer, Float
+              arg.to_s
+            else
+              raise TypeError, "Unsupported command argument type: #{arg.class}"
+            end
+
+      buf = FFI::MemoryPointer.from_string(arg)
       buffers << buf # prevent garbage collection
       arg_ptrs.put_pointer(i * FFI::Pointer.size, buf)
       arg_lens.put_ulong(i * 8, arg.bytesize)
     end
 
-    [arg_ptrs, arg_lens, buffers]
+    [arg_ptrs, arg_lens, buffers, command_args]
   end
 
   def convert_response(res, return_map_as_hash: false, &block)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: valkey-glide-rb
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.9.3.pre.rc1
 platform: ruby
 authors:
 - Valkey GLIDE Maintainers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-22 00:00:00.000000000 Z
+date: 2026-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -40,6 +40,7 @@ files:
 - README.md
 - Rakefile
 - THIRD_PARTY_LICENSES_RUBY
+- docker/manylinux2014/Dockerfile
 - examples/README.md
 - examples/cluster.rb
 - examples/opentelemetry.rb
@@ -70,6 +71,7 @@ files:
 - lib/valkey/commands/transaction_commands.rb
 - lib/valkey/commands/vector_search_commands.rb
 - lib/valkey/errors.rb
+- lib/valkey/future.rb
 - lib/valkey/native/aarch64-apple-darwin/libglide_ffi.dylib
 - lib/valkey/native/aarch64-unknown-linux-gnu/libglide_ffi.so
 - lib/valkey/native/aarch64-unknown-linux-musl/libglide_ffi.so