mock_redis 0.14.1 → 0.15.0

data/lib/mock_redis/multi_db_wrapper.rb

@@ -9,11 +9,11 @@ class MockRedis
 
       @prototype_db = db.clone
 
-      @databases = Hash.new {|h,k| h[k] = @prototype_db.clone}
+      @databases = Hash.new { |h, k| h[k] = @prototype_db.clone }
       @databases[@db_index] = db
     end
 
-    def respond_to?(method, include_private=false)
+    def respond_to?(method, include_private = false)
       super || current_db.respond_to?(method, include_private)
     end
 
@@ -44,7 +44,7 @@ class MockRedis
       else
         case current_db.type(key)
         when 'hash'
-          dest.hmset(key, *(src.hgetall(key).map{|k,v| [k,v]}.flatten))
+          dest.hmset(key, *(src.hgetall(key).map { |k, v| [k, v] }.flatten))
         when 'list'
           while value = src.rpop(key)
             dest.lpush(key, value)
@@ -56,7 +56,7 @@ class MockRedis
         when 'string'
           dest.set(key, src.get(key))
         when 'zset'
-          src.zrange(key, 0, -1, :with_scores => true).each do |(m,s)|
+          src.zrange(key, 0, -1, :with_scores => true).each do |(m, s)|
             dest.zadd(key, s, m)
           end
         else
@@ -75,6 +75,7 @@ class MockRedis
     end
 
     private
+
     def current_db
       @databases[@db_index]
     end

data/lib/mock_redis/pipelined_wrapper.rb

@@ -2,7 +2,7 @@ class MockRedis
   class PipelinedWrapper
     include UndefRedisMethods
 
-    def respond_to?(method, include_private=false)
+    def respond_to?(method, include_private = false)
       super || @db.respond_to?(method)
     end
 
@@ -28,14 +28,14 @@ class MockRedis
       end
     end
 
-    def pipelined(options = {})
+    def pipelined(_options = {})
       @in_pipeline = true
       yield self
       @in_pipeline = false
       responses = @pipelined_futures.map do |future|
         begin
           result = send(*future.command)
-          future.set_result(result)
+          future.store_result(result)
           result
         rescue => e
           e

data/lib/mock_redis/set_methods.rb

@@ -13,7 +13,7 @@ class MockRedis
       with_set_at(key) do |s|
         if members.size > 1
           size_before = s.size
-          members.reverse.each {|m| s << m}
+          members.reverse_each { |m| s << m }
           s.size - size_before
         else
           !!s.add?(members.first)
@@ -22,12 +22,12 @@ class MockRedis
     end
 
     def scard(key)
-      with_set_at(key) {|s| s.length}
+      with_set_at(key) { |s| s.length }
     end
 
     def sdiff(*keys)
       assert_has_args(keys, 'sdiff')
-      with_sets_at(*keys) {|*sets| sets.reduce(&:-)}.to_a
+      with_sets_at(*keys) { |*sets| sets.reduce(&:-) }.to_a
     end
 
     def sdiffstore(destination, *keys)
@@ -55,7 +55,7 @@ class MockRedis
     end
 
     def sismember(key, member)
-      with_set_at(key) {|s| s.include?(member.to_s)}
+      with_set_at(key) { |s| s.include?(member.to_s) }
     end
 
     def smembers(key)
@@ -110,7 +110,7 @@ class MockRedis
 
     def sunion(*keys)
       assert_has_args(keys, 'sunion')
-      with_sets_at(*keys) {|*sets| sets.reduce(&:+).to_a}
+      with_sets_at(*keys) { |*sets| sets.reduce(&:+).to_a }
     end
 
     def sunionstore(destination, *keys)
@@ -122,8 +122,9 @@ class MockRedis
     end
 
     private
+
     def with_set_at(key, &blk)
-      with_thing_at(key, :assert_sety, proc {Set.new}, &blk)
+      with_thing_at(key, :assert_sety, proc { Set.new }, &blk)
     end
 
     def with_sets_at(*keys, &blk)
@@ -140,15 +141,15 @@ class MockRedis
     end
 
     def sety?(key)
-      data[key].nil? || data[key].kind_of?(Set)
+      data[key].nil? || data[key].is_a?(Set)
     end
 
     def assert_sety(key)
       unless sety?(key)
         # Not the most helpful error, but it's what redis-rb barfs up
-        raise Redis::CommandError, "WRONGTYPE Operation against a key holding the wrong kind of value"
+        raise Redis::CommandError,
+              'WRONGTYPE Operation against a key holding the wrong kind of value'
       end
     end
-
   end
 end

data/lib/mock_redis/sort_method.rb

@@ -4,7 +4,7 @@ class MockRedis
   module SortMethod
     include Assertions
 
-    def sort(key, options={})
+    def sort(key, options = {})
       return [] if key.nil?
 
       enumerable = data[key]
@@ -15,7 +15,7 @@ class MockRedis
       limit        = options[:limit] || []
       store        = options[:store]
       get_patterns = Array(options[:get])
-      order        = options[:order] || "ASC"
+      order        = options[:order] || 'ASC'
       direction    = order.split.first
 
       projected = project(enumerable, by, get_patterns)
@@ -27,8 +27,8 @@ class MockRedis
 
     private
 
-    ASCENDING_SORT  = Proc.new { |a, b| a.first <=> b.first }
-    DESCENDING_SORT = Proc.new { |a, b| b.first <=> a.first }
+    ASCENDING_SORT  = proc { |a, b| a.first <=> b.first }
+    DESCENDING_SORT = proc { |a, b| b.first <=> a.first }
 
     def project(enumerable, by, get_patterns)
       enumerable.map do |*elements|
@@ -38,7 +38,7 @@ class MockRedis
 
         if get_patterns.length > 0
           value = get_patterns.map do |pattern|
-            pattern == "#" ? element : lookup_from_pattern(pattern, element)
+            pattern == '#' ? element : lookup_from_pattern(pattern, element)
           end
           value = value.first if value.length == 1
         end
@@ -50,12 +50,12 @@ class MockRedis
     def sort_by(projected, direction)
       sorter =
         case direction.upcase
-          when "DESC"
-            DESCENDING_SORT
-          when "ASC", "ALPHA"
-            ASCENDING_SORT
-          else
-            raise "Invalid direction '#{direction}'"
+        when 'DESC'
+          DESCENDING_SORT
+        when 'ASC', 'ALPHA'
+          ASCENDING_SORT
+        else
+          raise "Invalid direction '#{direction}'"
         end
 
       projected.sort(&sorter).map(&:last)
@@ -77,6 +77,5 @@ class MockRedis
         get key
       end
     end
-
   end
 end

data/lib/mock_redis/string_methods.rb

@@ -6,7 +6,7 @@ class MockRedis
 
     def append(key, value)
       assert_stringy(key)
-      data[key] ||= ""
+      data[key] ||= ''
       data[key] << value
       data[key].length
     end
@@ -35,7 +35,7 @@ class MockRedis
       offset_within_byte = offset % 8
 
       # String#getbyte would be lovely, but it's not in 1.8.7.
-      byte = (data[key] || "").each_byte.drop(offset_of_byte).first
+      byte = (data[key] || '').each_byte.drop(offset_of_byte).first
 
       if byte
         (byte & (2**7 >> offset_within_byte)) > 0 ? 1 : 0
@@ -46,7 +46,7 @@ class MockRedis
 
     def getrange(key, start, stop)
       assert_stringy(key)
-      (data[key] || "")[start..stop]
+      (data[key] || '')[start..stop]
     end
 
     def getset(key, value)
@@ -62,11 +62,11 @@ class MockRedis
     def incrby(key, n)
       assert_stringy(key)
       unless can_incr?(data[key])
-        raise Redis::CommandError, "ERR value is not an integer or out of range"
+        raise Redis::CommandError, 'ERR value is not an integer or out of range'
       end
 
       unless looks_like_integer?(n.to_s)
-        raise Redis::CommandError, "ERR value is not an integer or out of range"
+        raise Redis::CommandError, 'ERR value is not an integer or out of range'
       end
 
       new_value = data[key].to_i + n.to_i
@@ -78,11 +78,11 @@ class MockRedis
     def incrbyfloat(key, n)
       assert_stringy(key)
       unless can_incr_float?(data[key])
-        raise Redis::CommandError, "ERR value is not a valid float"
+        raise Redis::CommandError, 'ERR value is not a valid float'
       end
 
       unless looks_like_float?(n.to_s)
-        raise Redis::CommandError, "ERR value is not a valid float"
+        raise Redis::CommandError, 'ERR value is not a valid float'
       end
 
       new_value = data[key].to_f + n.to_f
@@ -106,14 +106,14 @@ class MockRedis
     def mset(*kvpairs)
       assert_has_args(kvpairs, 'mset')
       if kvpairs.length.odd?
-        raise Redis::CommandError, "ERR wrong number of arguments for MSET"
+        raise Redis::CommandError, 'ERR wrong number of arguments for MSET'
       end
 
-      kvpairs.each_slice(2) do |(k,v)|
-        set(k,v)
+      kvpairs.each_slice(2) do |(k, v)|
+        set(k, v)
       end
 
-      "OK"
+      'OK'
     end
 
     def mapped_mset(hash)
@@ -123,7 +123,7 @@ class MockRedis
     def msetnx(*kvpairs)
       assert_has_args(kvpairs, 'msetnx')
 
-      if kvpairs.each_slice(2).any? {|(k,_)| exists(k)}
+      if kvpairs.each_slice(2).any? { |(k, _)| exists(k) }
         false
       else
         mset(*kvpairs)
@@ -171,16 +171,16 @@ class MockRedis
     end
 
     def setbit(key, offset, value)
-      assert_stringy(key, "ERR bit is not an integer or out of range")
+      assert_stringy(key, 'ERR bit is not an integer or out of range')
       retval = getbit(key, offset)
 
-      str = data[key] || ""
+      str = data[key] || ''
 
       offset_of_byte = offset / 8
       offset_within_byte = offset % 8
 
       if offset_of_byte >= str.bytesize
-        str = zero_pad(str, offset_of_byte+1)
+        str = zero_pad(str, offset_of_byte + 1)
       end
 
       char_index = byte_index = offset_within_char = 0
@@ -219,7 +219,7 @@ class MockRedis
     def bitcount(key, start = 0, stop = -1)
       assert_stringy(key)
 
-      str   = data[key] || ""
+      str   = data[key] || ''
       count = 0
       m1    = 0x5555555555555555
       m2    = 0x3333333333333333
@@ -231,10 +231,10 @@ class MockRedis
       str.bytes.to_a[start..stop].each do |byte|
         # Naive Hamming weight
         c = byte
-        c = (c & m1)  + ((c >> 1) & m1)
-        c = (c & m2)  + ((c >> 2) & m2)
-        c = (c & m4)  + ((c >> 4) & m4)
-        c = (c & m8)  + ((c >> 8) & m8)
+        c = (c & m1) + ((c >> 1) & m1)
+        c = (c & m2) + ((c >> 2) & m2)
+        c = (c & m4) + ((c >> 4) & m4)
+        c = (c & m8) + ((c >> 8) & m8)
         c = (c & m16) + ((c >> 16) & m16)
         c = (c & m32) + ((c >> 32) & m32)
         count += c
@@ -261,32 +261,29 @@ class MockRedis
     def setrange(key, offset, value)
       assert_stringy(key)
       value = value.to_s
-      old_value = (data[key] || "")
+      old_value = (data[key] || '')
 
       prefix = zero_pad(old_value[0...offset], offset)
-      data[key] = prefix + value + (old_value[(offset + value.length)..-1] || "")
+      data[key] = prefix + value + (old_value[(offset + value.length)..-1] || '')
       data[key].length
     end
 
     def strlen(key)
       assert_stringy(key)
-      (data[key] || "").bytesize
+      (data[key] || '').bytesize
     end
 
-
-
-
     private
+
     def stringy?(key)
-      data[key].nil? || data[key].kind_of?(String)
+      data[key].nil? || data[key].is_a?(String)
     end
 
     def assert_stringy(key,
-        message="WRONGTYPE Operation against a key holding the wrong kind of value")
+        message = 'WRONGTYPE Operation against a key holding the wrong kind of value')
       unless stringy?(key)
         raise Redis::CommandError, message
       end
     end
-
   end
 end

data/lib/mock_redis/transaction_wrapper.rb

@@ -4,7 +4,7 @@ class MockRedis
   class TransactionWrapper
     include UndefRedisMethods
 
-    def respond_to?(method, include_private=false)
+    def respond_to?(method, include_private = false)
       super || @db.respond_to?(method)
     end
 
@@ -39,7 +39,7 @@ class MockRedis
 
     def discard
       unless @in_multi
-        raise Redis::CommandError, "ERR DISCARD without MULTI"
+        raise Redis::CommandError, 'ERR DISCARD without MULTI'
       end
       @in_multi = false
       @multi_block_given = false
@@ -49,7 +49,7 @@ class MockRedis
 
     def exec
       unless @in_multi
-        raise Redis::CommandError, "ERR EXEC without MULTI"
+        raise Redis::CommandError, 'ERR EXEC without MULTI'
       end
       @in_multi = false
       @multi_block_given = false
@@ -57,7 +57,7 @@ class MockRedis
       responses = @transaction_futures.map do |future|
         begin
           result = send(*future.command)
-          future.set_result(result)
+          future.store_result(result)
           result
         rescue => e
           e
@@ -70,16 +70,16 @@ class MockRedis
 
     def multi
       if @in_multi
-        raise Redis::CommandError, "ERR MULTI calls can not be nested"
+        raise Redis::CommandError, 'ERR MULTI calls can not be nested'
       end
       @in_multi = true
       if block_given?
         @multi_block_given = true
         begin
           yield(self)
-          self.exec
+          exec
         rescue StandardError => e
-          self.discard
+          discard
           raise e
         end
       else
@@ -98,6 +98,5 @@ class MockRedis
         'OK'
       end
     end
-
   end
 end

data/lib/mock_redis/utility_methods.rb

@@ -3,20 +3,18 @@ class MockRedis
     private
 
     def with_thing_at(key, assertion, empty_thing_generator)
-      begin
-        send(assertion, key)
-        data[key] ||= empty_thing_generator.call
-        data_key_ref = data[key]
-        ret = yield data[key]
-        data[key] = data_key_ref if data[key].nil?
-        primitive?(ret) ? ret.dup : ret
-      ensure
-        clean_up_empties_at(key)
-      end
+      send(assertion, key)
+      data[key] ||= empty_thing_generator.call
+      data_key_ref = data[key]
+      ret = yield data[key]
+      data[key] = data_key_ref if data[key].nil?
+      primitive?(ret) ? ret.dup : ret
+    ensure
+      clean_up_empties_at(key)
     end
 
     def primitive?(value)
-      value.kind_of?(::Array) || value.kind_of?(::Hash) || value.kind_of?(::String)
+      value.is_a?(::Array) || value.is_a?(::Hash) || value.is_a?(::String)
     end
 
     def clean_up_empties_at(key)
@@ -24,6 +22,5 @@ class MockRedis
         del(key)
       end
     end
-
   end
 end