redis-namespace 1.9.0 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88bd88ddb249a9424c8bcc002b84f097a96b4de6450944bc66096e6524115431
-  data.tar.gz: 1b9b4d59744b77a65ec523a77ea438de1f0923494a838c94a8c312893dce1fa6
+  metadata.gz: e003f4015162bfd465e79dd90e54b44ae46f0ec269118e10c08215d639166296
+  data.tar.gz: 16078b51e1bdab24977aa2b6fb7d0cd4761a7c41c340fcdacfb96dd32216c061
 SHA512:
-  metadata.gz: 2007d2f5396aec757c50d77de437dc01630b10de02eaeb852f7858233729476582036cf8214ba6e893f3e26b574c22169530a44bf9fb24c39fa2f2d5958e7ee5
-  data.tar.gz: af47dc4b2ce8357f8751c99ed71d05dc213a75a8092a3d54f016cef36b327967445b915bfaed32565639b0b2c16dbd02ef0026fbabcbf07c8965d3bb42b04f16
+  metadata.gz: fb965b575fe3ec2f2f45b99a71839f569f647681939b16576c053ab3e25bf85db1db030941bbe6eaeecc624eeeaf8c0497c58c53c4231440896e9e116bc189e3
+  data.tar.gz: 07b2b2e20c4a152b3e3a4cfbf6abad773f335e098067a9b213e29dd80cfc4519f3d27c43febe6cf8261ffe95e73184e23a1b9ff557007eb7a8308e43a398bbb1

data/lib/redis/namespace/version.rb

@@ -2,6 +2,6 @@
 
 class Redis
   class Namespace
-    VERSION = '1.9.0'
+    VERSION = '1.11.0'
   end
 end

data/lib/redis/namespace.rb

@@ -72,6 +72,7 @@ class Redis
       "exists?"          => [ :all ],
       "expire"           => [ :first ],
       "expireat"         => [ :first ],
+      "expiretime"       => [ :first ],
       "eval"             => [ :eval_style ],
       "evalsha"          => [ :eval_style ],
       "get"              => [ :first ],
@@ -122,6 +123,7 @@ class Redis
       "persist"          => [ :first ],
       "pexpire"          => [ :first ],
       "pexpireat"        => [ :first ],
+      "pexpiretime"      => [ :first ],
       "pfadd"            => [ :first ],
       "pfcount"          => [ :all ],
       "pfmerge"          => [ :all ],
@@ -138,6 +140,7 @@ class Redis
       "rpush"            => [ :first ],
       "rpushx"           => [ :first ],
       "sadd"             => [ :first ],
+      "sadd?"            => [ :first ],
       "scard"            => [ :first ],
       "scan"             => [ :scan_style, :second ],
       "scan_each"        => [ :scan_style, :all ],
@@ -158,6 +161,7 @@ class Redis
       "spop"             => [ :first ],
       "srandmember"      => [ :first ],
       "srem"             => [ :first ],
+      "srem?"            => [ :first ],
       "sscan"            => [ :first ],
       "sscan_each"       => [ :first ],
       "strlen"           => [ :first ],
@@ -202,6 +206,7 @@ class Redis
     HELPER_COMMANDS = {
       "auth"             => [],
       "disconnect!"      => [],
+      "close"            => [],
       "echo"             => [],
       "ping"             => [],
       "time"             => [],
@@ -238,6 +243,16 @@ class Redis
     # Support 1.8.7 by providing a namespaced reference to Enumerable::Enumerator
     Enumerator = Enumerable::Enumerator unless defined?(::Enumerator)
 
+    # This is used by the Redis gem to determine whether or not to display that deprecation message.
+    @sadd_returns_boolean = true
+
+    # This is used by the Redis gem to determine whether or not to display that deprecation message.
+    @srem_returns_boolean = true
+
+    class << self
+      attr_accessor :sadd_returns_boolean, :srem_returns_boolean
+    end
+
     attr_writer :namespace
     attr_reader :redis
     attr_accessor :warning
@@ -329,6 +344,32 @@ class Redis
     end
     ruby2_keywords(:eval) if respond_to?(:ruby2_keywords, true)
 
+    # This operation can run for a very long time if the namespace contains lots of keys!
+    # It should be used in tests, or when the namespace is small enough
+    # and you are sure you know what you are doing.
+    def clear
+      if warning?
+        warn("This operation can run for a very long time if the namespace contains lots of keys! " +
+             "It should be used in tests, or when the namespace is small enough " +
+             "and you are sure you know what you are doing.")
+      end
+
+      batch_size = 1000
+
+      if supports_scan?
+        cursor = "0"
+        begin
+          cursor, keys = scan(cursor, count: batch_size)
+          del(*keys) unless keys.empty?
+        end until cursor == "0"
+      else
+        all_keys = keys("*")
+        all_keys.each_slice(batch_size) do |keys|
+          del(*keys)
+        end
+      end
+    end
+
     ADMINISTRATIVE_COMMANDS.keys.each do |command|
       define_method(command) do |*args, &block|
         raise NoMethodError if deprecations?
@@ -371,7 +412,8 @@ class Redis
                "passthrough has been deprecated and will be removed in " +
                "redis-namespace 2.0 (at #{call_site})")
         end
-        @redis.send(command, *args, &block)
+
+        wrapped_send(@redis, command, args, &block)
       else
         super
       end
@@ -476,7 +518,7 @@ class Redis
       end
 
       # Dispatch the command to Redis and store the result.
-      result = @redis.send(command, *args, &block)
+      result = wrapped_send(@redis, command, args, &block)
 
       # Don't try to remove namespace from a Redis::Future, you can't.
       return result if result.is_a?(Redis::Future)
@@ -513,6 +555,16 @@ class Redis
       end
     end
 
+    def wrapped_send(redis_client, command, args = [], &block)
+      if redis_client.class.name == "ConnectionPool"
+        redis_client.with do |pool_connection|
+          pool_connection.send(command, *args, &block)
+        end
+      else
+        redis_client.send(command, *args, &block)
+      end
+    end
+
     # Avoid modifying the caller's (pass-by-reference) arguments.
     def clone_args(arg)
       if arg.is_a?(Array)
@@ -530,13 +582,10 @@ class Redis
 
     def namespaced_block(command, &block)
       if block.arity == 0
-        redis.send(command, &block)
+        wrapped_send(redis, command, &block)
       else
-        redis.send(command) do |r|
-          copy = dup
-          copy.redis = r
-          yield copy
-        end
+        outer_block = proc { |r| copy = dup; copy.redis = r; yield copy }
+        wrapped_send(redis, command, &outer_block)
       end
     end
 
@@ -582,5 +631,10 @@ class Redis
         Enumerator.new(&block)
       end
     end
+
+    def supports_scan?
+      redis_version = @redis.info["redis_version"]
+      Gem::Version.new(redis_version) >= Gem::Version.new("2.8.0")
+    end
   end
 end

data/spec/deprecation_spec.rb

@@ -31,7 +31,7 @@ describe Redis::Namespace do
     end
 
     before(:each) do
-      allow(redis).to receive(:unhandled) do |*args| 
+      allow(redis).to receive(:unhandled) do |*args|
         "unhandled(#{args.inspect})"
       end
       allow(redis).to receive(:flushdb).and_return("OK")

data/spec/redis_spec.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 
 require File.dirname(__FILE__) + '/spec_helper'
+require 'connection_pool'
 
 describe "redis" do
   @redis_version = Gem::Version.new(Redis.new.info["redis_version"])
@@ -184,6 +185,24 @@ describe "redis" do
     expect(@namespaced.mapped_mget('foo', 'baz', 'bar')).to eq({'foo'=>'1000', 'bar'=>'2000', 'baz' => nil})
   end
 
+  it "should utilize connection_pool while using a namespace with mget" do
+    memo = @namespaced
+    connection_pool = ConnectionPool.new(size: 2, timeout: 2) { Redis.new db: 15 }
+    @namespaced = Redis::Namespace.new(:ns, redis: connection_pool)
+
+    expect(connection_pool).to receive(:with).and_call_original do |arg|
+      expect(arg).to be(an_instance_of(Redis))
+    end.at_least(:once)
+
+    @namespaced.set('foo', 1000)
+    @namespaced.set('bar', 2000)
+    expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '1000', 'bar' => '2000' })
+    expect(@namespaced.mapped_mget('foo', 'baz', 'bar')).to eq({'foo'=>'1000', 'bar'=>'2000', 'baz' => nil})
+    @redis.get('foo').should eq('bar')
+
+    @namespaced = memo
+  end
+
   it "should be able to use a namespace with mset" do
     @namespaced.mset('foo', '1000', 'bar', '2000')
     expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '1000', 'bar' => '2000' })
@@ -339,6 +358,17 @@ describe "redis" do
     expect(values).to match_array(['banana', 'eggplant'])
   end
 
+  it "should add a new member" do
+    expect(@namespaced.sadd?('foo', 1)).to eq(true)
+    expect(@namespaced.sadd?('foo', 1)).to eq(false)
+  end
+
+  it "should remove members" do
+    @namespaced.sadd('foo', 1)
+    expect(@namespaced.srem?('foo', 1)).to eq(true)
+    expect(@namespaced.srem?('foo', 1)).to eq(false)
+  end
+
   it "should add namespace to sort" do
     @namespaced.sadd('foo', 1)
     @namespaced.sadd('foo', 2)
@@ -376,6 +406,26 @@ describe "redis" do
     expect(@namespaced.hgetall("foo")).to eq({"key1" => "value1"})
   end
 
+  it "should utilize connection_pool while adding namepsace to multi blocks" do
+    memo = @namespaced
+    connection_pool = ConnectionPool.new(size: 2, timeout: 2) { Redis.new db: 15 }
+    @namespaced = Redis::Namespace.new(:ns, redis: connection_pool)
+
+    expect(connection_pool).to receive(:with).and_call_original do |arg|
+      expect(arg).to be(an_instance_of(Redis))
+    end.at_least(:once)
+
+    @namespaced.mapped_hmset "foo", {"key" => "value"}
+    @namespaced.multi do |r|
+      r.del "foo"
+      r.mapped_hmset "foo", {"key1" => "value1"}
+    end
+    expect(@redis.get("foo")).to eq("bar")
+    expect(@namespaced.hgetall("foo")).to eq({"key1" => "value1"})
+
+    @namespaced = memo
+  end
+
   it "should pass through multi commands without block" do
     @namespaced.mapped_hmset "foo", {"key" => "value"}
 
@@ -387,6 +437,28 @@ describe "redis" do
     expect(@namespaced.hgetall("foo")).to eq({"key1" => "value1"})
   end
 
+  it "should utilize connection_pool while passing through multi commands without block" do
+    memo = @namespaced
+    connection_pool = ConnectionPool.new(size: 2, timeout: 2) { Redis.new db: 15 }
+    @namespaced = Redis::Namespace.new(:ns, redis: connection_pool)
+
+    expect(connection_pool).to receive(:with).and_call_original do |arg|
+      expect(arg).to be(an_instance_of(Redis))
+    end.at_least(:once)
+
+    @namespaced.mapped_hmset "foo", {"key" => "value"}
+
+    @namespaced.multi
+    @namespaced.del "foo"
+    @namespaced.mapped_hmset "foo", {"key1" => "value1"}
+    @namespaced.exec
+
+    expect(@namespaced.hgetall("foo")).to eq({"key1" => "value1"})
+    expect(@redis.get("foo")).to eq("bar")
+
+    @namespaced = memo
+  end
+
   it 'should return futures without attempting to remove namespaces' do
     @namespaced.multi do
       @future = @namespaced.keys('*')
@@ -403,6 +475,26 @@ describe "redis" do
     expect(@namespaced.hgetall("foo")).to eq({"key1" => "value1"})
   end
 
+  it "should utilize connection_pool while adding namespace to pipelined blocks" do
+    memo = @namespaced
+    connection_pool = ConnectionPool.new(size: 2, timeout: 2) { Redis.new db: 15 }
+    @namespaced = Redis::Namespace.new(:ns, redis: connection_pool)
+
+    expect(connection_pool).to receive(:with).and_call_original do |arg|
+      expect(arg).to be(an_instance_of(Redis))
+    end.at_least(:once)
+
+    @namespaced.mapped_hmset "foo", {"key" => "value"}
+    @namespaced.pipelined do |r|
+      r.del "foo"
+      r.mapped_hmset "foo", {"key1" => "value1"}
+    end
+    expect(@namespaced.hgetall("foo")).to eq({"key1" => "value1"})
+    expect(@redis.get("foo")).to eq("bar")
+
+    @namespaced = memo
+  end
+
   it "should returned response array from pipelined block" do
     @namespaced.mset "foo", "bar", "key", "value"
     result = @namespaced.pipelined do |r|
@@ -574,6 +666,12 @@ describe "redis" do
         expect(@redis.ttl("ns:foo")).to satisfy {|v| (0..1).include?(v) }
       end
 
+      it "should namespace expiretime" do
+        @namespaced.set('mykey', 'Hello')
+        @namespaced.expireat('mykey', 2000000000)
+        expect(@namespaced.expiretime('mykey')).to eq(2000000000)
+      end
+
       it "should namespace hincrbyfloat" do
         @namespaced.hset('mykey', 'field', 10.50)
         expect(@namespaced.hincrbyfloat('mykey', 'field', 0.1)).to eq(10.6)
@@ -606,6 +704,12 @@ describe "redis" do
         expect(@namespaced.pexpire('mykey', 1555555555005)).to eq(true)
       end
 
+      it "should namespace pexpiretime" do
+        @namespaced.set('mykey', 'Hello')
+        @namespaced.pexpireat('mykey', 2000000000000)
+        expect(@namespaced.pexpiretime('mykey')).to eq(2000000000000)
+      end
+
       it "should namespace psetex" do
         expect(@namespaced.psetex('mykey', 10000, 'Hello')).to eq('OK')
         expect(@namespaced.get('mykey')).to eq('Hello')
@@ -967,4 +1071,30 @@ describe "redis" do
       expect(sub_sub_namespaced.full_namespace).to eql("ns:sub1:sub2")
     end
   end
+
+  describe :clear do
+    it "warns with helpful output" do
+      expect { @namespaced.clear }.to output(/can run for a very long time/).to_stderr
+    end
+
+    it "should delete all the keys" do
+      @redis.set("foo", "bar")
+      @namespaced.mset("foo1", "bar", "foo2", "bar")
+      capture_stderr { @namespaced.clear }
+
+      expect(@redis.keys).to eq ["foo"]
+      expect(@namespaced.keys).to be_empty
+    end
+
+    it "should delete all the keys in older redis" do
+      allow(@redis).to receive(:info).and_return({ "redis_version" => "2.7.0" })
+
+      @redis.set("foo", "bar")
+      @namespaced.mset("foo1", "bar", "foo2", "bar")
+      capture_stderr { @namespaced.clear }
+
+      expect(@redis.keys).to eq ["foo"]
+      expect(@namespaced.keys).to be_empty
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-namespace
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.11.0
 platform: ruby
 authors:
 - Chris Wanstrath
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-13 00:00:00.000000000 Z
+date: 2023-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -70,6 +70,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
   Adds a Redis::Namespace class which can be used to namespace calls
   to Redis. This is useful when using a single instance of Redis with
@@ -99,8 +113,7 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/resque/redis-namespace/issues
   changelog_uri: https://github.com/resque/redis-namespace/blob/master/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/redis-namespace/1.9.0
-  source_code_uri: https://github.com/resque/redis-namespace/tree/v1.9.0
+  documentation_uri: https://www.rubydoc.info/gems/redis-namespace/1.11.0
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -117,7 +130,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: Namespaces Redis commands.