redis-namespace 1.7.0 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ebbb9000d7b34a0a8386ac9d72e2f63f4573720b22a8eb7e3676c0c1759200b
-  data.tar.gz: ec5c495b22e58cc98d4c759f7873f2d2f9f69c8205b750062207b6f4b1f45897
+  metadata.gz: e003f4015162bfd465e79dd90e54b44ae46f0ec269118e10c08215d639166296
+  data.tar.gz: 16078b51e1bdab24977aa2b6fb7d0cd4761a7c41c340fcdacfb96dd32216c061
 SHA512:
-  metadata.gz: e05aa113c14df634a64fdfad7891781ace6a5060a533e9417f94476235f3e05fd33859c4653fcbe8f417582e9257cdf20b1599ac1b2e4cbe38ccaf7c88af2dba
-  data.tar.gz: 220e3ec476e5613dd3a8529f2f7b30f7aba9433a1f4ab4402c55be555ef00ff5651738824ddc583e83e7cbad9297d1f1a107bd61e4b44df5e8c9efa50589cfea
+  metadata.gz: fb965b575fe3ec2f2f45b99a71839f569f647681939b16576c053ab3e25bf85db1db030941bbe6eaeecc624eeeaf8c0497c58c53c4231440896e9e116bc189e3
+  data.tar.gz: 07b2b2e20c4a152b3e3a4cfbf6abad773f335e098067a9b213e29dd80cfc4519f3d27c43febe6cf8261ffe95e73184e23a1b9ff557007eb7a8308e43a398bbb1

data/README.md

@@ -33,6 +33,13 @@ redis_connection.get('ns:foo')
 # => nil
 ```
 
+Redis::Namespace also supports `Proc` as a namespace and will take the result string as namespace at runtime.
+
+```ruby
+redis_connection = Redis.new
+namespaced_redis = Redis::Namespace.new(Proc.new { Tenant.current_tenant }, redis: redis_connection)
+```
+
 Installation
 ============
 
@@ -79,7 +86,7 @@ namespaced.redis.flushall()
 
 As mentioned above, 2.0 will remove blind passthrough and the administrative command passthrough.
 By default in 1.5+, deprecation warnings are present and enabled;
-they can be silenced by initializing `Redis::Namespace` with `warnings: false` or by setting the `REDIS_NAMESPACE_QUIET` environment variable.
+they can be silenced by initializing `Redis::Namespace` with `warning: false` or by setting the `REDIS_NAMESPACE_QUIET` environment variable.
 
 Early opt-in
 ------------

data/lib/redis/namespace/version.rb

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

data/lib/redis/namespace.rb

@@ -68,12 +68,15 @@ class Redis
       "decrby"           => [ :first ],
       "del"              => [ :all   ],
       "dump"             => [ :first ],
-      "exists"           => [ :first ],
+      "exists"           => [ :all ],
+      "exists?"          => [ :all ],
       "expire"           => [ :first ],
       "expireat"         => [ :first ],
+      "expiretime"       => [ :first ],
       "eval"             => [ :eval_style ],
       "evalsha"          => [ :eval_style ],
       "get"              => [ :first ],
+      "getex"            => [ :first ],
       "getbit"           => [ :first ],
       "getrange"         => [ :first ],
       "getset"           => [ :first ],
@@ -120,6 +123,7 @@ class Redis
       "persist"          => [ :first ],
       "pexpire"          => [ :first ],
       "pexpireat"        => [ :first ],
+      "pexpiretime"      => [ :first ],
       "pfadd"            => [ :first ],
       "pfcount"          => [ :all ],
       "pfmerge"          => [ :all ],
@@ -136,6 +140,7 @@ class Redis
       "rpush"            => [ :first ],
       "rpushx"           => [ :first ],
       "sadd"             => [ :first ],
+      "sadd?"            => [ :first ],
       "scard"            => [ :first ],
       "scan"             => [ :scan_style, :second ],
       "scan_each"        => [ :scan_style, :all ],
@@ -150,11 +155,13 @@ class Redis
       "sinterstore"      => [ :all ],
       "sismember"        => [ :first ],
       "smembers"         => [ :first ],
+      "smismember"       => [ :first ],
       "smove"            => [ :exclude_last ],
       "sort"             => [ :sort  ],
       "spop"             => [ :first ],
       "srandmember"      => [ :first ],
       "srem"             => [ :first ],
+      "srem?"            => [ :first ],
       "sscan"            => [ :first ],
       "sscan_each"       => [ :first ],
       "strlen"           => [ :first ],
@@ -199,6 +206,7 @@ class Redis
     HELPER_COMMANDS = {
       "auth"             => [],
       "disconnect!"      => [],
+      "close"            => [],
       "echo"             => [],
       "ping"             => [],
       "time"             => [],
@@ -235,13 +243,23 @@ 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
 
     def initialize(namespace, options = {})
       @namespace = namespace
-      @redis = options[:redis] || Redis.current
+      @redis = options[:redis] || Redis.new
       @warning = !!options.fetch(:warning) do
                    !ENV['REDIS_NAMESPACE_QUIET']
                  end
@@ -260,7 +278,7 @@ class Redis
     end
 
     def client
-      warn("The client method is deprecated as of redis-rb 4.0.0, please use the new _client" +
+      warn("The client method is deprecated as of redis-rb 4.0.0, please use the new _client " +
             "method instead. Support for the old method will be removed in redis-namespace 2.0.") if @has_new_client_method && deprecations?
       _client
     end
@@ -306,7 +324,7 @@ class Redis
                                    :redis => @redis)
       end
 
-      @namespace
+      @namespace.respond_to?(:call) ? @namespace.call : @namespace
     end
 
     def full_namespace
@@ -314,7 +332,7 @@ class Redis
     end
 
     def connection
-      @redis.connection.tap { |info| info[:namespace] = @namespace }
+      @redis.connection.tap { |info| info[:namespace] = namespace }
     end
 
     def exec
@@ -324,6 +342,33 @@ class Redis
     def eval(*args)
       call_with_namespace(:eval, *args)
     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|
@@ -339,6 +384,7 @@ class Redis
         end
         call_with_namespace(command, *args, &block)
       end
+      ruby2_keywords(command) if respond_to?(:ruby2_keywords, true)
     end
 
     COMMANDS.keys.each do |command|
@@ -348,6 +394,7 @@ class Redis
       define_method(command) do |*args, &block|
         call_with_namespace(command, *args, &block)
       end
+      ruby2_keywords(command) if respond_to?(:ruby2_keywords, true)
     end
 
     def method_missing(command, *args, &block)
@@ -365,15 +412,17 @@ 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
     end
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 
     def inspect
       "<#{self.class.name} v#{VERSION} with client v#{Redis::VERSION} "\
-      "for #{@redis.id}/#{@namespace}>"
+      "for #{@redis.id}/#{full_namespace}>"
     end
 
     def respond_to_missing?(command, include_all=false)
@@ -405,6 +454,7 @@ class Redis
       case before
       when :first
         args[0] = add_namespace(args[0]) if args[0]
+        args[-1] = ruby2_keywords_hash(args[-1]) if args[-1].is_a?(Hash)
       when :all
         args = add_namespace(args)
       when :exclude_first
@@ -417,13 +467,14 @@ class Redis
         args.push(last) if last
       when :exclude_options
         if args.last.is_a?(Hash)
-          last = args.pop
+          last = ruby2_keywords_hash(args.pop)
           args = add_namespace(args)
           args.push(last)
         else
           args = add_namespace(args)
         end
       when :alternate
+        args = args.flatten
         args.each_with_index { |a, i| args[i] = add_namespace(a) if i.even? }
       when :sort
         args[0] = add_namespace(args[0]) if args[0]
@@ -437,6 +488,7 @@ class Redis
           args[1][:get].each_index do |i|
             args[1][:get][i] = add_namespace(args[1][:get][i]) unless args[1][:get][i] == "#"
           end
+          args[1] = ruby2_keywords_hash(args[1])
         end
       when :eval_style
         # redis.eval() and evalsha() can either take the form:
@@ -457,7 +509,7 @@ class Redis
       when :scan_style
         options = (args.last.kind_of?(Hash) ? args.pop : {})
         options[:match] = add_namespace(options.fetch(:match, '*'))
-        args << options
+        args << ruby2_keywords_hash(options)
 
         if block
           original_block = block
@@ -466,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)
@@ -483,9 +535,36 @@ class Redis
 
       result
     end
+    ruby2_keywords(:call_with_namespace) if respond_to?(:ruby2_keywords, true)
+
+  protected
+
+    def redis=(redis)
+      @redis = redis
+    end
 
   private
 
+    if Hash.respond_to?(:ruby2_keywords_hash)
+      def ruby2_keywords_hash(kwargs)
+        Hash.ruby2_keywords_hash(kwargs)
+      end
+    else
+      def ruby2_keywords_hash(kwargs)
+        kwargs
+      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)
@@ -502,18 +581,16 @@ class Redis
     end
 
     def namespaced_block(command, &block)
-      redis.send(command) do |r|
-        begin
-          original, @redis = @redis, r
-          yield self
-        ensure
-          @redis = original
-        end
+      if block.arity == 0
+        wrapped_send(redis, command, &block)
+      else
+        outer_block = proc { |r| copy = dup; copy.redis = r; yield copy }
+        wrapped_send(redis, command, &outer_block)
       end
     end
 
     def add_namespace(key)
-      return key unless key && @namespace
+      return key unless key && namespace
 
       case key
       when Array
@@ -522,12 +599,12 @@ class Redis
         key.keys.each {|k| key[add_namespace(k)] = key.delete(k)}
         key
       else
-        "#{@namespace}:#{key}"
+        "#{namespace}:#{key}"
       end
     end
 
     def rem_namespace(key)
-      return key unless key && @namespace
+      return key unless key && namespace
 
       case key
       when Array
@@ -539,7 +616,7 @@ class Redis
           key.each { |k| yielder.yield rem_namespace(k) }
         end
       else
-        key.to_s.sub(/\A#{@namespace}:/, '')
+        key.to_s.sub(/\A#{namespace}:/, '')
       end
     end
 
@@ -554,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,30 +1,20 @@
 # encoding: utf-8
 
 require File.dirname(__FILE__) + '/spec_helper'
+require 'connection_pool'
 
 describe "redis" do
-  @redis_version = Gem::Version.new(Redis.current.info["redis_version"])
+  @redis_version = Gem::Version.new(Redis.new.info["redis_version"])
   let(:redis_client) { @redis.respond_to?(:_client) ? @redis._client : @redis.client}
 
-  before(:all) do
+  before(:each) do
     # use database 15 for testing so we dont accidentally step on your real data
     @redis = Redis.new :db => 15
-  end
-
-  before(:each) do
-    @namespaced = Redis::Namespace.new(:ns, :redis => @redis)
     @redis.flushdb
+    @namespaced = Redis::Namespace.new(:ns, :redis => @redis)
     @redis.set('foo', 'bar')
   end
 
-  after(:each) do
-    @redis.flushdb
-  end
-
-  after(:all) do
-    @redis.quit
-  end
-
   # redis-rb 3.3.4+
   it "should inject :namespace into connection info" do
     info = @redis.connection.merge(:namespace => :ns)
@@ -52,6 +42,17 @@ describe "redis" do
     expect(@namespaced.type('counter')).to eq('string')
   end
 
+  it "should work with Proc namespaces" do
+    namespace = Proc.new { :dynamic_ns }
+    namespaced = Redis::Namespace.new(namespace, redis: @redis)
+
+    expect(namespaced.get('foo')).to eq(nil)
+    namespaced.set('foo', 'chris')
+    expect(namespaced.get('foo')).to eq('chris')
+    @redis.set('foo', 'bob')
+    expect(@redis.get('foo')).to eq('bob')
+  end
+
   context 'when sending capital commands (issue 68)' do
     it 'should be able to use a namespace' do
       @namespaced.send('SET', 'fubar', 'quux')
@@ -106,6 +107,13 @@ describe "redis" do
     expect(@namespaced.lrange('bar',0,-1)).to eq(['bar'])
   end
 
+  it "should be able to use a namespace with getex" do
+    expect(@namespaced.set('mykey', 'Hello')).to eq('OK')
+    expect(@namespaced.getex('mykey', ex: 50)).to eq('Hello')
+    expect(@namespaced.get('mykey')).to eq('Hello')
+    expect(@namespaced.ttl('mykey')).to eq(50)
+  end
+
   it 'should be able to use a namespace with getbit' do
     @namespaced.set('foo','bar')
     expect(@namespaced.getbit('foo',1)).to eq(1)
@@ -140,10 +148,22 @@ describe "redis" do
 
   it 'should be able to use a namespace with setbit' do
     @namespaced.setbit('virgin_key', 1, 1)
-    expect(@namespaced.exists('virgin_key')).to be true
+    expect(@namespaced.exists?('virgin_key')).to be true
     expect(@namespaced.get('virgin_key')).to eq(@namespaced.getrange('virgin_key',0,-1))
   end
 
+  it 'should be able to use a namespace with exists' do
+    @namespaced.set('foo', 1000)
+    @namespaced.set('bar', 2000)
+    expect(@namespaced.exists('foo', 'bar')).to eq(2)
+  end
+
+  it 'should be able to use a namespace with exists?' do
+    @namespaced.set('foo', 1000)
+    @namespaced.set('bar', 2000)
+    expect(@namespaced.exists?('does_not_exist', 'bar')).to eq(true)
+  end
+
   it 'should be able to use a namespace with bitpos' do
     @namespaced.setbit('bit_map', 42, 1)
     expect(@namespaced.bitpos('bit_map', 0)).to eq(0)
@@ -165,19 +185,44 @@ 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' })
     expect(@namespaced.mapped_mget('foo', 'baz', 'bar')).to eq({ 'foo' => '1000', 'bar' => '2000', 'baz' => nil})
+
     @namespaced.mapped_mset('foo' => '3000', 'bar' => '5000')
     expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '3000', 'bar' => '5000' })
     expect(@namespaced.mapped_mget('foo', 'baz', 'bar')).to eq({ 'foo' => '3000', 'bar' => '5000', 'baz' => nil})
+
+    @namespaced.mset(['foo', '4000'], ['baz', '6000'])
+    expect(@namespaced.mapped_mget('foo', 'bar', 'baz')).to eq({ 'foo' => '4000', 'bar' => '5000', 'baz' => '6000' })
   end
 
   it "should be able to use a namespace with msetnx" do
     @namespaced.msetnx('foo', '1000', '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})
+
+    @namespaced.msetnx(['baz', '4000'])
+    expect(@namespaced.mapped_mget('foo', 'baz', 'bar')).to eq({ 'foo' => '1000', 'bar' => '2000', 'baz' => '4000'})
   end
 
   it "should be able to use a namespace with mapped_msetnx" do
@@ -239,7 +284,7 @@ describe "redis" do
     @namespaced.zadd('sort2', 2, 2)
     @namespaced.zadd('sort2', 3, 3)
     @namespaced.zadd('sort2', 4, 4)
-    @namespaced.zunionstore('union', ['sort1', 'sort2'], :weights => [2, 1])
+    @namespaced.zunionstore('union', ['sort1', 'sort2'], weights: [2, 1])
     expect(@namespaced.zrevrange('union', 0, -1)).to eq(%w( 2 4 3 1 ))
   end
 
@@ -313,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)
@@ -350,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"}
 
@@ -361,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('*')
@@ -377,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|
@@ -386,6 +504,27 @@ describe "redis" do
     expect(result).to eq(["bar", "value"])
   end
 
+  it "is thread safe for multi blocks" do
+    mon = Monitor.new
+    entered = false
+    entered_cond = mon.new_cond
+
+    thread = Thread.new do
+      mon.synchronize do
+        entered_cond.wait_until { entered }
+        @namespaced.multi
+      end
+    end
+
+    @namespaced.multi do |transaction|
+      entered = true
+      mon.synchronize { entered_cond.signal }
+      thread.join(0.1)
+      transaction.get("foo")
+    end
+    thread.join
+  end
+
   it "should add namespace to strlen" do
     @namespaced.set("mykey", "123456")
     expect(@namespaced.strlen("mykey")).to eq(6)
@@ -442,6 +581,45 @@ describe "redis" do
     expect { @namespaced.unknown('foo') }.to raise_exception NoMethodError
   end
 
+  describe '#inspect' do
+    let(:single_level_names) { %i[first] }
+    let(:double_level_names) { %i[first second] }
+    let(:triple_level_names) { %i[first second third] }
+    let(:namespace_builder) do
+      ->(redis, *namespaces) { namespaces.reduce(redis) { |r, n| Redis::Namespace.new(n, redis: r) } }
+    end
+    let(:regexp_builder) do
+      ->(*namespaces) { %r{/#{namespaces.join(':')}>\z} }
+    end
+
+    context 'when one namespace' do
+      let(:single_namespaced) { namespace_builder.call(@redis, *single_level_names) }
+      let(:regexp) { regexp_builder.call(*single_level_names) }
+
+      it 'should have correct ending of inspect string' do
+        expect(regexp =~ single_namespaced.inspect).not_to be(nil)
+      end
+    end
+
+    context 'when two namespaces' do
+      let(:double_namespaced) { namespace_builder.call(@redis, *double_level_names) }
+      let(:regexp) { regexp_builder.call(*double_level_names) }
+
+      it 'should have correct ending of inspect string' do
+        expect(regexp =~ double_namespaced.inspect).not_to be(nil)
+      end
+    end
+
+    context 'when three namespaces' do
+      let(:triple_namespaced) { namespace_builder.call(@redis, *triple_level_names) }
+      let(:regexp) { regexp_builder.call(*triple_level_names) }
+
+      it 'should have correct ending of inspect string' do
+        expect(regexp =~ triple_namespaced.inspect).not_to be(nil)
+      end
+    end
+  end
+
   # Redis 2.6 RC reports its version as 2.5.
   if @redis_version >= Gem::Version.new("2.5.0")
     describe "redis 2.6 commands" do
@@ -488,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)
@@ -520,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')
@@ -626,7 +816,7 @@ describe "redis" do
               expect(result).to match_array(namespaced_keys)
             end
           end
-        end if Redis.current.respond_to?(:scan)
+        end if Redis.new.respond_to?(:scan)
 
         context '#scan_each' do
           context 'when :match supplied' do
@@ -659,7 +849,7 @@ describe "redis" do
               end
             end
           end
-        end if Redis.current.respond_to?(:scan_each)
+        end if Redis.new.respond_to?(:scan_each)
       end
 
       context 'hash scan methods' do
@@ -687,7 +877,7 @@ describe "redis" do
               expect(results).to match_array(@redis.hgetall('ns:hsh').to_a)
             end
           end
-        end if Redis.current.respond_to?(:hscan)
+        end if Redis.new.respond_to?(:hscan)
 
         context '#hscan_each' do
           context 'when :match supplied' do
@@ -720,7 +910,7 @@ describe "redis" do
               end
             end
           end
-        end if Redis.current.respond_to?(:hscan_each)
+        end if Redis.new.respond_to?(:hscan_each)
       end
 
       context 'set scan methods' do
@@ -748,7 +938,7 @@ describe "redis" do
               expect(results).to match_array(set)
             end
           end
-        end if Redis.current.respond_to?(:sscan)
+        end if Redis.new.respond_to?(:sscan)
 
         context '#sscan_each' do
           context 'when :match supplied' do
@@ -781,7 +971,7 @@ describe "redis" do
               end
             end
           end
-        end if Redis.current.respond_to?(:sscan_each)
+        end if Redis.new.respond_to?(:sscan_each)
       end
 
       context 'zset scan methods' do
@@ -811,7 +1001,7 @@ describe "redis" do
               expect(results).to match_array(hash.to_a)
             end
           end
-        end if Redis.current.respond_to?(:zscan)
+        end if Redis.new.respond_to?(:zscan)
 
         context '#zscan_each' do
           context 'when :match supplied' do
@@ -844,7 +1034,7 @@ describe "redis" do
               end
             end
           end
-        end if Redis.current.respond_to?(:zscan_each)
+        end if Redis.new.respond_to?(:zscan_each)
       end
     end
   end
@@ -881,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

data/spec/spec_helper.rb

@@ -12,6 +12,10 @@ $TESTING=true
 $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 require 'redis/namespace'
 
+if Redis.respond_to?(:exists_returns_integer=)
+  Redis.exists_returns_integer = true
+end
+
 module Helper
   def capture_stderr(io = nil)
     require 'stringio'

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: redis-namespace
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.11.0
 platform: ruby
 authors:
 - Chris Wanstrath
 - Terence Lee
 - Steve Klabnik
 - Ryan Biesemeyer
-autorequire: 
+- Mike Bianco
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-12-11 00:00:00.000000000 Z
+date: 2023-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -19,28 +20,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.4
+        version: '4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.4
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.1'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.1'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -69,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
@@ -78,6 +93,7 @@ email:
 - hone02@gmail.com
 - steve@steveklabnik.com
 - me@yaauie.com
+- mike@mikebian.co
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -91,17 +107,21 @@ files:
 - spec/deprecation_spec.rb
 - spec/redis_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/resque/redis-namespace
+homepage: https://github.com/resque/redis-namespace
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+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.11.0
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
       version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
@@ -110,8 +130,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.4.1
+signing_key:
 specification_version: 4
 summary: Namespaces Redis commands.
 test_files: []