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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17396d39342cbcc8a293f5e8b252e1689841b436664c630e330d06b0a1cff9c9
-  data.tar.gz: 7fa260b6afbb060a1c79a8dcb264aae5b211a24e69b042c720e242d39b7b3ab9
+  metadata.gz: 31e06a1cd3c0ecb6cd124d2d65c232cd080f5d5b9c3beaec4edac11ca8c9ddd4
+  data.tar.gz: a72a457f3533a2ee91c3b4d3a33633d4a5b19f73482c71fd6405c7c5229b3a1e
 SHA512:
-  metadata.gz: e96a09b0077bd54a30722201d03ccd8bb8baf7a47c0005d5c3d87441bfeb015479181548dce68bd1e882ee9e266be4658e68b2562e32dca6c48c101ca4e0e2cc
-  data.tar.gz: dbee972964d0a2e54dbf7f4916c2bab6427525ace1d97a679845409b9d55390419631c8407df7502ca9b3561bd51ea0bba1ebecd8bbef680cdaa45b5ba28f405
+  metadata.gz: 3f3384dfc9de4a87b7efd6464e2b724534339e2b56f748f4399283a290303ab54361f057c8069c19bb38ce29f621aa0056ac2f96975f81717c023bdf3a2c75fe
+  data.tar.gz: bb8378c230ffde26c7abe0f3755d002c5f2bd67e345b2e380036fd07b5b9731b61c7c61bf36d2302a559d33f769daaa86386986de0f69285839a5638235a7f75

data/lib/valkey/commands/scripting_commands.rb

@@ -137,22 +137,13 @@ class Valkey
       # @example Execute script that returns different data types
       #   valkey.eval("return {1, 'hello', true, nil}")
       #     # => [1, "hello", true, nil]
-      # @example Positional form, matching redis-rb's eval(script, keys, argv)
-      #   valkey.eval("return KEYS[1] .. ARGV[1]", ["mykey"], ["myarg"])
-      #     # => "mykeynyarg"
       # Since the eval is not available in the rust backend
       # using the load and invoke script
-      def eval(script, *rest, keys: nil, args: nil)
+      def eval(script, keys: [], args: [])
         # Validate script parameter
         raise ArgumentError, "script must be a string" unless script.is_a?(String)
         raise ArgumentError, "script cannot be empty" if script.empty?
 
-        # Accept redis-rb's flexible positional form - eval(script, keys, argv)
-        # - in addition to the keyword form, mirroring the same treatment
-        # applied to evalsha (see that method for the full rationale).
-        keys ||= rest[0] || []
-        args ||= rest[1] || []
-
         # Validate and convert keys and args to strings
         begin
           keys = Array(keys).map(&:to_s)
@@ -190,22 +181,13 @@ class Valkey
       #   rescue Valkey::CommandError => e
       #     puts "Script not found: #{e.message}"
       #   end
-      # @example Positional form, matching redis-rb's evalsha(sha, keys, argv)
-      #   valkey.evalsha(sha, ["user"], ["123"])
-      #     # => "user:123"
       # Since evalsha is not available in rust backend
       # using invoke script
-      def evalsha(sha, *rest, keys: nil, args: nil)
+      def evalsha(sha, keys: [], args: [])
         # Validate SHA1 hash parameter
         raise ArgumentError, "sha1 hash must be a string" unless sha.is_a?(String)
         raise ArgumentError, "sha1 hash must be a 40-character hexadecimal string" unless valid_sha1?(sha)
 
-        # Accept redis-rb's flexible positional form - evalsha(sha, keys, argv)
-        # - in addition to the keyword form, so code written against redis-rb's
-        # API (e.g. redis_display_id) doesn't need to special-case this client.
-        keys ||= rest[0] || []
-        args ||= rest[1] || []
-
         # Validate and convert keys and args to strings
         begin
           keys = Array(keys).map(&:to_s)

data/lib/valkey/commands/string_commands.rb

@@ -129,14 +129,7 @@ class Valkey
       # @param [String] value
       # @return [Boolean] whether the key was set or not
       def setnx(key, value)
-        # &Utils::Boolify (not glide-core's generic Boolean-coercion table) is
-        # deliberately used here: glide-core's per-command coercion is keyed by
-        # command name alone, so it can't distinguish this dedicated SETNX
-        # RequestType from a raw `customCommand(["SETNX", ...])` call, which
-        # 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])
       end
 
       # Set one or more values.

data/lib/valkey/commands/transaction_commands.rb

@@ -16,12 +16,8 @@ class Valkey
       #   end # => ["OK", 6]
       #
       # @yield [multi] the commands that are called inside this block are cached
-      #   locally (no server round-trip per command) and sent to the server as a
-      #   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.
-      # @yieldparam [Valkey::Pipeline] multi collects the block's commands
+      #   and written to the server upon returning from it
+      # @yieldparam [Valkey] multi `self`
       #
       # @return [Array<...>]
       #   - an array with replies
@@ -30,12 +26,17 @@ class Valkey
       # @see #unwatch
       def multi
         if block_given?
-          pipeline = Pipeline.new
-          yield pipeline
-
-          return [] if pipeline.commands.empty?
-
-          send_batch_commands(pipeline.commands, exception: true, is_atomic: true)
+          begin
+            @in_multi_block = true
+            start_multi
+            yield(self)
+            exec
+          rescue StandardError
+            discard
+            raise
+          ensure
+            @in_multi_block = false
+          end
         else
           start_multi
           self
@@ -113,12 +114,11 @@ class Valkey
       # @see #discard
       def exec
         if @in_multi
-          queued_commands = @queued_commands
           begin
             begin
               result = send_command(RequestType::EXEC)
               # If EXEC returns an error object (from array), it's already handled
-              result.is_a?(Array) ? reconvert_queued_replies(result, queued_commands) : result
+              result
             rescue CommandError => e
               # If EXEC itself raises an error (like when transaction is aborted),
               # return an array with the error to match expected behavior in tests
@@ -157,59 +157,8 @@ class Valkey
         @queued_commands = []
       end
 
-      # Commands whose reply is boolean when run standalone (via native return-type
-      # coercion server-side), but arrives as a raw 0/1 integer inside an EXEC array,
-      # since that coercion is keyed by the single command actually being run - which,
-      # for a queued command, is EXEC itself, not the original command.
-      #
-      # This list mirrors glide-core's own Boolean-coercion table in
-      # `value_conversion.rs::expected_type_for_cmd` (HEXISTS, HSETNX, EXPIRE, EXPIREAT,
-      # PEXPIRE, PEXPIREAT, SISMEMBER, PERSIST, SMOVE, PFADD, RENAMENX, MOVE, COPY,
-      # MSETNX, XGROUP DESTROY, XGROUP CREATECONSUMER) MINUS the commands whose Ruby
-      # method already passes its own explicit conversion block (`hexists`/`hsetnx`
-      # use `&Utils::Boolify`; `xgroup_destroy`/`xgroup_createconsumer` use a custom
-      # bool->int block). Those are already handled correctly by the `if block`
-      # branch below, before this list is even consulted - listing them here too
-      # would be redundant, not wrong. Every RequestType below calls `send_command`
-      # with NO block at all, so this static list is the only place their boolean-ness
-      # is recorded.
-      #
-      # NOTE: SETNX is deliberately NOT in glide-core's coercion table (and so isn't
-      # here as a "no block" entry either) - it's `redis-rb`-style boolean-ness only,
-      # not something the server/`glide-core` treats as boolean, since coercion there
-      # is keyed by command name alone and can't distinguish this dedicated RequestType
-      # from a raw `customCommand(["SETNX", ...])` call, which other bindings' existing
-      # contracts expect to keep returning a plain integer. `setnx`'s own Ruby method
-      # passes `&Utils::Boolify` directly instead - see string_commands.rb - so it's
-      # already covered by the `if block` branch, same as hexists/hsetnx.
-      BOOLEAN_REQUEST_TYPES = [
-        RequestType::EXPIRE, RequestType::EXPIRE_AT, RequestType::PEXPIRE, RequestType::PEXPIRE_AT,
-        RequestType::PERSIST, RequestType::SISMEMBER, RequestType::S_MOVE, RequestType::PFADD,
-        RequestType::RENAME_NX, RequestType::MOVE, RequestType::COPY, RequestType::MSET_NX
-      ].freeze
-
       private
 
-      # Re-applies each queued command's own reply conversion (e.g. `&Utils::Boolify`)
-      # to EXEC's raw array, since redis-rb's Future-based design does the equivalent
-      # (a Future remembers its conversion and re-applies it once EXEC resolves), but
-      # queued commands here go through the plain single-command path with no such
-      # memory - see BOOLEAN_REQUEST_TYPES above for the case with no explicit block.
-      def reconvert_queued_replies(result, queued_commands)
-        return result unless result.size == queued_commands.size
-
-        result.each_with_index.map do |value, i|
-          command_type, _args, block = queued_commands[i]
-          if block
-            block.call(value)
-          elsif BOOLEAN_REQUEST_TYPES.include?(command_type)
-            Utils::Boolify.call(value)
-          else
-            value
-          end
-        end
-      end
-
       # Start a MULTI block if one isn't already active.
       #
       # This mirrors the behaviour of popular Valkey/Redis clients where

data/lib/valkey/version.rb

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

data/lib/valkey.rb

@@ -457,9 +457,7 @@ class Valkey
         RequestType::MULTI, RequestType::EXEC, RequestType::DISCARD,
         RequestType::WATCH, RequestType::UNWATCH
       ]
-      if !tx_commands.include?(command_type) && result == "QUEUED"
-        @queued_commands << [command_type, command_args.dup, block]
-      end
+      @queued_commands << [command_type, command_args.dup] if !tx_commands.include?(command_type) && result == "QUEUED"
     end
 
     result
@@ -467,29 +465,23 @@ class Valkey
 
   private
 
-  def send_batch_commands(commands, exception: true, is_atomic: false)
+  def send_batch_commands(commands, exception: true)
     # WORKAROUND: The underlying Glide FFI backend has stability issues when
-    # batching LITERAL MULTI / EXEC / DISCARD commands (e.g. a `pipelined` block
-    # that manually calls `pipeline.multi`/`pipeline.exec`). To avoid native
-    # crashes we fall back to issuing those commands sequentially instead of via
-    # `Bindings.batch`. This never applies to a real `is_atomic: true` batch
-    # (see `multi`'s block form) - that path never contains literal MULTI/EXEC
-    # commands, since the server-side transaction wrapping is handled by GLIDE
-    # itself based on the `is_atomic` flag, not by commands in the list.
-    unless is_atomic
-      tx_types = [RequestType::MULTI, RequestType::EXEC, RequestType::DISCARD]
-
-      if commands.any? { |(command_type, _args, _block)| tx_types.include?(command_type) }
-        results = []
-
-        commands.each do |command_type, command_args, block|
-          res = send_command(command_type, command_args)
-          res = block.call(res) if block
-          results << res
-        end
-
-        return results
+    # batching transactional commands like MULTI / EXEC / DISCARD. To avoid
+    # native crashes we fall back to issuing those commands sequentially
+    # instead of via `Bindings.batch`.
+    tx_types = [RequestType::MULTI, RequestType::EXEC, RequestType::DISCARD]
+
+    if commands.any? { |(command_type, _args, _block)| tx_types.include?(command_type) }
+      results = []
+
+      commands.each do |command_type, command_args, block|
+        res = send_command(command_type, command_args)
+        res = block.call(res) if block
+        results << res
       end
+
+      return results
     end
 
     cmds = []
@@ -519,7 +511,7 @@ class Valkey
     batch_info = Bindings::BatchInfo.new
     batch_info[:cmd_count] = cmds.size
     batch_info[:cmds] = cmd_ptrs
-    batch_info[:is_atomic] = is_atomic
+    batch_info[:is_atomic] = false
 
     batch_options = Bindings::BatchOptionsInfo.new
     batch_options[:retry_server_error] = true
@@ -708,10 +700,7 @@ class Valkey
 
     response = convert_response.call(result)
 
-    # Don't run the caller's converter (e.g. Utils::Boolify) over the MULTI-queued
-    # "QUEUED" sentinel - send_command's own `result == "QUEUED"` check (used to
-    # track queued commands) needs to see the literal string, not e.g. `true`.
-    if block_given? && response != "QUEUED"
+    if block_given?
       block.call(response)
     else
       response

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: valkey-glide-rb
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 1.0.0.pre.rc1
 platform: ruby
 authors:
 - Valkey GLIDE Maintainers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-22 00:00:00.000000000 Z
+date: 2026-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi