mock_redis 0.14.1 → 0.15.0

data/lib/mock_redis/version.rb

@@ -1,4 +1,4 @@
 # Defines the gem version.
 class MockRedis
-  VERSION = '0.14.1'
+  VERSION = '0.15.0'
 end

data/lib/mock_redis/zset.rb

@@ -12,7 +12,7 @@ class MockRedis
 
     def initialize
       @members = Set.new
-      @scores  = Hash.new
+      @scores  = {}
     end
 
     def initialize_copy(source)
@@ -33,39 +33,39 @@ class MockRedis
 
     def delete?(member)
       scores.delete(member)
-      members.delete?(member) and self
+      members.delete?(member) && self
     end
 
     def each
-      members.each {|m| yield score(m), m}
+      members.each { |m| yield score(m), m }
     end
 
     def in_range(min, max)
       in_from_the_left = case min
-                         when "-inf"
-                             lambda {|_| true }
-                         when "+inf"
-                             lambda {|_| false }
+                         when '-inf'
+                           lambda { |_| true }
+                         when '+inf'
+                           lambda { |_| false }
                          when /\((.*)$/
-                             val = $1.to_f
-                           lambda {|x| x.to_f > val }
+                           val = $1.to_f
+                           lambda { |x| x.to_f > val }
                          else
-                           lambda {|x| x.to_f >= min.to_f }
+                           lambda { |x| x.to_f >= min.to_f }
                          end
 
       in_from_the_right = case max
-                          when "-inf"
-                              lambda {|_| false }
-                          when "+inf"
-                              lambda {|_| true }
+                          when '-inf'
+                            lambda { |_| false }
+                          when '+inf'
+                            lambda { |_| true }
                           when /\((.*)$/
-                              val = $1.to_f
-                            lambda {|x| x.to_f < val }
+                            val = $1.to_f
+                            lambda { |x| x.to_f < val }
                           else
-                            lambda {|x| x.to_f <= max.to_f }
+                            lambda { |x| x.to_f <= max.to_f }
                           end
 
-      sorted.find_all do |(score, member)|
+      sorted.find_all do |(score, _member)|
         in_from_the_left[score] && in_from_the_right[score]
       end
     end
@@ -74,8 +74,8 @@ class MockRedis
       if !block_given?
         intersection(other, &:+)
       else
-        self.members.intersection(other.members).reduce(self.class.new) do |acc, m|
-          new_score = yield(self.score(m), other.score(m))
+        members.intersection(other.members).reduce(self.class.new) do |acc, m|
+          new_score = yield(score(m), other.score(m))
           acc.add(new_score, m)
         end
       end
@@ -99,12 +99,11 @@ class MockRedis
       if !block_given?
         union(other, &:+)
       else
-        self.members.union(other.members).reduce(self.class.new) do |acc, m|
-          new_score = yield(self.score(m), other.score(m))
+        members.union(other.members).reduce(self.class.new) do |acc, m|
+          new_score = yield(score(m), other.score(m))
           acc.add(new_score, m)
         end
       end
     end
-
   end
 end

data/lib/mock_redis/zset_methods.rb

@@ -21,9 +21,9 @@ class MockRedis
         score, member = args
         assert_scorey(score) unless score =~ /(\+|\-)inf/
         retval = !zscore(key, member)
-        with_zset_at(key) {|z| z.add(score, member.to_s)}
+        with_zset_at(key) { |z| z.add(score, member.to_s) }
       else
-        raise Redis::CommandError, "ERR wrong number of arguments"
+        raise Redis::CommandError, 'ERR wrong number of arguments'
       end
 
       retval
@@ -52,20 +52,20 @@ class MockRedis
       end
     end
 
-    def zinterstore(destination, keys, options={})
+    def zinterstore(destination, keys, options = {})
       assert_has_args(keys, 'zinterstore')
 
       data[destination] = combine_weighted_zsets(keys, options, :intersection)
       zcard(destination)
     end
 
-    def zrange(key, start, stop, options={})
+    def zrange(key, start, stop, options = {})
       with_zset_at(key) do |z|
         to_response(z.sorted[start.to_i..stop.to_i] || [], options)
       end
     end
 
-    def zrangebyscore(key, min, max, options={})
+    def zrangebyscore(key, min, max, options = {})
       assert_range_args(min, max)
 
       with_zset_at(key) do |zset|
@@ -75,12 +75,12 @@ class MockRedis
     end
 
     def zrank(key, member)
-      with_zset_at(key) {|z| z.sorted_members.index(member.to_s) }
+      with_zset_at(key) { |z| z.sorted_members.index(member.to_s) }
     end
 
     def zrem(key, *args)
       if !args.first.is_a?(Array)
-        retval = with_zset_at(key) {|z| !!z.delete?(args.first.to_s)}
+        retval = with_zset_at(key) { |z| !!z.delete?(args.first.to_s) }
       else
         args = args.first
         retval = args.map { |member| !!zscore(key, member.to_s) }.count(true)
@@ -92,7 +92,7 @@ class MockRedis
       retval
     end
 
-    def zrevrange(key, start, stop, options={})
+    def zrevrange(key, start, stop, options = {})
       with_zset_at(key) do |z|
         to_response(z.sorted.reverse[start..stop] || [], options)
       end
@@ -100,7 +100,7 @@ class MockRedis
 
     def zremrangebyrank(key, start, stop)
       zrange(key, start, stop).
-        each {|member| zrem(key, member)}.
+        each { |member| zrem(key, member) }.
         size
     end
 
@@ -108,11 +108,11 @@ class MockRedis
       assert_range_args(min, max)
 
       zrangebyscore(key, min, max).
-        each {|member| zrem(key, member)}.
+        each { |member| zrem(key, member) }.
         size
     end
 
-    def zrevrangebyscore(key, max, min, options={})
+    def zrevrangebyscore(key, max, min, options = {})
       assert_range_args(min, max)
 
       with_zset_at(key) do |zset|
@@ -125,7 +125,7 @@ class MockRedis
     end
 
     def zrevrank(key, member)
-      with_zset_at(key) {|z| z.sorted_members.reverse.index(member.to_s) }
+      with_zset_at(key) { |z| z.sorted_members.reverse.index(member.to_s) }
     end
 
     def zscore(key, member)
@@ -135,7 +135,7 @@ class MockRedis
       end
     end
 
-    def zunionstore(destination, keys, options={})
+    def zunionstore(destination, keys, options = {})
       assert_has_args(keys, 'zunionstore')
 
       data[destination] = combine_weighted_zsets(keys, options, :union)
@@ -143,13 +143,14 @@ class MockRedis
     end
 
     private
+
     def apply_limit(collection, limit)
       if limit
         if limit.is_a?(Array) && limit.length == 2
           offset, count = limit
           collection.drop(offset).take(count)
         else
-          raise Redis::CommandError, "ERR syntax error"
+          raise Redis::CommandError, 'ERR syntax error'
         end
       else
         collection
@@ -157,7 +158,7 @@ class MockRedis
     end
 
     def to_response(score_member_pairs, options)
-      score_member_pairs.map do |(score,member)|
+      score_member_pairs.map do |(score, member)|
         if options[:with_scores] || options[:withscores]
           [member, score.to_f]
         else
@@ -169,18 +170,18 @@ class MockRedis
     def combine_weighted_zsets(keys, options, how)
       weights = options.fetch(:weights, keys.map { 1 })
       if weights.length != keys.length
-        raise Redis::CommandError, "ERR syntax error"
+        raise Redis::CommandError, 'ERR syntax error'
       end
 
       aggregator = case options.fetch(:aggregate, :sum).to_s.downcase.to_sym
                    when :sum
-                     proc {|a,b| [a,b].compact.reduce(&:+)}
+                     proc { |a, b| [a, b].compact.reduce(&:+) }
                    when :min
-                     proc {|a,b| [a,b].compact.min}
+                     proc { |a, b| [a, b].compact.min }
                    when :max
-                     proc {|a,b| [a,b].compact.max}
+                     proc { |a, b| [a, b].compact.max }
                    else
-                     raise Redis::CommandError, "ERR syntax error"
+                     raise Redis::CommandError, 'ERR syntax error'
                    end
 
       with_zsets_at(*keys) do |*zsets|
@@ -192,11 +193,10 @@ class MockRedis
           za.send(how, zb, &aggregator)
         end
       end
-
     end
 
     def with_zset_at(key, &blk)
-      with_thing_at(key, :assert_zsety, proc {Zset.new}, &blk)
+      with_thing_at(key, :assert_zsety, proc { Zset.new }, &blk)
     end
 
     def with_zsets_at(*keys, &blk)
@@ -212,13 +212,13 @@ class MockRedis
     end
 
     def zsety?(key)
-      data[key].nil? || data[key].kind_of?(Zset)
+      data[key].nil? || data[key].is_a?(Zset)
     end
 
     def assert_zsety(key)
       unless zsety?(key)
         raise Redis::CommandError,
-        "WRONGTYPE Operation against a key holding the wrong kind of value"
+        'WRONGTYPE Operation against a key holding the wrong kind of value'
       end
     end
 
@@ -227,7 +227,7 @@ class MockRedis
       !!Float(x) rescue false
     end
 
-    def assert_scorey(value, message = "ERR value is not a valid float")
+    def assert_scorey(value, message = 'ERR value is not a valid float')
       return if value =~ /\(?(\-|\+)inf/
 
       value = $1 if value.to_s.match(/\((.*)/)

data/spec/cloning_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe "MockRedis#clone" do
+describe 'MockRedis#clone' do
   before do
     @mock = MockRedis.new
   end
 
-  context "the stored data" do
+  context 'the stored data' do
     before do
       @mock.set('foo', 'bar')
       @mock.hset('foohash', 'bar', 'baz')
@@ -16,60 +16,60 @@ describe "MockRedis#clone" do
       @clone = @mock.clone
     end
 
-    it "copies the stored data to the clone" do
+    it 'copies the stored data to the clone' do
       @clone.get('foo').should == 'bar'
     end
 
-    it "performs a deep copy (string values)" do
+    it 'performs a deep copy (string values)' do
       @mock.del('foo')
       @clone.get('foo').should == 'bar'
     end
 
-    it "performs a deep copy (list values)" do
+    it 'performs a deep copy (list values)' do
       @mock.lpop('foolist')
       @clone.lrange('foolist', 0, 1).should == ['bar']
     end
 
-    it "performs a deep copy (hash values)" do
+    it 'performs a deep copy (hash values)' do
       @mock.hset('foohash', 'bar', 'quux')
-      @clone.hgetall('foohash').should == {'bar' => 'baz'}
+      @clone.hgetall('foohash').should == { 'bar' => 'baz' }
     end
 
-    it "performs a deep copy (set values)" do
+    it 'performs a deep copy (set values)' do
       @mock.srem('fooset', 'bar')
       @clone.smembers('fooset').should == ['bar']
     end
 
-    it "performs a deep copy (zset values)" do
+    it 'performs a deep copy (zset values)' do
       @mock.zadd('foozset', 2, 'bar')
       @clone.zscore('foozset', 'bar').should == 1.0
     end
   end
 
-  context "expiration times" do
+  context 'expiration times' do
     before do
       @mock.set('foo', 1)
-      @mock.expire('foo', 60026)
+      @mock.expire('foo', 60_026)
 
       @clone = @mock.clone
     end
 
-    it "copies the expiration times" do
+    it 'copies the expiration times' do
       @clone.ttl('foo').should > 0
     end
 
-    it "deep-copies the expiration times" do
+    it 'deep-copies the expiration times' do
       @mock.persist('foo')
       @clone.ttl('foo').should > 0
     end
 
-    it "deep-copies the expiration times" do
+    it 'deep-copies the expiration times' do
       @clone.persist('foo')
       @mock.ttl('foo').should > 0
     end
   end
 
-  context "transactional info" do
+  context 'transactional info' do
     before do
       @mock.multi
       @mock.incr('foo')
@@ -79,18 +79,17 @@ describe "MockRedis#clone" do
       @clone = @mock.clone
     end
 
-    it "makes sure the clone is in a transaction" do
+    it 'makes sure the clone is in a transaction' do
       lambda do
         @clone.exec
       end.should_not raise_error
     end
 
-    it "deep-copies the queued commands" do
+    it 'deep-copies the queued commands' do
       @clone.incrby('foo', 8)
       @clone.exec.should == [1, 3, 7, 15]
 
       @mock.exec.should == [1, 3, 7]
     end
   end
-
 end

data/spec/commands/append_spec.rb

@@ -3,22 +3,22 @@ require 'spec_helper'
 describe '#append(key, value)' do
   before { @key = 'mock-redis-test:append' }
 
-  it "returns the new length of the string" do
+  it 'returns the new length of the string' do
     @redises.set(@key, 'porkchop')
     @redises.append(@key, 'sandwiches').should == 18
   end
 
-  it "appends value to the previously-stored value" do
+  it 'appends value to the previously-stored value' do
     @redises.set(@key, 'porkchop')
     @redises.append(@key, 'sandwiches')
 
     @redises.get(@key).should == 'porkchopsandwiches'
   end
 
-  it "treats a missing key as an empty string" do
+  it 'treats a missing key as an empty string' do
     @redises.append(@key, 'foo')
     @redises.get(@key).should == 'foo'
   end
 
-  it_should_behave_like "a string-only command"
+  it_should_behave_like 'a string-only command'
 end

data/spec/commands/auth_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "#auth(password) [mock only]" do
+describe '#auth(password) [mock only]' do
   it "just returns 'OK'" do
     @redises.mock.auth('foo').should == 'OK'
   end

data/spec/commands/bgrewriteaof_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe "#bgrewriteaof [mock only]" do
-  it "just returns a canned string" do
+describe '#bgrewriteaof [mock only]' do
+  it 'just returns a canned string' do
     @redises.mock.bgrewriteaof.should =~ /append/
   end
 end

data/spec/commands/bgsave_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe "#bgsave [mock only]" do
-  it "just returns a canned string" do
+describe '#bgsave [mock only]' do
+  it 'just returns a canned string' do
     @redises.mock.bgsave.should =~ /saving/
   end
 end

data/spec/commands/bitcount_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe "#bitcount(key [, start, end ])" do
+describe '#bitcount(key [, start, end ])' do
   before do
     @key = 'mock-redis-test:bitcount'
-    @redises.set(@key, "foobar")
+    @redises.set(@key, 'foobar')
   end
 
   it 'gets the number of set bits from the key' do
@@ -21,5 +21,5 @@ describe "#bitcount(key [, start, end ])" do
     @redises.bitcount('mock-redis-test:not-found').should == 0
   end
 
-  it_should_behave_like "a string-only command"
+  it_should_behave_like 'a string-only command'
 end