redis-namespace 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: '08244a1c35f2f0164e72385ebd64aae7c57354b6'
-  data.tar.gz: dd76131303f0cbb576780146d9c5e3a759302e57
+SHA256:
+  metadata.gz: 9ebbb9000d7b34a0a8386ac9d72e2f63f4573720b22a8eb7e3676c0c1759200b
+  data.tar.gz: ec5c495b22e58cc98d4c759f7873f2d2f9f69c8205b750062207b6f4b1f45897
 SHA512:
-  metadata.gz: 4ca1e49aaf2c9e213a0859d1a0bda67f988ddf3a5af08bbf08388a8582298659d6a6869b7d8ee035501d8abf35779be20164dff5b849110f75f173cafb3444e5
-  data.tar.gz: ca1151681a327f2206370a12f63729ee4f9a0891830274fc0e219353137f09216757421cfb4d4d29c18f73ca2f6e2b7bcf8ff4a0dc55a88324cd0aa7957f2993
+  metadata.gz: e05aa113c14df634a64fdfad7891781ace6a5060a533e9417f94476235f3e05fd33859c4653fcbe8f417582e9257cdf20b1599ac1b2e4cbe38ccaf7c88af2dba
+  data.tar.gz: 220e3ec476e5613dd3a8529f2f7b30f7aba9433a1f4ab4402c55be555ef00ff5651738824ddc583e83e7cbad9297d1f1a107bd61e4b44df5e8c9efa50589cfea

data/LICENSE

@@ -1,20 +1,21 @@
+MIT License
+
 Copyright (c) 2009 Chris Wanstrath
 
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -3,13 +3,13 @@ redis-namespace
 
 Redis::Namespace provides an interface to a namespaced subset of your [redis][] keyspace (e.g., keys with a common beginning), and requires the [redis-rb][] gem.
 
-~~~ irb
+```ruby
 require 'redis-namespace'
 # => true
 
 redis_connection = Redis.new
 # => #<Redis client v3.1.0 for redis://127.0.0.1:6379/0>
-namespaced_redis = Redis::Namespace.new(:ns, :redis => redis_connection)
+namespaced_redis = Redis::Namespace.new(:ns, redis: redis_connection)
 # => #<Redis::Namespace v1.5.0 with client v3.1.0 for redis://127.0.0.1:6379/0/ns>
 
 namespaced_redis.set('foo', 'bar') # redis_connection.set('ns:foo', 'bar')
@@ -20,6 +20,8 @@ namespaced_redis.set('foo', 'bar') # redis_connection.set('ns:foo', 'bar')
 
 namespaced_redis.get('foo')
 # => "bar"
+redis_connection.get('foo')
+# => nil
 redis_connection.get('ns:foo')
 # => "bar"
 
@@ -29,7 +31,7 @@ namespaced_redis.get('foo')
 # => nil
 redis_connection.get('ns:foo')
 # => nil
-~~~
+```
 
 Installation
 ============
@@ -42,20 +44,18 @@ From the command line:
 
 Or in your Gemfile:
 
-~~~ ruby
+```ruby
 gem 'redis-namespace'
-~~~
+```
 
 Caveats
 =======
 
-`Redis::Namespace` provides a namespaced interface to `Redis` by keeping an internal registry of the method signatures in `Redis` provided by the redis-rb gem;
-we keep track of which arguments need the namespace added, and which return values need the namespace removed.
+`Redis::Namespace` provides a namespaced interface to `Redis` by keeping an internal registry of the method signatures in `Redis` provided by the [redis-rb][] gem; we keep track of which arguments need the namespace added, and which return values need the namespace removed.
 
 Blind Passthrough
 -----------------
-If your version of this gem doesn't know about a particular command, it can't namespace it.
-Historically, this has meant that Redis::Namespace blindly passes unknown commands on to the underlying redis connection without modification which can lead to surprising effects.
+If your version of this gem doesn't know about a particular command, it can't namespace it. Historically, this has meant that Redis::Namespace blindly passes unknown commands on to the underlying redis connection without modification which can lead to surprising effects.
 
 As of v1.5.0, blind passthrough has been deprecated, and the functionality will be removed entirely in 2.0.
 
@@ -63,19 +63,16 @@ If you come across a command that is not yet supported, please open an issue on
 
 Administrative Commands
 -----------------------
-The effects of some redis commands cannot be limited to a particular namespace (e.g., `FLUSHALL`, which literally truncates all databases in your redis server, regardless of keyspace).
-Historically, this has meant that Redis::Namespace intentionally passes administrative commands on to the underlying redis connection without modification, which can lead to surprising effects.
+The effects of some redis commands cannot be limited to a particular namespace (e.g., `FLUSHALL`, which literally truncates all databases in your redis server, regardless of keyspace). Historically, this has meant that Redis::Namespace intentionally passes administrative commands on to the underlying redis connection without modification, which can lead to surprising effects.
 
-As of v1.6.0, the direct use of administrative commands has been deprecated, and the functionality will be removed entirely in 2.0;
-while such commands are often useful for testing or administration, their meaning is inherently hidden when placed behind an interface that implies it will namespace everything.
+As of v1.6.0, the direct use of administrative commands has been deprecated, and the functionality will be removed entirely in 2.0; while such commands are often useful for testing or administration, their meaning is inherently hidden when placed behind an interface that implies it will namespace everything.
 
-The prefered way to send an administrative command is on the redis connection
-itself, which is publicly exposed as `Redis::Namespace#redis`:
+The prefered way to send an administrative command is on the redis connection itself, which is publicly exposed as `Redis::Namespace#redis`:
 
-~~~ ruby
+```ruby
 namespaced.redis.flushall()
 # => "OK"
-~~~
+```
 
 2.x Planned Breaking Changes
 ============================

data/lib/redis/namespace.rb

@@ -57,9 +57,12 @@ class Redis
       "append"           => [ :first ],
       "bitcount"         => [ :first ],
       "bitop"            => [ :exclude_first ],
+      "bitpos"           => [ :first ],
       "blpop"            => [ :exclude_last, :first ],
       "brpop"            => [ :exclude_last, :first ],
       "brpoplpush"       => [ :exclude_last ],
+      "bzpopmin"         => [ :first ],
+      "bzpopmax"         => [ :first ],
       "debug"            => [ :exclude_first ],
       "decr"             => [ :first ],
       "decrby"           => [ :first ],
@@ -160,27 +163,31 @@ class Redis
       "sunionstore"      => [ :all ],
       "ttl"              => [ :first ],
       "type"             => [ :first ],
+      "unlink"           => [ :all   ],
       "unsubscribe"      => [ :all ],
       "zadd"             => [ :first ],
       "zcard"            => [ :first ],
       "zcount"           => [ :first ],
       "zincrby"          => [ :first ],
       "zinterstore"      => [ :exclude_options ],
+      "zpopmin"          => [ :first ],
+      "zpopmax"          => [ :first ],
       "zrange"           => [ :first ],
       "zrangebyscore"    => [ :first ],
+      "zrangebylex"      => [ :first ],
       "zrank"            => [ :first ],
       "zrem"             => [ :first ],
       "zremrangebyrank"  => [ :first ],
       "zremrangebyscore" => [ :first ],
+      "zremrangebylex"   => [ :first ],
       "zrevrange"        => [ :first ],
       "zrevrangebyscore" => [ :first ],
+      "zrevrangebylex"   => [ :first ],
       "zrevrank"         => [ :first ],
       "zscan"            => [ :first ],
       "zscan_each"       => [ :first ],
       "zscore"           => [ :first ],
-      "zunionstore"      => [ :exclude_options ],
-      "[]"               => [ :first ],
-      "[]="              => [ :first ]
+      "zunionstore"      => [ :exclude_options ]
     }
     TRANSACTION_COMMANDS = {
       "discard"          => [],
@@ -254,7 +261,7 @@ class Redis
 
     def 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
+            "method instead. Support for the old method will be removed in redis-namespace 2.0.") if @has_new_client_method && deprecations?
       _client
     end
 
@@ -272,7 +279,9 @@ class Redis
 
     # emulate Ruby 1.9+ and keep respond_to_missing? logic together.
     def respond_to?(command, include_private=false)
-      super or respond_to_missing?(command, include_private)
+      return !deprecations? if DEPRECATED_COMMANDS.include?(command.to_s.downcase)
+
+      respond_to_missing?(command, include_private) or super
     end
 
     def keys(query = nil)
@@ -300,6 +309,14 @@ class Redis
       @namespace
     end
 
+    def full_namespace
+      redis.is_a?(Namespace) ? "#{redis.full_namespace}:#{namespace}" : namespace.to_s
+    end
+
+    def connection
+      @redis.connection.tap { |info| info[:namespace] = @namespace }
+    end
+
     def exec
       call_with_namespace(:exec)
     end
@@ -308,15 +325,12 @@ class Redis
       call_with_namespace(:eval, *args)
     end
 
-    def method_missing(command, *args, &block)
-      normalized_command = command.to_s.downcase
+    ADMINISTRATIVE_COMMANDS.keys.each do |command|
+      define_method(command) do |*args, &block|
+        raise NoMethodError if deprecations?
 
-      if ADMINISTRATIVE_COMMANDS.include?(normalized_command)
-        # administrative commands usage is deprecated and will be removed in 2.0
-        # redis-namespace cannot safely apply a namespace to their effects.
-        return super if deprecations?
         if warning?
-          warn("Passing '#{normalized_command}' command to redis as is; " +
+          warn("Passing '#{command}' command to redis as is; " +
                "administrative commands cannot be effectively namespaced " +
                "and should be called on the redis connection directly; " +
                "passthrough has been deprecated and will be removed in " +
@@ -324,8 +338,23 @@ class Redis
                )
         end
         call_with_namespace(command, *args, &block)
-      elsif COMMANDS.include?(normalized_command)
+      end
+    end
+
+    COMMANDS.keys.each do |command|
+      next if ADMINISTRATIVE_COMMANDS.include?(command)
+      next if method_defined?(command)
+
+      define_method(command) do |*args, &block|
         call_with_namespace(command, *args, &block)
+      end
+    end
+
+    def method_missing(command, *args, &block)
+      normalized_command = command.to_s.downcase
+
+      if COMMANDS.include?(normalized_command)
+        send(normalized_command, *args, &block)
       elsif @redis.respond_to?(normalized_command) && !deprecations?
         # blind passthrough is deprecated and will be removed in 2.0
         # redis-namespace does not know how to handle this command.
@@ -351,8 +380,6 @@ class Redis
       normalized_command = command.to_s.downcase
 
       case
-      when DEPRECATED_COMMANDS.include?(normalized_command)
-        !deprecations?
       when COMMANDS.include?(normalized_command)
         true
       when !deprecations? && redis.respond_to?(command, include_all)

data/lib/redis/namespace/version.rb

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

data/spec/deprecation_spec.rb

@@ -43,7 +43,7 @@ describe Redis::Namespace do
       its(:deprecations?) { should be true }
 
       context('with an unhandled command') do
-        it { should_not respond_to :unhandled }
+        it { is_expected.not_to respond_to :unhandled }
 
         it('raises a NoMethodError') do
           expect do
@@ -53,7 +53,7 @@ describe Redis::Namespace do
       end
 
       context('with an administrative command') do
-        it { should_not respond_to :flushdb }
+        it { is_expected.not_to respond_to :flushdb }
 
         it('raises a NoMethodError') do
           expect do
@@ -69,7 +69,7 @@ describe Redis::Namespace do
       its(:deprecations?) { should be false }
 
       context('with an an unhandled command') do
-        it { should respond_to :unhandled }
+        it { is_expected.to respond_to :unhandled }
 
         it 'blindly passes through' do
           expect(redis).to receive(:unhandled)
@@ -106,7 +106,7 @@ describe Redis::Namespace do
       end
 
       context('with an administrative command') do
-        it { should respond_to :flushdb }
+        it { is_expected.to respond_to :flushdb }
         it 'processes the command' do
           expect(redis).to receive(:flushdb)
           capture_stderr { namespaced.flushdb }

data/spec/redis_spec.rb

@@ -25,32 +25,38 @@ describe "redis" do
     @redis.quit
   end
 
+  # redis-rb 3.3.4+
+  it "should inject :namespace into connection info" do
+    info = @redis.connection.merge(:namespace => :ns)
+    expect(@namespaced.connection).to eq(info)
+  end
+
   it "proxies `client` to the _client and deprecated" do
-    @namespaced.client.should eq(redis_client)
+    expect(@namespaced.client).to eq(redis_client)
   end
 
   it "proxies `_client` to the _client" do
-    @namespaced._client.should eq(redis_client)
+    expect(@namespaced._client).to eq(redis_client)
   end
 
   it "should be able to use a namespace" do
-    @namespaced.get('foo').should eq(nil)
+    expect(@namespaced.get('foo')).to eq(nil)
     @namespaced.set('foo', 'chris')
-    @namespaced.get('foo').should eq('chris')
+    expect(@namespaced.get('foo')).to eq('chris')
     @redis.set('foo', 'bob')
-    @redis.get('foo').should eq('bob')
+    expect(@redis.get('foo')).to eq('bob')
 
     @namespaced.incrby('counter', 2)
-    @namespaced.get('counter').to_i.should eq(2)
-    @redis.get('counter').should eq(nil)
-    @namespaced.type('counter').should eq('string')
+    expect(@namespaced.get('counter').to_i).to eq(2)
+    expect(@redis.get('counter')).to eq(nil)
+    expect(@namespaced.type('counter')).to eq('string')
   end
 
   context 'when sending capital commands (issue 68)' do
     it 'should be able to use a namespace' do
       @namespaced.send('SET', 'fubar', 'quux')
-      @redis.get('fubar').should be_nil
-      @namespaced.get('fubar').should eq 'quux'
+      expect(@redis.get('fubar')).to be_nil
+      expect(@namespaced.get('fubar')).to eq 'quux'
     end
   end
 
@@ -58,10 +64,10 @@ describe "redis" do
     @namespaced.rpush "foo", "string"
     @namespaced.rpush "foo", "ns:string"
     @namespaced.rpush "foo", "string_no_timeout"
-    @namespaced.blpop("foo", 1).should eq(["foo", "string"])
-    @namespaced.blpop("foo", 1).should eq(["foo", "ns:string"])
-    @namespaced.blpop("foo").should eq(["foo", "string_no_timeout"])
-    @namespaced.blpop("foo", 1).should eq(nil)
+    expect(@namespaced.blpop("foo", 1)).to eq(["foo", "string"])
+    expect(@namespaced.blpop("foo", 1)).to eq(["foo", "ns:string"])
+    expect(@namespaced.blpop("foo")).to eq(["foo", "string_no_timeout"])
+    expect(@namespaced.blpop("foo", 1)).to eq(nil)
   end
 
   it "should be able to use a namespace with del" do
@@ -69,125 +75,142 @@ describe "redis" do
     @namespaced.set('bar', 2000)
     @namespaced.set('baz', 3000)
     @namespaced.del 'foo'
-    @namespaced.get('foo').should eq(nil)
+    expect(@namespaced.get('foo')).to eq(nil)
     @namespaced.del 'bar', 'baz'
-    @namespaced.get('bar').should eq(nil)
-    @namespaced.get('baz').should eq(nil)
+    expect(@namespaced.get('bar')).to eq(nil)
+    expect(@namespaced.get('baz')).to eq(nil)
+  end
+
+  it "should be able to use a namespace with unlink" do
+    @namespaced.set('foo', 1000)
+    @namespaced.set('bar', 2000)
+    @namespaced.set('baz', 3000)
+    @namespaced.unlink 'foo'
+    expect(@namespaced.get('foo')).to eq(nil)
+    @namespaced.unlink 'bar', 'baz'
+    expect(@namespaced.get('bar')).to eq(nil)
+    expect(@namespaced.get('baz')).to eq(nil)
   end
 
   it 'should be able to use a namespace with append' do
     @namespaced.set('foo', 'bar')
-    @namespaced.append('foo','n').should eq(4)
-    @namespaced.get('foo').should eq('barn')
-    @redis.get('foo').should eq('bar')
+    expect(@namespaced.append('foo','n')).to eq(4)
+    expect(@namespaced.get('foo')).to eq('barn')
+    expect(@redis.get('foo')).to eq('bar')
   end
 
   it 'should be able to use a namespace with brpoplpush' do
     @namespaced.lpush('foo','bar')
-    @namespaced.brpoplpush('foo','bar',0).should eq('bar')
-    @namespaced.lrange('foo',0,-1).should eq([])
-    @namespaced.lrange('bar',0,-1).should eq(['bar'])
+    expect(@namespaced.brpoplpush('foo','bar',0)).to eq('bar')
+    expect(@namespaced.lrange('foo',0,-1)).to eq([])
+    expect(@namespaced.lrange('bar',0,-1)).to eq(['bar'])
   end
 
   it 'should be able to use a namespace with getbit' do
     @namespaced.set('foo','bar')
-    @namespaced.getbit('foo',1).should eq(1)
+    expect(@namespaced.getbit('foo',1)).to eq(1)
   end
 
   it 'should be able to use a namespace with getrange' do
     @namespaced.set('foo','bar')
-    @namespaced.getrange('foo',0,-1).should eq('bar')
+    expect(@namespaced.getrange('foo',0,-1)).to eq('bar')
   end
 
   it 'should be able to use a namespace with linsert' do
     @namespaced.rpush('foo','bar')
     @namespaced.rpush('foo','barn')
     @namespaced.rpush('foo','bart')
-    @namespaced.linsert('foo','BEFORE','barn','barf').should eq(4)
-    @namespaced.lrange('foo',0,-1).should eq(['bar','barf','barn','bart'])
+    expect(@namespaced.linsert('foo','BEFORE','barn','barf')).to eq(4)
+    expect(@namespaced.lrange('foo',0,-1)).to eq(['bar','barf','barn','bart'])
   end
 
   it 'should be able to use a namespace with lpushx' do
-    @namespaced.lpushx('foo','bar').should eq(0)
+    expect(@namespaced.lpushx('foo','bar')).to eq(0)
     @namespaced.lpush('foo','boo')
-    @namespaced.lpushx('foo','bar').should eq(2)
-    @namespaced.lrange('foo',0,-1).should eq(['bar','boo'])
+    expect(@namespaced.lpushx('foo','bar')).to eq(2)
+    expect(@namespaced.lrange('foo',0,-1)).to eq(['bar','boo'])
   end
 
   it 'should be able to use a namespace with rpushx' do
-    @namespaced.rpushx('foo','bar').should eq(0)
+    expect(@namespaced.rpushx('foo','bar')).to eq(0)
     @namespaced.lpush('foo','boo')
-    @namespaced.rpushx('foo','bar').should eq(2)
-    @namespaced.lrange('foo',0,-1).should eq(['boo','bar'])
+    expect(@namespaced.rpushx('foo','bar')).to eq(2)
+    expect(@namespaced.lrange('foo',0,-1)).to eq(['boo','bar'])
   end
 
   it 'should be able to use a namespace with setbit' do
     @namespaced.setbit('virgin_key', 1, 1)
-    @namespaced.exists('virgin_key').should be_true
-    @namespaced.get('virgin_key').should eq(@namespaced.getrange('virgin_key',0,-1))
+    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 bitpos' do
+    @namespaced.setbit('bit_map', 42, 1)
+    expect(@namespaced.bitpos('bit_map', 0)).to eq(0)
+    expect(@namespaced.bitpos('bit_map', 1)).to eq(42)
   end
 
   it 'should be able to use a namespace with setrange' do
     @namespaced.setrange('foo', 0, 'bar')
-    @namespaced.get('foo').should eq('bar')
+    expect(@namespaced.get('foo')).to eq('bar')
 
     @namespaced.setrange('bar', 2, 'foo')
-    @namespaced.get('bar').should eq("\000\000foo")
+    expect(@namespaced.get('bar')).to eq("\000\000foo")
   end
 
   it "should be able to use a namespace with mget" do
     @namespaced.set('foo', 1000)
     @namespaced.set('bar', 2000)
-    @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '1000', 'bar' => '2000' })
-    @namespaced.mapped_mget('foo', 'baz', 'bar').should eq({'foo'=>'1000', 'bar'=>'2000', 'baz' => nil})
+    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})
   end
 
   it "should be able to use a namespace with mset" do
     @namespaced.mset('foo', '1000', 'bar', '2000')
-    @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '1000', 'bar' => '2000' })
-    @namespaced.mapped_mget('foo', 'baz', 'bar').should eq({ 'foo' => '1000', 'bar' => '2000', 'baz' => nil})
+    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')
-    @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '3000', 'bar' => '5000' })
-    @namespaced.mapped_mget('foo', 'baz', 'bar').should eq({ 'foo' => '3000', 'bar' => '5000', 'baz' => nil})
+    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})
   end
 
   it "should be able to use a namespace with msetnx" do
     @namespaced.msetnx('foo', '1000', 'bar', '2000')
-    @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '1000', 'bar' => '2000' })
-    @namespaced.mapped_mget('foo', 'baz', 'bar').should eq({ 'foo' => '1000', 'bar' => '2000', 'baz' => nil})
+    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})
   end
 
   it "should be able to use a namespace with mapped_msetnx" do
     @namespaced.set('foo','1')
-    @namespaced.mapped_msetnx('foo'=>'1000', 'bar'=>'2000').should be_false
-    @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '1', 'bar' => nil })
-    @namespaced.mapped_msetnx('bar'=>'2000', 'baz'=>'1000').should be_true
-    @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '1', 'bar' => '2000' })
+    expect(@namespaced.mapped_msetnx('foo'=>'1000', 'bar'=>'2000')).to be false
+    expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '1', 'bar' => nil })
+    expect(@namespaced.mapped_msetnx('bar'=>'2000', 'baz'=>'1000')).to be true
+    expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '1', 'bar' => '2000' })
   end
 
   it "should be able to use a namespace with hashes" do
     @namespaced.hset('foo', 'key', 'value')
     @namespaced.hset('foo', 'key1', 'value1')
-    @namespaced.hget('foo', 'key').should eq('value')
-    @namespaced.hgetall('foo').should eq({'key' => 'value', 'key1' => 'value1'})
-    @namespaced.hlen('foo').should eq(2)
-    @namespaced.hkeys('foo').should eq(['key', 'key1'])
+    expect(@namespaced.hget('foo', 'key')).to eq('value')
+    expect(@namespaced.hgetall('foo')).to eq({'key' => 'value', 'key1' => 'value1'})
+    expect(@namespaced.hlen('foo')).to eq(2)
+    expect(@namespaced.hkeys('foo')).to eq(['key', 'key1'])
     @namespaced.hmset('bar', 'key', 'value', 'key1', 'value1')
     @namespaced.hmget('bar', 'key', 'key1')
     @namespaced.hmset('bar', 'a_number', 1)
-    @namespaced.hmget('bar', 'a_number').should eq(['1'])
+    expect(@namespaced.hmget('bar', 'a_number')).to eq(['1'])
     @namespaced.hincrby('bar', 'a_number', 3)
-    @namespaced.hmget('bar', 'a_number').should eq(['4'])
-    @namespaced.hgetall('bar').should eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
-
-    @namespaced.hsetnx('foonx','nx',10).should be_true
-    @namespaced.hsetnx('foonx','nx',12).should be_false
-    @namespaced.hget('foonx','nx').should eq("10")
-    @namespaced.hkeys('foonx').should eq(%w{ nx })
-    @namespaced.hvals('foonx').should eq(%w{ 10 })
+    expect(@namespaced.hmget('bar', 'a_number')).to eq(['4'])
+    expect(@namespaced.hgetall('bar')).to eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
+
+    expect(@namespaced.hsetnx('foonx','nx',10)).to be true
+    expect(@namespaced.hsetnx('foonx','nx',12)).to be false
+    expect(@namespaced.hget('foonx','nx')).to eq("10")
+    expect(@namespaced.hkeys('foonx')).to eq(%w{ nx })
+    expect(@namespaced.hvals('foonx')).to eq(%w{ 10 })
     @namespaced.mapped_hmset('baz', {'key' => 'value', 'key1' => 'value1', 'a_number' => 4})
-    @namespaced.mapped_hmget('baz', 'key', 'key1', 'a_number').should eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
-    @namespaced.hgetall('baz').should eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
+    expect(@namespaced.mapped_hmget('baz', 'key', 'key1', 'a_number')).to eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
+    expect(@namespaced.hgetall('baz')).to eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
   end
 
   it "should properly intersect three sets" do
@@ -198,7 +221,7 @@ describe "redis" do
     @namespaced.sadd('bar', 3)
     @namespaced.sadd('bar', 4)
     @namespaced.sadd('baz', 3)
-    @namespaced.sinter('foo', 'bar', 'baz').should eq(%w( 3 ))
+    expect(@namespaced.sinter('foo', 'bar', 'baz')).to eq(%w( 3 ))
   end
 
   it "should properly union two sets" do
@@ -207,7 +230,7 @@ describe "redis" do
     @namespaced.sadd('bar', 2)
     @namespaced.sadd('bar', 3)
     @namespaced.sadd('bar', 4)
-    @namespaced.sunion('foo', 'bar').sort.should eq(%w( 1 2 3 4 ))
+    expect(@namespaced.sunion('foo', 'bar').sort).to eq(%w( 1 2 3 4 ))
   end
 
   it "should properly union two sorted sets with options" do
@@ -217,7 +240,7 @@ describe "redis" do
     @namespaced.zadd('sort2', 3, 3)
     @namespaced.zadd('sort2', 4, 4)
     @namespaced.zunionstore('union', ['sort1', 'sort2'], :weights => [2, 1])
-    @namespaced.zrevrange('union', 0, -1).should eq(%w( 2 4 3 1 ))
+    expect(@namespaced.zrevrange('union', 0, -1)).to eq(%w( 2 4 3 1 ))
   end
 
   it "should properly union two sorted sets without options" do
@@ -227,7 +250,7 @@ describe "redis" do
     @namespaced.zadd('sort2', 3, 3)
     @namespaced.zadd('sort2', 4, 4)
     @namespaced.zunionstore('union', ['sort1', 'sort2'])
-    @namespaced.zrevrange('union', 0, -1).should eq(%w( 4 2 3 1 ))
+    expect(@namespaced.zrevrange('union', 0, -1)).to eq(%w( 4 2 3 1 ))
   end
 
   it "should properly intersect two sorted sets without options" do
@@ -242,7 +265,7 @@ describe "redis" do
     @namespaced.zinterstore('inter', ['food', 'color'])
 
     inter_values = @namespaced.zrevrange('inter', 0, -1, :with_scores => true)
-    inter_values.should =~ [['orange', 3.0], ['eggplant', 7.0]]
+    expect(inter_values).to match_array([['orange', 3.0], ['eggplant', 7.0]])
   end
 
   it "should properly intersect two sorted sets with options" do
@@ -257,7 +280,37 @@ describe "redis" do
     @namespaced.zinterstore('inter', ['food', 'color'], :aggregate => "min")
 
     inter_values = @namespaced.zrevrange('inter', 0, -1, :with_scores => true)
-    inter_values.should =~ [['orange', 1.0], ['eggplant', 3.0]]
+    expect(inter_values).to match_array([['orange', 1.0], ['eggplant', 3.0]])
+  end
+
+  it "should return lexicographical range for sorted set" do
+    @namespaced.zadd('food', 0, 'orange')
+    @namespaced.zadd('food', 0, 'banana')
+    @namespaced.zadd('food', 0, 'eggplant')
+
+    values = @namespaced.zrangebylex('food', '[b', '(o')
+    expect(values).to match_array(['banana', 'eggplant'])
+  end
+
+  it "should return the number of elements removed from the set" do
+    @namespaced.zadd('food', 0, 'orange')
+    @namespaced.zadd('food', 0, 'banana')
+    @namespaced.zadd('food', 0, 'eggplant')
+
+    removed = @namespaced.zremrangebylex('food', '[b', '(o')
+    expect(removed).to eq(2)
+
+    values = @namespaced.zrange('food', 0, -1)
+    expect(values).to eq(['orange'])
+  end
+
+  it "should return reverce lexicographical range for sorted set" do
+    @namespaced.zadd('food', 0, 'orange')
+    @namespaced.zadd('food', 0, 'banana')
+    @namespaced.zadd('food', 0, 'eggplant')
+
+    values = @namespaced.zrevrangebylex('food', '(o', '[b')
+    expect(values).to match_array(['banana', 'eggplant'])
   end
 
   it "should add namespace to sort" do
@@ -268,24 +321,24 @@ describe "redis" do
     @namespaced.set('value_1', 'a')
     @namespaced.set('value_2', 'b')
 
-    @namespaced.sort('foo').should eq(%w( 1 2 ))
-    @namespaced.sort('foo', :limit => [0, 1]).should eq(%w( 1 ))
-    @namespaced.sort('foo', :order => 'desc').should eq(%w( 2 1 ))
-    @namespaced.sort('foo', :by => 'weight_*').should eq(%w( 2 1 ))
-    @namespaced.sort('foo', :get => 'value_*').should eq(%w( a b ))
-    @namespaced.sort('foo', :get => '#').should eq(%w( 1 2 ))
-    @namespaced.sort('foo', :get => ['#', 'value_*']).should eq([["1", "a"], ["2", "b"]])
+    expect(@namespaced.sort('foo')).to eq(%w( 1 2 ))
+    expect(@namespaced.sort('foo', :limit => [0, 1])).to eq(%w( 1 ))
+    expect(@namespaced.sort('foo', :order => 'desc')).to eq(%w( 2 1 ))
+    expect(@namespaced.sort('foo', :by => 'weight_*')).to eq(%w( 2 1 ))
+    expect(@namespaced.sort('foo', :get => 'value_*')).to eq(%w( a b ))
+    expect(@namespaced.sort('foo', :get => '#')).to eq(%w( 1 2 ))
+    expect(@namespaced.sort('foo', :get => ['#', 'value_*'])).to eq([["1", "a"], ["2", "b"]])
 
     @namespaced.sort('foo', :store => 'result')
-    @namespaced.lrange('result', 0, -1).should eq(%w( 1 2 ))
+    expect(@namespaced.lrange('result', 0, -1)).to eq(%w( 1 2 ))
   end
 
   it "should yield the correct list of keys" do
     @namespaced.set("foo", 1)
     @namespaced.set("bar", 2)
     @namespaced.set("baz", 3)
-    @namespaced.keys("*").sort.should eq(%w( bar baz foo ))
-    @namespaced.keys.sort.should eq(%w( bar baz foo ))
+    expect(@namespaced.keys("*").sort).to eq(%w( bar baz foo ))
+    expect(@namespaced.keys.sort).to eq(%w( bar baz foo ))
   end
 
   it "should add namepsace to multi blocks" do
@@ -294,7 +347,7 @@ describe "redis" do
       r.del "foo"
       r.mapped_hmset "foo", {"key1" => "value1"}
     end
-    @namespaced.hgetall("foo").should eq({"key1" => "value1"})
+    expect(@namespaced.hgetall("foo")).to eq({"key1" => "value1"})
   end
 
   it "should pass through multi commands without block" do
@@ -305,14 +358,14 @@ describe "redis" do
     @namespaced.mapped_hmset "foo", {"key1" => "value1"}
     @namespaced.exec
 
-    @namespaced.hgetall("foo").should eq({"key1" => "value1"})
+    expect(@namespaced.hgetall("foo")).to eq({"key1" => "value1"})
   end
 
   it 'should return futures without attempting to remove namespaces' do
     @namespaced.multi do
       @future = @namespaced.keys('*')
     end
-    @future.class.should be(Redis::Future)
+    expect(@future.class).to be(Redis::Future)
   end
 
   it "should add namespace to pipelined blocks" do
@@ -321,7 +374,7 @@ describe "redis" do
       r.del "foo"
       r.mapped_hmset "foo", {"key1" => "value1"}
     end
-    @namespaced.hgetall("foo").should eq({"key1" => "value1"})
+    expect(@namespaced.hgetall("foo")).to eq({"key1" => "value1"})
   end
 
   it "should returned response array from pipelined block" do
@@ -330,59 +383,59 @@ describe "redis" do
       r.get("foo")
       r.get("key")
     end
-    result.should eq(["bar", "value"])
+    expect(result).to eq(["bar", "value"])
   end
 
   it "should add namespace to strlen" do
     @namespaced.set("mykey", "123456")
-    @namespaced.strlen("mykey").should eq(6)
+    expect(@namespaced.strlen("mykey")).to eq(6)
   end
 
   it "should not add namespace to echo" do
-    @namespaced.echo(123).should eq("123")
+    expect(@namespaced.echo(123)).to eq("123")
   end
 
   it 'should not add namespace to disconnect!' do
-    expect(@redis).to receive(:disconnect!).with().and_call_original
+    expect(@redis).to receive(:disconnect!).with(no_args).and_call_original
 
     expect(@namespaced.disconnect!).to be nil
   end
 
   it "can change its namespace" do
-    @namespaced.get('foo').should eq(nil)
+    expect(@namespaced.get('foo')).to eq(nil)
     @namespaced.set('foo', 'chris')
-    @namespaced.get('foo').should eq('chris')
+    expect(@namespaced.get('foo')).to eq('chris')
 
-    @namespaced.namespace.should eq(:ns)
+    expect(@namespaced.namespace).to eq(:ns)
     @namespaced.namespace = :spec
-    @namespaced.namespace.should eq(:spec)
+    expect(@namespaced.namespace).to eq(:spec)
 
-    @namespaced.get('foo').should eq(nil)
+    expect(@namespaced.get('foo')).to eq(nil)
     @namespaced.set('foo', 'chris')
-    @namespaced.get('foo').should eq('chris')
+    expect(@namespaced.get('foo')).to eq('chris')
   end
 
   it "can accept a temporary namespace" do
-    @namespaced.namespace.should eq(:ns)
-    @namespaced.get('foo').should eq(nil)
+    expect(@namespaced.namespace).to eq(:ns)
+    expect(@namespaced.get('foo')).to eq(nil)
 
     @namespaced.namespace(:spec) do |temp_ns|
-      temp_ns.namespace.should eq(:spec)
-      temp_ns.get('foo').should eq(nil)
+      expect(temp_ns.namespace).to eq(:spec)
+      expect(temp_ns.get('foo')).to eq(nil)
       temp_ns.set('foo', 'jake')
-      temp_ns.get('foo').should eq('jake')
+      expect(temp_ns.get('foo')).to eq('jake')
     end
 
-    @namespaced.namespace.should eq(:ns)
-    @namespaced.get('foo').should eq(nil)
+    expect(@namespaced.namespace).to eq(:ns)
+    expect(@namespaced.get('foo')).to eq(nil)
   end
 
   it "should respond to :namespace=" do
-    @namespaced.respond_to?(:namespace=).should eq(true)
+    expect(@namespaced.respond_to?(:namespace=)).to eq(true)
   end
 
   it "should respond to :warning=" do
-    @namespaced.respond_to?(:warning=).should == true
+    expect(@namespaced.respond_to?(:warning=)).to eq(true)
   end
 
   it "should raise an exception when an unknown command is passed" do
@@ -422,7 +475,7 @@ describe "redis" do
         v = @namespaced.dump("foo")
         @redis.del("ns:foo")
 
-        expect(@namespaced.restore("foo", 1000, v)).to be_true
+        expect(@namespaced.restore("foo", 1000, v)).to be_truthy
         expect(@redis.get("ns:foo")).to eq 'a'
         expect(@redis.ttl("ns:foo")).to satisfy {|v| (0..1).include?(v) }
 
@@ -430,72 +483,72 @@ describe "redis" do
         w = @namespaced.dump("bar")
         @redis.del("ns:bar")
 
-        expect(@namespaced.restore("bar", 1000, w)).to be_true
+        expect(@namespaced.restore("bar", 1000, w)).to be_truthy
         expect(@redis.lrange('ns:bar', 0, -1)).to eq %w(b c d)
         expect(@redis.ttl("ns:foo")).to satisfy {|v| (0..1).include?(v) }
       end
 
       it "should namespace hincrbyfloat" do
         @namespaced.hset('mykey', 'field', 10.50)
-        @namespaced.hincrbyfloat('mykey', 'field', 0.1).should eq(10.6)
+        expect(@namespaced.hincrbyfloat('mykey', 'field', 0.1)).to eq(10.6)
       end
 
       it "should namespace incrbyfloat" do
         @namespaced.set('mykey', 10.50)
-        @namespaced.incrbyfloat('mykey', 0.1).should eq(10.6)
+        expect(@namespaced.incrbyfloat('mykey', 0.1)).to eq(10.6)
       end
 
       it "should namespace object" do
         @namespaced.set('foo', 1000)
-        @namespaced.object('encoding', 'foo').should eq('int')
+        expect(@namespaced.object('encoding', 'foo')).to eq('int')
       end
 
       it "should namespace persist" do
         @namespaced.set('mykey', 'Hello')
         @namespaced.expire('mykey', 60)
-        @namespaced.persist('mykey').should eq(true)
-        @namespaced.ttl('mykey').should eq(-1)
+        expect(@namespaced.persist('mykey')).to eq(true)
+        expect(@namespaced.ttl('mykey')).to eq(-1)
       end
 
       it "should namespace pexpire" do
         @namespaced.set('mykey', 'Hello')
-        @namespaced.pexpire('mykey', 60000).should eq(true)
+        expect(@namespaced.pexpire('mykey', 60000)).to eq(true)
       end
 
       it "should namespace pexpireat" do
         @namespaced.set('mykey', 'Hello')
-        @namespaced.pexpire('mykey', 1555555555005).should eq(true)
+        expect(@namespaced.pexpire('mykey', 1555555555005)).to eq(true)
       end
 
       it "should namespace psetex" do
-        @namespaced.psetex('mykey', 10000, 'Hello').should eq('OK')
-        @namespaced.get('mykey').should eq('Hello')
+        expect(@namespaced.psetex('mykey', 10000, 'Hello')).to eq('OK')
+        expect(@namespaced.get('mykey')).to eq('Hello')
       end
 
       it "should namespace pttl" do
         @namespaced.set('mykey', 'Hello')
         @namespaced.expire('mykey', 1)
-        @namespaced.pttl('mykey').should >= 0
+        expect(@namespaced.pttl('mykey')).to be >= 0
       end
 
       it "should namespace eval keys passed in as array args" do
-        @namespaced.
-          eval("return {KEYS[1], KEYS[2]}", %w[k1 k2], %w[arg1 arg2]).
-          should eq(%w[ns:k1 ns:k2])
+        expect(@namespaced.
+          eval("return {KEYS[1], KEYS[2]}", %w[k1 k2], %w[arg1 arg2])).
+          to eq(%w[ns:k1 ns:k2])
       end
 
       it "should namespace eval keys passed in as hash args" do
-        @namespaced.
-          eval("return {KEYS[1], KEYS[2]}", :keys => %w[k1 k2], :argv => %w[arg1 arg2]).
-          should eq(%w[ns:k1 ns:k2])
+        expect(@namespaced.
+          eval("return {KEYS[1], KEYS[2]}", :keys => %w[k1 k2], :argv => %w[arg1 arg2])).
+          to eq(%w[ns:k1 ns:k2])
       end
 
       it "should namespace eval keys passed in as hash args unmodified" do
         args = { :keys => %w[k1 k2], :argv => %w[arg1 arg2] }
         args.freeze
-        @namespaced.
-          eval("return {KEYS[1], KEYS[2]}", args).
-          should eq(%w[ns:k1 ns:k2])
+        expect(@namespaced.
+          eval("return {KEYS[1], KEYS[2]}", args)).
+          to eq(%w[ns:k1 ns:k2])
       end
 
       context '#evalsha' do
@@ -504,23 +557,23 @@ describe "redis" do
         end
 
         it "should namespace evalsha keys passed in as array args" do
-          @namespaced.
-            evalsha(sha, %w[k1 k2], %w[arg1 arg2]).
-            should eq(%w[ns:k1 ns:k2])
+          expect(@namespaced.
+            evalsha(sha, %w[k1 k2], %w[arg1 arg2])).
+            to eq(%w[ns:k1 ns:k2])
         end
 
         it "should namespace evalsha keys passed in as hash args" do
-          @namespaced.
-            evalsha(sha, :keys => %w[k1 k2], :argv => %w[arg1 arg2]).
-            should eq(%w[ns:k1 ns:k2])
+          expect(@namespaced.
+            evalsha(sha, :keys => %w[k1 k2], :argv => %w[arg1 arg2])).
+            to eq(%w[ns:k1 ns:k2])
         end
 
         it "should namespace evalsha keys passed in as hash args unmodified" do
           args = { :keys => %w[k1 k2], :argv => %w[arg1 arg2] }
           args.freeze
-          @namespaced.
-            evalsha(sha, args).
-            should eq(%w[ns:k1 ns:k2])
+          expect(@namespaced.
+            evalsha(sha, args)).
+            to eq(%w[ns:k1 ns:k2])
         end
       end
 
@@ -529,13 +582,13 @@ describe "redis" do
         let(:sha) { @redis.script(:load, "return {KEYS[1], KEYS[2]}") }
 
         it "should namespace eval keys passed in as hash args" do
-          nested_namespace.
-          eval("return {KEYS[1], KEYS[2]}", :keys => %w[k1 k2], :argv => %w[arg1 arg2]).
-          should eq(%w[ns:nest:k1 ns:nest:k2])
+          expect(nested_namespace.
+          eval("return {KEYS[1], KEYS[2]}", :keys => %w[k1 k2], :argv => %w[arg1 arg2])).
+          to eq(%w[ns:nest:k1 ns:nest:k2])
         end
         it "should namespace evalsha keys passed in as hash args" do
-          nested_namespace.evalsha(sha, :keys => %w[k1 k2], :argv => %w[arg1 arg2]).
-            should eq(%w[ns:nest:k1 ns:nest:k2])
+          expect(nested_namespace.evalsha(sha, :keys => %w[k1 k2], :argv => %w[arg1 arg2])).
+            to eq(%w[ns:nest:k1 ns:nest:k2])
         end
       end
     end
@@ -564,13 +617,13 @@ describe "redis" do
           context 'when :match supplied' do
             it 'should retrieve the proper keys' do
               _, result = @namespaced.scan(0, :match => 'zeta:*', :count => 1000)
-              result.should =~ matching_namespaced_keys
+              expect(result).to match_array(matching_namespaced_keys)
             end
           end
           context 'without :match supplied' do
             it 'should retrieve the proper keys' do
               _, result = @namespaced.scan(0, :count => 1000)
-              result.should =~ namespaced_keys
+              expect(result).to match_array(namespaced_keys)
             end
           end
         end if Redis.current.respond_to?(:scan)
@@ -581,13 +634,13 @@ describe "redis" do
               it 'should yield unnamespaced' do
                 results = []
                 @namespaced.scan_each(:match => 'zeta:*', :count => 1000) {|k| results << k }
-                results.should =~ matching_namespaced_keys
+                expect(results).to match_array(matching_namespaced_keys)
               end
             end
             context 'without a block' do
               it 'should return an Enumerator that un-namespaces' do
                 enum = @namespaced.scan_each(:match => 'zeta:*', :count => 1000)
-                enum.to_a.should =~ matching_namespaced_keys
+                expect(enum.to_a).to match_array(matching_namespaced_keys)
               end
             end
           end
@@ -596,13 +649,13 @@ describe "redis" do
               it 'should yield unnamespaced' do
                 results = []
                 @namespaced.scan_each(:count => 1000){ |k| results << k }
-                results.should =~ namespaced_keys
+                expect(results).to match_array(namespaced_keys)
               end
             end
             context 'without a block' do
               it 'should return an Enumerator that un-namespaces' do
                 enum = @namespaced.scan_each(:count => 1000)
-                enum.to_a.should =~ namespaced_keys
+                expect(enum.to_a).to match_array(namespaced_keys)
               end
             end
           end
@@ -625,13 +678,13 @@ describe "redis" do
           context 'when supplied :match' do
             it 'should retrieve the proper keys' do
               _, results = @namespaced.hscan('hsh', 0, :match => 'zeta:*')
-              results.should =~ hash_matching_subset.to_a
+              expect(results).to match_array(hash_matching_subset.to_a)
             end
           end
           context 'without :match supplied' do
             it 'should retrieve all hash keys' do
               _, results = @namespaced.hscan('hsh', 0)
-              results.should =~ @redis.hgetall('ns:hsh').to_a
+              expect(results).to match_array(@redis.hgetall('ns:hsh').to_a)
             end
           end
         end if Redis.current.respond_to?(:hscan)
@@ -642,13 +695,13 @@ describe "redis" do
               it 'should yield the correct hash keys unchanged' do
                 results = []
                 @namespaced.hscan_each('hsh', :match => 'zeta:*', :count => 1000) { |kv| results << kv}
-                results.should =~ hash_matching_subset.to_a
+                expect(results).to match_array(hash_matching_subset.to_a)
               end
             end
             context 'without a block' do
               it 'should return an Enumerator that yields the correct hash keys unchanged' do
                 enum = @namespaced.hscan_each('hsh', :match => 'zeta:*', :count => 1000)
-                enum.to_a.should =~ hash_matching_subset.to_a
+                expect(enum.to_a).to match_array(hash_matching_subset.to_a)
               end
             end
           end
@@ -657,13 +710,13 @@ describe "redis" do
               it 'should yield all hash keys unchanged' do
                 results = []
                 @namespaced.hscan_each('hsh', :count => 1000){ |k| results << k }
-                results.should =~ hash.to_a
+                expect(results).to match_array(hash.to_a)
               end
             end
             context 'without a block' do
               it 'should return an Enumerator that yields all keys unchanged' do
                 enum = @namespaced.hscan_each('hsh', :count => 1000)
-                enum.to_a.should =~ hash.to_a
+                expect(enum.to_a).to match_array(hash.to_a)
               end
             end
           end
@@ -686,13 +739,13 @@ describe "redis" do
           context 'when supplied :match' do
             it 'should retrieve the matching set members from the proper set' do
               _, results = @namespaced.sscan('set', 0, :match => 'zeta:*', :count => 1000)
-              results.should =~ matching_subset
+              expect(results).to match_array(matching_subset)
             end
           end
           context 'without :match supplied' do
             it 'should retrieve all set members from the proper set' do
               _, results = @namespaced.sscan('set', 0, :count => 1000)
-              results.should =~ set
+              expect(results).to match_array(set)
             end
           end
         end if Redis.current.respond_to?(:sscan)
@@ -703,13 +756,13 @@ describe "redis" do
               it 'should yield the correct hset elements unchanged' do
                 results = []
                 @namespaced.sscan_each('set', :match => 'zeta:*', :count => 1000) { |kv| results << kv}
-                results.should =~ matching_subset
+                expect(results).to match_array(matching_subset)
               end
             end
             context 'without a block' do
               it 'should return an Enumerator that yields the correct set elements unchanged' do
                 enum = @namespaced.sscan_each('set', :match => 'zeta:*', :count => 1000)
-                enum.to_a.should =~ matching_subset
+                expect(enum.to_a).to match_array(matching_subset)
               end
             end
           end
@@ -718,13 +771,13 @@ describe "redis" do
               it 'should yield all set elements unchanged' do
                 results = []
                 @namespaced.sscan_each('set', :count => 1000){ |k| results << k }
-                results.should =~ set
+                expect(results).to match_array(set)
               end
             end
             context 'without a block' do
               it 'should return an Enumerator that yields all set elements unchanged' do
                 enum = @namespaced.sscan_each('set', :count => 1000)
-                enum.to_a.should =~ set
+                expect(enum.to_a).to match_array(set)
               end
             end
           end
@@ -748,14 +801,14 @@ describe "redis" do
             it 'should retrieve the matching set elements and their scores' do
               results = []
               @namespaced.zscan_each('zset', :match => 'zeta:*', :count => 1000) { |ms| results << ms }
-              results.should =~ hash_matching_subset.to_a
+              expect(results).to match_array(hash_matching_subset.to_a)
             end
           end
           context 'without :match supplied' do
             it 'should retrieve all set elements and their scores' do
               results = []
               @namespaced.zscan_each('zset', :count => 1000) { |ms| results << ms }
-              results.should =~ hash.to_a
+              expect(results).to match_array(hash.to_a)
             end
           end
         end if Redis.current.respond_to?(:zscan)
@@ -766,13 +819,13 @@ describe "redis" do
               it 'should yield the correct set elements and scores unchanged' do
                 results = []
                 @namespaced.zscan_each('zset', :match => 'zeta:*', :count => 1000) { |ms| results << ms}
-                results.should =~ hash_matching_subset.to_a
+                expect(results).to match_array(hash_matching_subset.to_a)
               end
             end
             context 'without a block' do
               it 'should return an Enumerator that yields the correct set elements and scoresunchanged' do
                 enum = @namespaced.zscan_each('zset', :match => 'zeta:*', :count => 1000)
-                enum.to_a.should =~ hash_matching_subset.to_a
+                expect(enum.to_a).to match_array(hash_matching_subset.to_a)
               end
             end
           end
@@ -781,13 +834,13 @@ describe "redis" do
               it 'should yield all set elements and scores unchanged' do
                 results = []
                 @namespaced.zscan_each('zset', :count => 1000){ |ms| results << ms }
-                results.should =~ hash.to_a
+                expect(results).to match_array(hash.to_a)
               end
             end
             context 'without a block' do
               it 'should return an Enumerator that yields all set elements and scores unchanged' do
                 enum = @namespaced.zscan_each('zset', :count => 1000)
-                enum.to_a.should =~ hash.to_a
+                expect(enum.to_a).to match_array(hash.to_a)
               end
             end
           end
@@ -799,12 +852,12 @@ describe "redis" do
   if @redis_version >= Gem::Version.new("2.8.9")
     it 'should namespace pfadd' do
       5.times { |n| @namespaced.pfadd("pf", n) }
-      @redis.pfcount("ns:pf").should == 5
+      expect(@redis.pfcount("ns:pf")).to eq(5)
     end
 
     it 'should namespace pfcount' do
       5.times { |n| @redis.pfadd("ns:pf", n) }
-      @namespaced.pfcount("pf").should == 5
+      expect(@namespaced.pfcount("pf")).to eq(5)
     end
 
     it 'should namespace pfmerge' do
@@ -814,7 +867,18 @@ describe "redis" do
       end
 
       @namespaced.pfmerge("pfc", "pfa", "pfb")
-      @redis.pfcount("ns:pfc").should == 10
+      expect(@redis.pfcount("ns:pfc")).to eq(10)
+    end
+  end
+
+  describe :full_namespace do
+    it "should return the full namespace including sub namespaces" do
+      sub_namespaced     = Redis::Namespace.new(:sub1, :redis => @namespaced)
+      sub_sub_namespaced = Redis::Namespace.new(:sub2, :redis => sub_namespaced)
+
+      expect(@namespaced.full_namespace).to eql("ns")
+      expect(sub_namespaced.full_namespace).to eql("ns:sub1")
+      expect(sub_sub_namespaced.full_namespace).to eql("ns:sub1:sub2")
     end
   end
 end

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ Bundler.setup(:default, :test)
 Bundler.require(:default, :test)
 
 require 'rspec'
+require 'rspec/its'
 require 'redis'
 require 'logger'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-namespace
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Chris Wanstrath
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-03 00:00:00.000000000 Z
+date: 2019-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -47,14 +47,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  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
@@ -87,17 +101,16 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Namespaces Redis commands.