redis-client 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f09f4bc8f3f2cf92a6beb3b02ef601209bc36073eee68e4d57c93f802b10db2f
-  data.tar.gz: c3539ba4db69fac8a98649e27125409feb62d925b55a2c03bc75e87d26e60a89
+  metadata.gz: '097ad5acec4f5ea01788629c3fe2c606e54c1a2a0749c4e489487cf6bd446eae'
+  data.tar.gz: 275d778806cb7848d99ddcba33f1e932853efc9f0d149d6409692d1b39452d86
 SHA512:
-  metadata.gz: '08bbfce855729654d6f74830a18a6aaea755f4790c58ccf92cc53ac321a6a3ca4d5935a885498c89d48d781b5affc16e757524e7d1f2355da57b5048ca968528'
-  data.tar.gz: aac332fe44444ac5afdf5b23ba35e23dc3129a50c5c9c51628f24d151620c26108984574decd5ab25435f39ee305cf4933ab0413aaad7076cf525503c9ec50d3
+  metadata.gz: c553d706fe8b955a0c6b65a28e9d6a1ddcdec156a562ec5092396a0bca9fa72a251441b8675484fff2d4db3d8e2f335043d226bb4c9c3359e84acc9b7605543f
+  data.tar.gz: 68dcc5d81b1632dd60d22651d0ef600903fe607230d3ac396d5e98aab7694d374d5e577777234d7e514fc4df04b332e0fdb31b3c9971fb116c6b0e87c1ddc5f5

data/.rubocop.yml

@@ -7,6 +7,7 @@ Layout/LineLength:
   Max: 120
   Exclude:
     - 'test/**/*'
+    - 'benchmark/**/*'
 
 Layout/CaseIndentation:
   EnforcedStyle: end

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Unreleased
 
+# 0.3.0
+
+- `hiredis` is now the default driver when available.
+- Add `RedisClient.default_driver=`.
+- `#call` now takes an optional block to cast the return value.
+- Treat `#call` keyword arguments as Redis flags.
+- Fix `RedisClient#multi` returning some errors as values instead of raising them.
+
 # 0.2.1
 
 - Use a more robust way to detect the current compiler.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    redis-client (0.2.1)
+    redis-client (0.3.0)
       connection_pool
 
 GEM
@@ -64,4 +64,4 @@ DEPENDENCIES
   toxiproxy
 
 BUNDLED WITH
-   2.3.8
+   2.3.13

data/README.md

@@ -145,19 +145,68 @@ redis.call("LPUSH", "list", "1", "2", "3", "4")
 Hashes are flatenned as well:
 
 ```ruby
-redis.call("HMSET", "hash", foo: 1, bar: 2)
-redis.call("SET", "key", "value", ex: 5)
+redis.call("HMSET", "hash", { "foo" => "1", "bar" => "2" })
 ```
 
 is equivalent to:
 
 ```ruby
 redis.call("HMSET", "hash", "foo", "1", "bar", "2")
-redis.call("SET", "key", "value", "ex", "5")
 ```
 
 Any other type requires the caller to explictly cast the argument as a string.
 
+Keywords arguments are treated as Redis command flags:
+
+```ruby
+redis.call("SET", "mykey", "value", nx: true, ex: 60)
+redis.call("SET", "mykey", "value", nx: false, ex: nil)
+```
+
+is equivalent to:
+
+```ruby
+redis.call("SET", "mykey", "value", "nx", "ex", "60")
+redis.call("SET", "mykey", "value")
+```
+
+If flags are built dynamically, you'll have to explictly pass them as keyword arguments with `**`:
+
+```ruby
+flags = {}
+flags[:nx] = true if something?
+redis.call("SET", "mykey", "value", **flags)
+```
+
+**Important Note**: because of the keyword argument semantic change between Ruby 2 and Ruby 3,
+unclosed hash literals with string keys may be interpreted differently:
+
+```ruby
+redis.call("HMSET", "hash", "foo" => "bar")
+```
+
+On Ruby 2 `"foo" => "bar"` will be passed as a postional argument, but on Ruby 3 it will be interpreted as keyword
+arguments. To avoid such problem, make sure to enclose hash literals:
+
+```ruby
+redis.call("HMSET", "hash", { "foo" => "bar" })
+```
+
+### Commands return values
+
+Contrary to the `redis` gem, `redis-client` doesn't do any type casting on the return value of commands.
+
+If you wish to cast the return value, you can pass a block to the `#call` familly of methods:
+
+```ruby
+redis.call("INCR", "counter") # => 1
+redis.call("GET", "counter") # => "1"
+redis.call("GET", "counter", &:to_i) # => 1
+
+redis.call("EXISTS", "counter") # => 1
+redis.call("EXISTS", "counter") { |c| c > 0 } # => true
+```
+
 ### Blocking commands
 
 For blocking commands such as `BRPOP`, a custom timeout duration can be passed as first argument of the `#blocking_call` method:
@@ -338,6 +387,24 @@ redis.call("GET", "counter") # Will be retried up to 3 times.
 redis.call_once("INCR", "counter") # Won't be retried.
 ```
 
+### Drivers
+
+`redis-client` ships with two connection implementations, a `hiredis` binding and a pure Ruby implementation.
+
+The hiredis binding is only available on Linux, macOS and other POSIX platforms. When available it is the default.
+
+The default driver can be set through `RedisClient.default_driver=`:
+
+```ruby
+RedisClient.default_driver = :ruby
+```
+
+You can also select the driver on a per connection basis:
+
+```ruby
+redis_config = RedisClient.config(driver: :ruby, ...)
+```
+
 ## Notable differences with the `redis` gem
 
 ### Thread Safety

data/Rakefile

@@ -24,6 +24,7 @@ end
 
 namespace :test do
   Rake::TestTask.new(:sentinel) do |t|
+    t.libs << "test/sentinel"
     t.libs << "test"
     t.libs << "lib"
     t.test_files = FileList["test/sentinel/*_test.rb"]
@@ -57,7 +58,7 @@ namespace :benchmark do
           env = {}
           args = []
           args << "--yjit" if mode == :yjit
-          env["DRIVER"] = "hiredis" if mode == :hiredis
+          env["DRIVER"] = mode == :hiredis ? "hiredis" : "ruby"
           system(env, RbConfig.ruby, *args, "benchmark/#{suite}.rb", out: output)
         end
 

data/ext/redis_client/hiredis/extconf.rb

@@ -31,16 +31,28 @@ if RUBY_ENGINE == "ruby" && !RUBY_ENGINE.match?(/mswin/)
   end
 
   Dir.chdir(hiredis_dir) do
-    flags = %(CFLAGS="-I#{openssl_include}" SSL_LDFLAGS="-L#{openssl_lib}") if openssl_lib
-    success = system("#{make_program} static USE_SSL=1 #{flags}")
-    raise "Building hiredis failed" unless success
+    flags = ["static", "USE_SSL=1"]
+    if openssl_lib
+      flags << %(CFLAGS="-I#{openssl_include}") << %(SSL_LDFLAGS="-L#{openssl_lib}")
+    end
+
+    flags << "OPTIMIZATION=-g" if ENV["EXT_PEDANTIC"]
+
+    unless system(make_program, *flags)
+      raise "Building hiredis failed"
+    end
   end
 
   $CFLAGS << " -I#{hiredis_dir}"
   $LDFLAGS << " -lssl -lcrypto"
   $libs << " #{hiredis_dir}/libhiredis.a #{hiredis_dir}/libhiredis_ssl.a "
-  $CFLAGS << " -O3"
   $CFLAGS << " -std=c99 "
+  if ENV["EXT_PEDANTIC"]
+    $CFLAGS << " -Werror"
+    $CFLAGS << " -g "
+  else
+    $CFLAGS << " -O3 "
+  end
 
   if `cc --version`.match?(/ clang /i) || RbConfig::CONFIG['CC'].match?(/clang/i)
     $LDFLAGS << ' -Wl,-exported_symbols_list,"' << File.join(__dir__, 'export.clang') << '"'
@@ -48,10 +60,6 @@ if RUBY_ENGINE == "ruby" && !RUBY_ENGINE.match?(/mswin/)
     $LDFLAGS << ' -Wl,--version-script="' << File.join(__dir__, 'export.gcc') << '"'
   end
 
-  if ENV["EXT_PEDANTIC"]
-    $CFLAGS << " -Werror"
-  end
-
   $CFLAGS << " -Wno-declaration-after-statement" # Older compilers
   $CFLAGS << " -Wno-compound-token-split-by-macro" # Older rubies on macos
 

data/lib/redis_client/command_builder.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+class RedisClient
+  module CommandBuilder
+    extend self
+
+    if Symbol.method_defined?(:name)
+      def generate!(args, kwargs)
+        command = args.flat_map do |element|
+          case element
+          when Hash
+            element.flatten
+          when Set
+            element.to_a
+          else
+            element
+          end
+        end
+
+        kwargs.each do |key, value|
+          if value
+            if value == true
+              command << key.name
+            else
+              command << key.name << value
+            end
+          end
+        end
+
+        command.map! do |element|
+          case element
+          when String
+            element
+          when Symbol
+            element.name
+          when Integer, Float
+            element.to_s
+          else
+            raise TypeError, "Unsupported command argument type: #{element.class}"
+          end
+        end
+
+        command
+      end
+    else
+      def generate!(args, kwargs)
+        command = args.flat_map do |element|
+          case element
+          when Hash
+            element.flatten
+          when Set
+            element.to_a
+          else
+            element
+          end
+        end
+
+        kwargs.each do |key, value|
+          if value
+            if value == true
+              command << key.to_s
+            else
+              command << key.to_s << value
+            end
+          end
+        end
+
+        command.map! do |element|
+          case element
+          when String
+            element
+          when Integer, Float, Symbol
+            element.to_s
+          else
+            raise TypeError, "Unsupported command argument type: #{element.class}"
+          end
+        end
+
+        command
+      end
+    end
+  end
+end

data/lib/redis_client/config.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "openssl"
 require "uri"
 
 class RedisClient
@@ -11,7 +12,7 @@ class RedisClient
     DEFAULT_DB = 0
 
     module Common
-      attr_reader :db, :username, :password, :id, :ssl, :ssl_params,
+      attr_reader :db, :username, :password, :id, :ssl, :ssl_params, :command_builder,
         :connect_timeout, :read_timeout, :write_timeout, :driver, :connection_prelude
 
       alias_method :ssl?, :ssl
@@ -27,7 +28,8 @@ class RedisClient
         connect_timeout: timeout,
         ssl: nil,
         ssl_params: nil,
-        driver: :ruby,
+        driver: nil,
+        command_builder: CommandBuilder,
         reconnect_attempts: false
       )
         @username = username || DEFAULT_USERNAME
@@ -41,17 +43,9 @@ class RedisClient
         @read_timeout = read_timeout
         @write_timeout = write_timeout
 
-        @driver = case driver
-        when :ruby
-          Connection
-        when :hiredis
-          unless defined?(RedisClient::HiredisConnection)
-            require "redis_client/hiredis_connection"
-          end
-          HiredisConnection
-        else
-          raise ArgumentError, "Unknown driver #{driver.inspect}, expected one of: `:ruby`, `:hiredis`"
-        end
+        @driver = driver ? RedisClient.driver(driver) : RedisClient.default_driver
+
+        @command_builder = command_builder
 
         reconnect_attempts = Array.new(reconnect_attempts, 0).freeze if reconnect_attempts.is_a?(Integer)
         @reconnect_attempts = reconnect_attempts
@@ -84,41 +78,8 @@ class RedisClient
         false
       end
 
-      def hiredis_ssl_context
-        @hiredis_ssl_context ||= HiredisConnection::SSLContext.new(
-          ca_file: @ssl_params[:ca_file],
-          ca_path: @ssl_params[:ca_path],
-          cert: @ssl_params[:cert],
-          key: @ssl_params[:key],
-          hostname: @ssl_params[:hostname],
-        )
-      end
-
-      def openssl_context
-        @openssl_context ||= begin
-          params = @ssl_params.dup || {}
-
-          cert = params[:cert]
-          if cert.is_a?(String)
-            cert = File.read(cert) if File.exist?(cert)
-            params[:cert] = OpenSSL::X509::Certificate.new(cert)
-          end
-
-          key = params[:key]
-          if key.is_a?(String)
-            key = File.read(key) if File.exist?(key)
-            params[:key] = OpenSSL::PKey.read(key)
-          end
-
-          context = OpenSSL::SSL::SSLContext.new
-          context.set_params(params)
-          if context.verify_mode != OpenSSL::SSL::VERIFY_NONE
-            if context.respond_to?(:verify_hostname) # Missing on JRuby
-              context.verify_hostname
-            end
-          end
-          context
-        end
+      def ssl_context
+        @ssl_context ||= @driver.ssl_context(@ssl_params)
       end
 
       private

data/lib/redis_client/connection_mixin.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class RedisClient
+  module ConnectionMixin
+    def call(command, timeout)
+      write(command)
+      result = read(timeout)
+      if result.is_a?(CommandError)
+        raise result
+      else
+        result
+      end
+    end
+
+    def call_pipelined(commands, timeouts)
+      exception = nil
+
+      size = commands.size
+      results = Array.new(commands.size)
+      write_multi(commands)
+
+      size.times do |index|
+        timeout = timeouts && timeouts[index]
+        result = read(timeout)
+        if result.is_a?(CommandError)
+          exception ||= result
+        end
+        results[index] = result
+      end
+
+      if exception
+        raise exception
+      else
+        results
+      end
+    end
+  end
+end

data/lib/redis_client/decorator.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+class RedisClient
+  module Decorator
+    class << self
+      def create(commands_mixin)
+        client_decorator = Class.new(Client)
+        client_decorator.include(commands_mixin)
+
+        pipeline_decorator = Class.new(Pipeline)
+        pipeline_decorator.include(commands_mixin)
+        client_decorator.const_set(:Pipeline, pipeline_decorator)
+
+        client_decorator
+      end
+    end
+
+    module CommandsMixin
+      def initialize(client)
+        @client = client
+      end
+
+      %i(call call_once blocking_call).each do |method|
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def #{method}(*args, &block)
+            @client.#{method}(*args, &block)
+          end
+          ruby2_keywords :#{method} if respond_to?(:ruby2_keywords, true)
+        RUBY
+      end
+    end
+
+    class Pipeline
+      include CommandsMixin
+    end
+
+    class Client
+      include CommandsMixin
+
+      def initialize(_client)
+        super
+        @_pipeline_class = self.class::Pipeline
+      end
+
+      def with(*args)
+        @client.with(*args) { |c| yield self.class.new(c) }
+      end
+      ruby2_keywords :with if respond_to?(:ruby2_keywords, true)
+
+      def pipelined
+        @client.pipelined { |p| yield @_pipeline_class.new(p) }
+      end
+
+      def multi(**kwargs)
+        @client.multi(**kwargs) { |p| yield @_pipeline_class.new(p) }
+      end
+
+      %i(close scan hscan sscan zscan).each do |method|
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def #{method}(*args, &block)
+            @client.#{method}(*args, &block)
+          end
+          ruby2_keywords :#{method} if respond_to?(:ruby2_keywords, true)
+        RUBY
+      end
+
+      %i(id config size connect_timeout read_timeout write_timeout).each do |reader|
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def #{reader}
+            @client.#{reader}
+          end
+        RUBY
+      end
+
+      %i(timeout connect_timeout read_timeout write_timeout).each do |writer|
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def #{writer}=(value)
+            @client.#{writer} = value
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/redis_client/hiredis_connection.rb

@@ -1,10 +1,23 @@
 # frozen_string_literal: true
 
 require "redis_client/hiredis_connection.so"
+require "redis_client/connection_mixin"
 
 class RedisClient
   class HiredisConnection
-    include Connection::Common
+    include ConnectionMixin
+
+    class << self
+      def ssl_context(ssl_params)
+        HiredisConnection::SSLContext.new(
+          ca_file: ssl_params[:ca_file],
+          ca_path: ssl_params[:ca_path],
+          cert: ssl_params[:cert],
+          key: ssl_params[:key],
+          hostname: ssl_params[:hostname],
+        )
+      end
+    end
 
     class SSLContext
       def initialize(ca_file: nil, ca_path: nil, cert: nil, key: nil, hostname: nil)
@@ -26,7 +39,7 @@ class RedisClient
       end
 
       if config.ssl
-        init_ssl(config.hiredis_ssl_context)
+        init_ssl(config.ssl_context)
       end
     end
 

data/lib/redis_client/pooled.rb

@@ -49,40 +49,48 @@ class RedisClient
       pool.size
     end
 
-    %w(pipelined).each do |method|
-      class_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def #{method}(&block)
-          with { |r| r.#{method}(&block) }
-        end
-      RUBY
-    end
-
-    %w(multi).each do |method|
-      class_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def #{method}(**kwargs, &block)
-          with { |r| r.#{method}(**kwargs, &block) }
-        end
-      RUBY
-    end
+    methods = %w(pipelined multi pubsub call call_once blocking_call)
+    iterable_methods = %w(scan sscan hscan zscan)
+    begin
+      methods.each do |method|
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{method}(...)
+            with { |r| r.#{method}(...) }
+          end
+        RUBY
+      end
 
-    %w(call call_once blocking_call pubsub).each do |method|
-      class_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def #{method}(*args)
-          with { |r| r.#{method}(*args) }
-        end
-      RUBY
-    end
+      iterable_methods.each do |method|
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{method}(...)
+            unless block_given?
+              return to_enum(__callee__, ...)
+            end
 
-    %w(scan sscan hscan zscan).each do |method|
-      class_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def #{method}(*args, &block)
-          unless block_given?
-            return to_enum(__callee__, *args)
+            with { |r| r.#{method}(...) }
+          end
+        RUBY
+      end
+    rescue SyntaxError
+      methods.each do |method|
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{method}(*args, &block)
+            with { |r| r.#{method}(*args, &block) }
           end
+        RUBY
+      end
 
-          with { |r| r.#{method}(*args, &block) }
-        end
-      RUBY
+      iterable_methods.each do |method|
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{method}(*args, &block)
+            unless block_given?
+              return to_enum(__callee__, *args)
+            end
+
+            with { |r| r.#{method}(*args, &block) }
+          end
+        RUBY
+      end
     end
 
     private