redis-namespace 1.2.2 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa794503f48ad056c80d9818eb87c16a415c192e
-  data.tar.gz: 0bdecba8c61e4b22523efd01ae57f812b0c5b535
+  metadata.gz: e20a131134003e74cb1b40bcf3ad11c61dae9d9d
+  data.tar.gz: f7718c7e9ea9ce7e8a46889c78bebe9a7d4a09ff
 SHA512:
-  metadata.gz: 2c1c8657d3fd3c5de3537f2c7569a6170b05bfa75b578343b345490d9c1c5c44c144b091cb70e32a92f7ff17eca3386c2ccafa76ea4dc2b8dd3db8da3f893c99
-  data.tar.gz: 64d2c5f885c88482f599a77ecb30c5fe7fd4d756a980451bfa2d86a04898d2eed70d7d0ed68fadfdf16603aba180c9846ebb2064b7dafd8c73354ee2d3aa7eff
+  metadata.gz: 00d8dca8c63810e4029cfc5430bb1507f9a1736320633ab703b049fc249c35160d1018151e7f6825f0eba960e868b82e7bd1836c6130fe850941b2825d5dfafd
+  data.tar.gz: 0fd499ddcf3c019525f6393eb4ba5957ebee559727924ea3c827e20cd57f818cca7e246ace91cea209b3914c7c0dde57e57e334aeab1af4d3e26b88fa7a1a38e

data/Rakefile

@@ -1,7 +1,13 @@
-task :default => :spec
-task :test    => :spec
+require 'rubygems'
+require "rspec/core/rake_task"
+
+require "bundler/gem_tasks"
 
-desc "Run specs"
-task :spec do
-  exec "rspec spec/redis_spec.rb"
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/*_spec.rb'
+  spec.rspec_opts = ['--backtrace']
+  spec.ruby_opts = ['-w']
 end
+
+task :default => :spec
+task :test    => :spec

data/lib/redis/namespace.rb

@@ -64,6 +64,8 @@ class Redis
       "exists"           => [ :first ],
       "expire"           => [ :first ],
       "expireat"         => [ :first ],
+      "eval"             => [ :eval_style ],
+      "evalsha"          => [ :eval_style ],
       "flushall"         => [],
       "flushdb"          => [],
       "get"              => [ :first ],
@@ -102,6 +104,8 @@ class Redis
       "mapped_hmset"     => [ :first ],
       "mapped_hmget"     => [ :first ],
       "mapped_mget"      => [ :all, :all ],
+      "mapped_mset"      => [ :all ],
+      "mapped_msetnx"    => [ :all ],
       "mget"             => [ :all ],
       "monitor"          => [ :monitor ],
       "move"             => [ :first ],
@@ -182,12 +186,14 @@ class Redis
               else {}
               end
 
-    attr_accessor :namespace
+    attr_writer :namespace
     attr_reader :redis
+    attr_accessor :warning
 
     def initialize(namespace, options = {})
       @namespace = namespace
       @redis = options[:redis] || Redis.current
+      @warning = options[:warning] || false
     end
 
     # Ruby defines a now deprecated type method so we need to override it here
@@ -210,8 +216,21 @@ class Redis
       query.nil? ? super("*") : super
     end
 
-    def exec
-      method_missing(:exec)
+    def multi(&block)
+      namespaced_block(:multi, &block)
+    end
+
+    def pipelined(&block)
+      namespaced_block(:pipelined, &block)
+    end
+
+    def namespace(desired_namespace = nil)
+      if desired_namespace
+        yield Redis::Namespace.new(desired_namespace,
+                                   :redis => @redis)
+      end
+
+      @namespace
     end
 
     def method_missing(command, *args, &block)
@@ -219,8 +238,10 @@ class Redis
         COMMANDS[ALIASES[command.to_s]]
 
       # redis-namespace does not know how to handle this command.
-      # Passing it to @redis as is.
+      # Passing it to @redis as is, where redis-namespace shows
+      # a warning message if @warning is set.
       if handling.nil?
+        warn("Passing '#{command}' command to redis as is.") if @warning
         return @redis.send(command, *args, &block)
       end
 
@@ -237,7 +258,7 @@ class Redis
         args = add_namespace(args)
         args.unshift(first) if first
       when :exclude_last
-        last = args.pop
+        last = args.pop unless args.length == 1
         args = add_namespace(args)
         args.push(last) if last
       when :exclude_options
@@ -252,9 +273,33 @@ class Redis
         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]
-        [:by, :get, :store].each do |key|
-          args[1][key] = add_namespace(args[1][key]) if args[1][key]
-        end if args[1].is_a?(Hash)
+        if args[1].is_a?(Hash)
+          [:by, :store].each do |key|
+            args[1][key] = add_namespace(args[1][key]) if args[1][key]
+          end
+
+          args[1][:get] = Array(args[1][:get])
+
+          args[1][:get].each_index do |i|
+            args[1][:get][i] = add_namespace(args[1][:get][i]) unless args[1][:get][i] == "#"
+          end
+        end
+      when :eval_style
+        # redis.eval() and evalsha() can either take the form:
+        #
+        #   redis.eval(script, [key1, key2], [argv1, argv2])
+        #
+        # Or:
+        #
+        #   redis.eval(script, :keys => ['k1', 'k2'], :argv => ['arg1', 'arg2'])
+        #
+        # This is a tricky + annoying special case, where we only want the `keys`
+        # argument to be namespaced.
+        if args.last.is_a?(Hash)
+          args.last[:keys] = add_namespace(args.last[:keys])
+        else
+          args[1] = add_namespace(args[1])
+        end
       end
 
       # Dispatch the command to Redis and store the result.
@@ -272,6 +317,17 @@ class Redis
     end
 
   private
+
+    def namespaced_block(command, &block)
+      original = @redis
+      result = redis.send(command) do |r|
+        @redis = r
+        yield self
+      end
+      @redis = original
+      result
+    end
+
     def add_namespace(key)
       return key unless key && @namespace
 
@@ -294,7 +350,7 @@ class Redis
       when Hash
         Hash[*key.map {|k, v| [ rem_namespace(k), v ]}.flatten]
       else
-        key.to_s.gsub /^#{@namespace}:/, ""
+        key.to_s.gsub(/^#{@namespace}:/, "")
       end
     end
   end

data/spec/redis_spec.rb

@@ -23,28 +23,30 @@ describe "redis" do
   end
 
   it "proxies `client` to the client" do
-    @namespaced.client.should == @redis.client
+    @namespaced.client.should eq(@redis.client)
   end
 
   it "should be able to use a namespace" do
-    @namespaced['foo'].should == nil
+    @namespaced['foo'].should eq(nil)
     @namespaced['foo'] = 'chris'
-    @namespaced['foo'].should == 'chris'
+    @namespaced['foo'].should eq('chris')
     @redis['foo'] = 'bob'
-    @redis['foo'].should == 'bob'
+    @redis['foo'].should eq('bob')
 
     @namespaced.incrby('counter', 2)
-    @namespaced['counter'].to_i.should == 2
-    @redis['counter'].should == nil
-    @namespaced.type('counter').should == 'string'
+    @namespaced['counter'].to_i.should eq(2)
+    @redis['counter'].should eq(nil)
+    @namespaced.type('counter').should eq('string')
   end
 
   it "should be able to use a namespace with bpop" do
     @namespaced.rpush "foo", "string"
     @namespaced.rpush "foo", "ns:string"
-    @namespaced.blpop("foo", 1).should == ["foo", "string"]
-    @namespaced.blpop("foo", 1).should == ["foo", "ns:string"]
-    @namespaced.blpop("foo", 1).should == nil
+    @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)
   end
 
   it "should be able to use a namespace with del" do
@@ -52,114 +54,126 @@ describe "redis" do
     @namespaced['bar'] = 2000
     @namespaced['baz'] = 3000
     @namespaced.del 'foo'
-    @namespaced['foo'].should == nil
+    @namespaced['foo'].should eq(nil)
     @namespaced.del 'bar', 'baz'
-    @namespaced['bar'].should == nil
-    @namespaced['baz'].should == nil
+    @namespaced['bar'].should eq(nil)
+    @namespaced['baz'].should eq(nil)
   end
 
   it 'should be able to use a namespace with append' do
     @namespaced['foo'] = 'bar'
-    @namespaced.append('foo','n').should == 4
-    @namespaced['foo'].should == 'barn'
-    @redis['foo'].should == 'bar'
+    @namespaced.append('foo','n').should eq(4)
+    @namespaced['foo'].should eq('barn')
+    @redis['foo'].should eq('bar')
   end
 
   it 'should be able to use a namespace with brpoplpush' do
     @namespaced.lpush('foo','bar')
-    @namespaced.brpoplpush('foo','bar',0).should == 'bar'
-    @namespaced.lrange('foo',0,-1).should == []
-    @namespaced.lrange('bar',0,-1).should == ['bar']
+    @namespaced.brpoplpush('foo','bar',0).should eq('bar')
+    @namespaced.lrange('foo',0,-1).should eq([])
+    @namespaced.lrange('bar',0,-1).should eq(['bar'])
   end
 
   it 'should be able to use a namespace with getbit' do
     @namespaced.set('foo','bar')
-    @namespaced.getbit('foo',1).should == 1
+    @namespaced.getbit('foo',1).should eq(1)
   end
 
   it 'should be able to use a namespace with getrange' do
     @namespaced.set('foo','bar')
-    @namespaced.getrange('foo',0,-1).should == 'bar'
+    @namespaced.getrange('foo',0,-1).should 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 == 4
-    @namespaced.lrange('foo',0,-1).should == ['bar','barf','barn','bart']
+    @namespaced.linsert('foo','BEFORE','barn','barf').should eq(4)
+    @namespaced.lrange('foo',0,-1).should eq(['bar','barf','barn','bart'])
   end
 
   it 'should be able to use a namespace with lpushx' do
-    @namespaced.lpushx('foo','bar').should == 0
+    @namespaced.lpushx('foo','bar').should eq(0)
     @namespaced.lpush('foo','boo')
-    @namespaced.lpushx('foo','bar').should == 2
-    @namespaced.lrange('foo',0,-1).should == ['bar','boo']
+    @namespaced.lpushx('foo','bar').should eq(2)
+    @namespaced.lrange('foo',0,-1).should eq(['bar','boo'])
   end
 
   it 'should be able to use a namespace with rpushx' do
-    @namespaced.rpushx('foo','bar').should == 0
+    @namespaced.rpushx('foo','bar').should eq(0)
     @namespaced.lpush('foo','boo')
-    @namespaced.rpushx('foo','bar').should == 2
-    @namespaced.lrange('foo',0,-1).should == ['boo','bar']
+    @namespaced.rpushx('foo','bar').should eq(2)
+    @namespaced.lrange('foo',0,-1).should 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 == @namespaced.getrange('virgin_key',0,-1)
+    @namespaced.get('virgin_key').should eq(@namespaced.getrange('virgin_key',0,-1))
   end
 
   it 'should be able to use a namespace with setrange' do
     @namespaced.setrange('foo', 0, 'bar')
-    @namespaced['foo'].should == 'bar'
+    @namespaced['foo'].should eq('bar')
 
     @namespaced.setrange('bar', 2, 'foo')
-    @namespaced['bar'].should == "\000\000foo"
+    @namespaced['bar'].should eq("\000\000foo")
   end
 
   it "should be able to use a namespace with mget" do
     @namespaced['foo'] = 1000
     @namespaced['bar'] = 2000
-    @namespaced.mapped_mget('foo', 'bar').should == { 'foo' => '1000', 'bar' => '2000' }
-    @namespaced.mapped_mget('foo', 'baz', 'bar').should == {'foo'=>'1000', 'bar'=>'2000', 'baz' => nil}
+    @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})
   end
 
   it "should be able to use a namespace with mset" do
     @namespaced.mset('foo', '1000', 'bar', '2000')
-    @namespaced.mapped_mget('foo', 'bar').should == { 'foo' => '1000', 'bar' => '2000' }
-    @namespaced.mapped_mget('foo', 'baz', 'bar').should == { 'foo' => '1000', 'bar' => '2000', 'baz' => nil}
+    @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})
+    @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})
   end
 
   it "should be able to use a namespace with msetnx" do
     @namespaced.msetnx('foo', '1000', 'bar', '2000')
-    @namespaced.mapped_mget('foo', 'bar').should == { 'foo' => '1000', 'bar' => '2000' }
-    @namespaced.mapped_mget('foo', 'baz', 'bar').should == { 'foo' => '1000', 'bar' => '2000', 'baz' => nil}
+    @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})
+  end
+
+  it "should be able to use a namespace with mapped_msetnx" do
+    puts @namespaced.keys.inspect
+    @namespaced.set('foo','1')
+    @namespaced.mapped_msetnx('foo'=>'1000', 'bar'=>'2000').should be_false
+    @namespaced.mapped_mget('foo', 'bar').should == { 'foo' => '1', 'bar' => nil }
+    @namespaced.mapped_msetnx('bar'=>'2000', 'baz'=>'1000').should be_true
+    @namespaced.mapped_mget('foo', 'bar').should == { '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 == 'value'
-    @namespaced.hgetall('foo').should == {'key' => 'value', 'key1' => 'value1'}
-    @namespaced.hlen('foo').should == 2
-    @namespaced.hkeys('foo').should == ['key', 'key1']
+    @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'])
     @namespaced.hmset('bar', 'key', 'value', 'key1', 'value1')
     @namespaced.hmget('bar', 'key', 'key1')
     @namespaced.hmset('bar', 'a_number', 1)
-    @namespaced.hmget('bar', 'a_number').should == ['1']
+    @namespaced.hmget('bar', 'a_number').should eq(['1'])
     @namespaced.hincrby('bar', 'a_number', 3)
-    @namespaced.hmget('bar', 'a_number').should == ['4']
-    @namespaced.hgetall('bar').should == {'key' => 'value', 'key1' => 'value1', 'a_number' => '4'}
+    @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 == "10"
-    @namespaced.hkeys('foonx').should     == %w{ nx }
-    @namespaced.hvals('foonx').should     == %w{ 10 }
+    @namespaced.hget('foonx','nx').should eq("10")
+    @namespaced.hkeys('foonx').should eq(%w{ nx })
+    @namespaced.hvals('foonx').should eq(%w{ 10 })
     @namespaced.mapped_hmset('baz', {'key' => 'value', 'key1' => 'value1', 'a_number' => 4})
-    @namespaced.mapped_hmget('baz', 'key', 'key1', 'a_number').should == {'key' => 'value', 'key1' => 'value1', 'a_number' => '4'}
-    @namespaced.hgetall('baz').should == {'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'})
   end
 
   it "should properly intersect three sets" do
@@ -170,7 +184,7 @@ describe "redis" do
     @namespaced.sadd('bar', 3)
     @namespaced.sadd('bar', 4)
     @namespaced.sadd('baz', 3)
-    @namespaced.sinter('foo', 'bar', 'baz').should == %w( 3 )
+    @namespaced.sinter('foo', 'bar', 'baz').should eq(%w( 3 ))
   end
 
   it "should properly union two sets" do
@@ -179,7 +193,7 @@ describe "redis" do
     @namespaced.sadd('bar', 2)
     @namespaced.sadd('bar', 3)
     @namespaced.sadd('bar', 4)
-    @namespaced.sunion('foo', 'bar').sort.should == %w( 1 2 3 4 )
+    @namespaced.sunion('foo', 'bar').sort.should eq(%w( 1 2 3 4 ))
   end
 
   it "should properly union two sorted sets with options" do
@@ -189,7 +203,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 == %w( 2 4 3 1 )
+    @namespaced.zrevrange('union', 0, -1).should eq(%w( 2 4 3 1 ))
   end
 
   it "should properly union two sorted sets without options" do
@@ -199,7 +213,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 == %w( 4 2 3 1 )
+    @namespaced.zrevrange('union', 0, -1).should eq(%w( 4 2 3 1 ))
   end
 
   it "should add namespace to sort" do
@@ -210,43 +224,99 @@ describe "redis" do
     @namespaced.set('value_1', 'a')
     @namespaced.set('value_2', 'b')
 
-    @namespaced.sort('foo').should == %w( 1 2 )
-    @namespaced.sort('foo', :limit => [0, 1]).should == %w( 1 )
-    @namespaced.sort('foo', :order => 'desc').should == %w( 2 1 )
-    @namespaced.sort('foo', :by => 'weight_*').should == %w( 2 1 )
-    @namespaced.sort('foo', :get => 'value_*').should == %w( a 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"]])
 
     @namespaced.sort('foo', :store => 'result')
-    @namespaced.lrange('result', 0, -1).should == %w( 1 2 )
+    @namespaced.lrange('result', 0, -1).should eq(%w( 1 2 ))
   end
 
   it "should yield the correct list of keys" do
     @namespaced["foo"] = 1
     @namespaced["bar"] = 2
     @namespaced["baz"] = 3
-    @namespaced.keys("*").sort.should == %w( bar baz foo )
-    @namespaced.keys.sort.should == %w( bar baz foo )
+    @namespaced.keys("*").sort.should eq(%w( bar baz foo ))
+    @namespaced.keys.sort.should eq(%w( bar baz foo ))
+  end
+
+  it "should add namepsace to multi blocks" do
+    @namespaced.mapped_hmset "foo", {"key" => "value"}
+    @namespaced.multi do |r|
+      r.del "foo"
+      r.mapped_hmset "foo", {"key1" => "value1"}
+    end
+    @namespaced.hgetall("foo").should eq({"key1" => "value1"})
+  end
+
+  it "should add namespace to pipelined blocks" do
+    @namespaced.mapped_hmset "foo", {"key" => "value"}
+    @namespaced.pipelined do |r|
+      r.del "foo"
+      r.mapped_hmset "foo", {"key1" => "value1"}
+    end
+    @namespaced.hgetall("foo").should eq({"key1" => "value1"})
+  end
+
+  it "should returned response array from pipelined block" do
+    @namespaced.mset "foo", "bar", "key", "value"
+    result = @namespaced.pipelined do |r|
+      r["foo"]
+      r["key"]
+    end
+    result.should eq(["bar", "value"])
   end
 
   it "can change its namespace" do
-    @namespaced['foo'].should == nil
+    @namespaced['foo'].should eq(nil)
     @namespaced['foo'] = 'chris'
-    @namespaced['foo'].should == 'chris'
+    @namespaced['foo'].should eq('chris')
 
-    @namespaced.namespace.should == :ns
+    @namespaced.namespace.should eq(:ns)
     @namespaced.namespace = :spec
-    @namespaced.namespace.should == :spec
+    @namespaced.namespace.should eq(:spec)
 
-    @namespaced['foo'].should == nil
+    @namespaced['foo'].should eq(nil)
     @namespaced['foo'] = 'chris'
-    @namespaced['foo'].should == 'chris'
+    @namespaced['foo'].should eq('chris')
+  end
+
+  it "can accept a temporary namespace" do
+    @namespaced.namespace.should eq(:ns)
+    @namespaced['foo'].should eq(nil)
+
+    @namespaced.namespace(:spec) do |temp_ns|
+      temp_ns.namespace.should eq(:spec)
+      temp_ns['foo'].should eq(nil)
+      temp_ns['foo'] = 'jake'
+      temp_ns['foo'].should eq('jake')
+    end
+
+    @namespaced.namespace.should eq(:ns)
+    @namespaced['foo'].should eq(nil)
   end
 
   it "should respond to :namespace=" do
-    @namespaced.respond_to?(:namespace=).should == true
+    @namespaced.respond_to?(:namespace=).should eq(true)
+  end
+
+  it "should respond to :warning=" do
+    @namespaced.respond_to?(:warning=).should == true
+  end
+
+  it "should warn against unknown commands if :warning is true" do
+    @namespaced.warning = true
+    capture_stderr {
+      @namespaced.unknown('foo')
+    }.should == "Passing 'unknown' command to redis as is."
   end
 
-  if @redis_version >= Gem::Version.new("2.6.0")
+  # 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
       it "should namespace bitcount" do
         pending "awaiting implementaton of command in redis gem"
@@ -262,50 +332,80 @@ describe "redis" do
 
       it "should namespace hincrbyfloat" do
         @namespaced.hset('mykey', 'field', 10.50)
-        @namespaced.hincrbyfloat('mykey', 'field', 0.1).should == 10.6
+        @namespaced.hincrbyfloat('mykey', 'field', 0.1).should eq(10.6)
       end
 
       it "should namespace incrbyfloat" do
         @namespaced.set('mykey', 10.50)
-        @namespaced.incrbyfloat('mykey', 0.1).should == 10.6
+        @namespaced.incrbyfloat('mykey', 0.1).should eq(10.6)
       end
 
       it "should namespace object" do
         @namespaced.set('foo', 1000)
-        @namespaced.object('encoding', 'foo').should == 'int'
+        @namespaced.object('encoding', 'foo').should eq('int')
       end
 
       it "should namespace persist" do
         @namespaced.set('mykey', 'Hello')
         @namespaced.expire('mykey', 60)
-        @namespaced.persist('mykey').should == true
-        @namespaced.ttl('mykey').should == -1
+        @namespaced.persist('mykey').should eq(true)
+        @namespaced.ttl('mykey').should eq(-1)
       end
 
       it "should namespace pexpire" do
         @namespaced.set('mykey', 'Hello')
-        @namespaced.pexpire('mykey', 60000).should == true
+        @namespaced.pexpire('mykey', 60000).should eq(true)
       end
 
       it "should namespace pexpireat" do
         @namespaced.set('mykey', 'Hello')
-        @namespaced.pexpire('mykey', 1555555555005).should == true
+        @namespaced.pexpire('mykey', 1555555555005).should eq(true)
       end
 
       it "should namespace psetex" do
-        @namespaced.psetex('mykey', 10000, 'Hello').should == 'OK'
-        @namespaced.get('mykey').should == 'Hello'
+        @namespaced.psetex('mykey', 10000, 'Hello').should eq('OK')
+        @namespaced.get('mykey').should eq('Hello')
       end
 
       it "should namespace pttl" do
         @namespaced.set('mykey', 'Hello')
         @namespaced.expire('mykey', 1)
-        @namespaced.pttl('mykey').should == 1000
+        @namespaced.pttl('mykey').should >= 0
       end
 
       it "should namespace restore" do
         pending "awaiting implementaton of command in redis gem"
       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])
+      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])
+      end
+
+      context '#evalsha' do
+        let!(:sha) do
+          @namespaced.script(:load, "return {KEYS[1], KEYS[2]}")
+        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])
+        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])
+        end
+      end
     end
   end
 
@@ -323,12 +423,12 @@ describe "redis" do
 
     it "should support command aliases (push_head)" do
       @namespaced.push_head('bar', 'quux')
-      @redis.llen('ns:bar').should == 1
+      @redis.llen('ns:bar').should eq(1)
     end
 
     it "should support command aliases (zset_add)" do
       @namespaced.zset_add('bar', 1, 'quux')
-      @redis.zcard('ns:bar').should == 1
+      @redis.zcard('ns:bar').should eq(1)
     end
   end
 end

data/spec/spec_helper.rb

@@ -11,6 +11,20 @@ $TESTING=true
 $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 require 'redis/namespace'
 
+def capture_stderr
+  require 'stringio'
+  begin
+    original, $stderr = $stderr, StringIO.new
+    yield
+  rescue Redis::CommandError 
+    # ignore Redis::CommandError for test and
+    # return captured messages
+    $stderr.string.chomp
+  ensure
+    $stderr = original
+  end
+end
+
 RSpec::Matchers.define :have_key do |expected|
   match do |redis|
     redis.exists(expected)

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: redis-namespace
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.3.0
 platform: ruby
 authors:
 - Chris Wanstrath
 - Terence Lee
+- Steve Klabnik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-03 00:00:00.000000000 Z
+date: 2013-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -57,7 +58,10 @@ 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
   multiple, different applications.
-email: chris@ozmm.org
+email:
+- chris@ozmm.org
+- hone02@gmail.com
+- steve@steveklabnik.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -69,7 +73,7 @@ files:
 - lib/redis-namespace.rb
 - spec/redis_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/defunkt/redis-namespace
+homepage: http://github.com/resque/redis-namespace
 licenses: []
 metadata: {}
 post_install_message: 
@@ -88,8 +92,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.2
+rubygems_version: 2.0.0
 signing_key: 
 specification_version: 4
 summary: Namespaces Redis commands.
 test_files: []
+has_rdoc: false