fakeredis 0.3.1 → 0.3.2

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011 Guillermo Iguaran
+Copyright (c) 2011-2012 Guillermo Iguaran
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -50,6 +50,8 @@ Or:
 * [dim](https://github.com/dim)
 * [czarneckid](https://github.com/czarneckid)
 * [obrie](https://github.com/obrie)
+* [jredville](https://github.com/jredville)
+* [redsquirrel](https://github.com/redsquirrel)
 * [Travis-CI](http://travis-ci.org/) (Travis-CI also uses Fakeredis in its tests!!!)
 
 
@@ -66,5 +68,5 @@ Or:
 
 ## Copyright
 
-Copyright (c) 2011 Guillermo Iguaran. See LICENSE for
+Copyright (c) 2011-2012 Guillermo Iguaran. See LICENSE for
 further details.

data/lib/fakeredis/version.rb

@@ -1,3 +1,3 @@
 module FakeRedis
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

data/lib/redis/connection/memory.rb

@@ -116,19 +116,11 @@ class Redis
       # * brpop
       # * brpoplpush
       # * discard
-      # * mapped_hmset
-      # * mapped_hmget
-      # * mapped_mset
-      # * mapped_msetnx
       # * move
       # * subscribe
       # * psubscribe
       # * publish
-      # * substr
-      # * unwatch
-      # * watch
       # * zremrangebyrank
-      # * zremrangebyscore
       # * zunionstore
       def flushdb
         @data = ExpiringHash.new
@@ -173,13 +165,14 @@ class Redis
 
       def getbit(key, offset)
         return unless @data[key]
-        @data[key].unpack('B8')[0].split("")[offset]
+        @data[key].unpack('B*')[0].split("")[offset].to_i
       end
 
       def getrange(key, start, ending)
         return unless @data[key]
         @data[key][start..ending]
       end
+      alias :substr :getrange
 
       def getset(key, value)
         old_value = @data[key]
@@ -188,6 +181,7 @@ class Redis
       end
 
       def mget(*keys)
+        raise ArgumentError, "wrong number of arguments for 'mget' command" if keys.empty?
         @data.values_at(*keys)
       end
 
@@ -281,7 +275,7 @@ class Redis
         case where
           when :before then @data[key].insert(index, value)
           when :after  then @data[key].insert(index + 1, value)
-          else raise ArgumentError.new
+          else raise ArgumentError
         end
       end
 
@@ -355,99 +349,99 @@ class Redis
       end
 
       def smembers(key)
-        data_type_check(key, Set)
+        data_type_check(key, ::Set)
         return [] unless @data[key]
         @data[key].to_a.reverse
       end
 
       def sismember(key, value)
-        data_type_check(key, Set)
+        data_type_check(key, ::Set)
         return false unless @data[key]
         @data[key].include?(value.to_s)
       end
 
       def sadd(key, value)
-        data_type_check(key, Set)
+        data_type_check(key, ::Set)
         if @data[key]
           !!@data[key].add?(value.to_s)
         else
-          @data[key] = Set.new([value.to_s])
+          @data[key] = ::Set.new([value.to_s])
           true
         end
       end
 
       def srem(key, value)
-        data_type_check(key, Set)
+        data_type_check(key, ::Set)
         deleted = !!(@data[key] && @data[key].delete?(value.to_s))
         remove_key_for_empty_collection(key)
         deleted
       end
 
       def smove(source, destination, value)
-        data_type_check(destination, Set)
+        data_type_check(destination, ::Set)
         result = self.srem(source, value)
         self.sadd(destination, value) if result
         result
       end
 
       def spop(key)
-        data_type_check(key, Set)
+        data_type_check(key, ::Set)
         elem = srandmember(key)
         srem(key, elem)
         elem
       end
 
       def scard(key)
-        data_type_check(key, Set)
+        data_type_check(key, ::Set)
         return 0 unless @data[key]
         @data[key].size
       end
 
       def sinter(*keys)
-        keys.each { |k| data_type_check(k, Set) }
-        return Set.new if keys.any? { |k| @data[k].nil? }
-        keys = keys.map { |k| @data[k] || Set.new }
+        keys.each { |k| data_type_check(k, ::Set) }
+        return ::Set.new if keys.any? { |k| @data[k].nil? }
+        keys = keys.map { |k| @data[k] || ::Set.new }
         keys.inject do |set, key|
           set & key
         end.to_a
       end
 
       def sinterstore(destination, *keys)
-        data_type_check(destination, Set)
+        data_type_check(destination, ::Set)
         result = sinter(*keys)
-        @data[destination] = Set.new(result)
+        @data[destination] = ::Set.new(result)
       end
 
       def sunion(*keys)
-        keys.each { |k| data_type_check(k, Set) }
-        keys = keys.map { |k| @data[k] || Set.new }
-        keys.inject(Set.new) do |set, key|
+        keys.each { |k| data_type_check(k, ::Set) }
+        keys = keys.map { |k| @data[k] || ::Set.new }
+        keys.inject(::Set.new) do |set, key|
           set | key
         end.to_a
       end
 
       def sunionstore(destination, *keys)
-        data_type_check(destination, Set)
+        data_type_check(destination, ::Set)
         result = sunion(*keys)
-        @data[destination] = Set.new(result)
+        @data[destination] = ::Set.new(result)
       end
 
       def sdiff(key1, *keys)
-        [key1, *keys].each { |k| data_type_check(k, Set) }
-        keys = keys.map { |k| @data[k] || Set.new }
+        [key1, *keys].each { |k| data_type_check(k, ::Set) }
+        keys = keys.map { |k| @data[k] || ::Set.new }
         keys.inject(@data[key1]) do |memo, set|
           memo - set
         end.to_a
       end
 
       def sdiffstore(destination, key1, *keys)
-        data_type_check(destination, Set)
+        data_type_check(destination, ::Set)
         result = sdiff(key1, *keys)
-        @data[destination] = Set.new(result)
+        @data[destination] = ::Set.new(result)
       end
 
       def srandmember(key)
-        data_type_check(key, Set)
+        data_type_check(key, ::Set)
         return nil unless @data[key]
         @data[key].to_a[rand(@data[key].size)]
       end
@@ -529,6 +523,7 @@ class Redis
       end
 
       def hmset(key, *fields)
+        raise ArgumentError, "wrong number of arguments for 'hmset' command" if fields.empty? || fields.size.odd?
         data_type_check(key, Hash)
         @data[key] ||= {}
         fields.each_slice(2) do |field|
@@ -537,6 +532,7 @@ class Redis
       end
 
       def hmget(key, *fields)
+        raise ArgumentError, "wrong number of arguments for 'hmget' command" if fields.empty?
         data_type_check(key, Hash)
         values = []
         fields.map do |field|
@@ -593,12 +589,15 @@ class Redis
       end
 
       def setbit(key, offset, bit)
-        return unless @data[key]
-        old_val = @data[key].unpack('B*')[0].split("")
+        old_val = @data[key] ? @data[key].unpack('B*')[0].split("") : []
+        size_increment = [((offset/8)+1)*8-old_val.length, 0].max
+        old_val += Array.new(size_increment).map{"0"}
+        original_val = old_val[offset]
         old_val[offset] = bit.to_s
         new_val = ""
         old_val.each_slice(8){|b| new_val = new_val + b.join("").to_i(2).chr }
         @data[key] = new_val
+        original_val
       end
 
       def setex(key, seconds, value)
@@ -627,13 +626,8 @@ class Redis
         true
       end
 
-      def mapped_mget(*keys)
-        reply = mget(*keys)
-        Hash[*keys.zip(reply).flatten]
-      end
-
       def sort(key)
-        # TODO: Impleent
+        # TODO: Implement
       end
 
       def incr(key)
@@ -666,7 +660,7 @@ class Redis
           when String then "string"
           when Hash then "hash"
           when Array then "list"
-          when Set then "set"
+          when ::Set then "set"
         end
       end
 
@@ -688,11 +682,19 @@ class Redis
         "OK"
       end
 
+      def watch(_)
+        "OK"
+      end
+
+      def unwatch
+        "OK"
+      end
+
       def zadd(key, score, value)
         data_type_check(key, ZSet)
         @data[key] ||= ZSet.new
         exists = @data[key].key?(value.to_s)
-        @data[key][value.to_s] = score.to_i
+        @data[key][value.to_s] = score
         !exists
       end
 
@@ -722,6 +724,7 @@ class Redis
 
       def zincrby(key, num, value)
         data_type_check(key, ZSet)
+        @data[key] ||= ZSet.new
         @data[key][value.to_s] ||= 0
         @data[key][value.to_s] += num
         @data[key][value.to_s].to_s
@@ -759,28 +762,47 @@ class Redis
         end[start..stop].flatten.map(&:to_s)
       end
 
-      def zrangebyscore(key, min, max, with_scores = nil)
+      def zrangebyscore(key, min, max, *opts)
         data_type_check(key, ZSet)
         return [] unless @data[key]
 
         range = zrange_select_by_score(key, min, max)
-        if with_scores
+        vals = if opts.include?('WITHSCORES')
           range.sort_by {|_,v| v }
         else
           range.keys.sort_by {|k| range[k] }
-        end.flatten.map(&:to_s)
+        end
+
+        limit = get_limit(opts, vals)
+        vals = vals[*limit] if limit
+
+        vals.flatten.map(&:to_s)
       end
 
-      def zrevrangebyscore(key, max, min, with_scores = nil)
+      def zrevrangebyscore(key, max, min, *opts)
         data_type_check(key, ZSet)
         return [] unless @data[key]
 
         range = zrange_select_by_score(key, min, max)
-        if with_scores
+        vals = if opts.include?('WITHSCORES')
           range.sort_by {|_,v| -v }
         else
           range.keys.sort_by {|k| -range[k] }
-        end.flatten.map(&:to_s)
+        end
+
+        limit = get_limit(opts, vals)
+        vals = vals[*limit] if limit
+
+        vals.flatten.map(&:to_s)
+      end
+
+      def zremrangebyscore(key, min, max)
+        data_type_check(key, ZSet)
+        return 0 unless @data[key]
+
+        range = zrange_select_by_score(key, min, max)
+        range.each {|k,_| @data[key].delete(k) }
+        range.size
       end
 
       def zinterstore(out, _, *keys)
@@ -788,7 +810,7 @@ class Redis
 
         hashes = keys.map do |src|
           case @data[src]
-          when Set
+          when ::Set
             Hash[@data[src].zip([0] * @data[src].size)]
           when Hash
             @data[src]
@@ -806,6 +828,13 @@ class Redis
         @data[out].size
       end
 
+      def zremrangebyrank(key, start, stop)
+        sorted_elements = @data[key].sort { |(v_a, r_a), (v_b, r_b)| r_a <=> r_b }
+        elements_to_delete = sorted_elements[start..stop]
+        elements_to_delete.each { |elem, rank| @data[key].delete(elem) }
+        elements_to_delete.size
+      end
+
       private
 
         def zrange_select_by_score(key, min, max)
@@ -815,12 +844,25 @@ class Redis
         def remove_key_for_empty_collection(key)
           del(key) if @data[key] && @data[key].empty?
         end
-        
+
         def data_type_check(key, klass)
           if @data[key] && !@data[key].is_a?(klass)
             fail "Operation against a key holding the wrong kind of value: Expected #{klass} at #{key}."
           end
         end
+
+        def get_limit(opts, vals)
+          index = opts.index('LIMIT')
+
+          if index
+            offset = opts[index + 1]
+
+            count = opts[index + 2]
+            count = vals.size if count < 0
+
+            [offset, count]
+          end
+        end
     end
   end
 end

data/spec/hashes_spec.rb

@@ -94,6 +94,21 @@ module FakeRedis
       @client.hmget("key2", "i1", "i2").should == [nil, nil]
     end
 
+    it "throws an argument error when you don't ask for any keys" do
+      lambda { @client.hmget("key1") }.should raise_error(ArgumentError)
+    end
+
+    it "should reject an empty list of values" do
+      lambda { @client.hmset("key") }.should raise_error(ArgumentError)
+      @client.exists("key").should be_false
+    end
+
+    it 'rejects an insert with a key but no value' do
+      lambda { @client.hmset("key", 'foo') }.should raise_error(ArgumentError)
+      lambda { @client.hmset("key", 'foo', 3, 'bar') }.should raise_error(ArgumentError)
+      @client.exists("key").should be_false
+    end
+
     it "should set multiple hash fields to multiple values" do
       @client.hmset("key", "k1", "value1", "k2", "value2")
 

data/spec/sorted_sets_spec.rb

@@ -14,6 +14,14 @@ module FakeRedis
       @client.zscore("key", "val").should == "2"
     end
 
+    it "should allow floats as scores when adding or updating" do
+      @client.zadd("key", 4.321, "val").should be(true)
+      @client.zscore("key", "val").should == "4.321"
+
+      @client.zadd("key", 54.3210, "val").should be(false)
+      @client.zscore("key", "val").should == "54.321"
+    end
+
     it "should remove members from sorted sets" do
       @client.zrem("key", "val").should be(false)
       @client.zadd("key", 1, "val").should be(true)
@@ -48,6 +56,10 @@ module FakeRedis
       @client.zscore("key", "val1").should == "3"
     end
 
+    it "initializes the sorted set if the key wasnt already set" do
+      @client.zincrby("key", 1, "val1").should == "1"
+    end
+
     it "should convert the key to a string for zscore" do
       @client.zadd("key", 1, 1)
       @client.zscore("key", 1).should == "1"
@@ -85,6 +97,9 @@ module FakeRedis
       @client.zrangebyscore("key", 1, 2).should == ["one", "two"]
       @client.zrangebyscore("key", 0, 100, :withscores => true).should == ["one", "1", "two", "2", "three", "3"]
       @client.zrangebyscore("key", 1, 2, :with_scores => true).should == ["one", "1", "two", "2"]
+      @client.zrangebyscore("key", 0, 100, :limit => [0, 1]).should == ["one"]
+      @client.zrangebyscore("key", 0, 100, :limit => [0, -1]).should == ["one", "two", "three"]
+      @client.zrangebyscore("key", 0, 100, :limit => [1, -1], :with_scores => true).should == ["two", "2", "three", "3"]
     end
 
     it "should return a reversed range of members in a sorted set, by score" do
@@ -96,6 +111,9 @@ module FakeRedis
       @client.zrevrangebyscore("key", 2, 1).should == ["two", "one"]
       @client.zrevrangebyscore("key", 1, 2).should == []
       @client.zrevrangebyscore("key", 2, 1, :with_scores => true).should == ["two", "2", "one", "1"]
+      @client.zrevrangebyscore("key", 100, 0, :limit => [0, 1]).should == ["three"]
+      @client.zrevrangebyscore("key", 100, 0, :limit => [0, -1]).should == ["three", "two", "one"]
+      @client.zrevrangebyscore("key", 100, 0, :limit => [1, -1], :with_scores => true).should == ["two", "2", "one", "1"]
     end
 
     it "should determine the index of a member in a sorted set" do
@@ -138,9 +156,33 @@ module FakeRedis
       @client.zrange("out", 0, 100, :with_scores => true).should == []
     end
 
-    #it "should remove all members in a sorted set within the given indexes"
+    context "zremrangebyscore" do
+      it "should remove items by score" do
+        @client.zadd("key", 1, "one")
+        @client.zadd("key", 2, "two")
+        @client.zadd("key", 3, "three")
+
+        @client.zremrangebyscore("key", 0, 2).should == 2
+        @client.zcard("key").should == 1
+      end
 
-    #it "should remove all members in a sorted set within the given scores"
+      it "should return 0 if the key didn't exist" do
+        @client.zremrangebyscore("key", 0, 2).should == 0
+      end
+    end
+
+    context '#zremrangebyrank' do
+      it 'removes all elements with in the given range' do
+        @client.zadd("key", 1, "one")
+        @client.zadd("key", 2, "two")
+        @client.zadd("key", 3, "three")
+
+        @client.zremrangebyrank("key", 0, 1).should == 2
+        @client.zcard('key').should == 1
+      end
+    end
+
+    #it "should remove all members in a sorted set within the given indexes"
 
     #it "should return a range of members in a sorted set, by index, with scores ordered from high to low"
 

data/spec/strings_spec.rb

@@ -35,19 +35,25 @@ module FakeRedis
     it "should returns the bit value at offset in the string value stored at key" do
       @client.set("key1", "a")
 
-      @client.getbit("key1", 1).should == "1"
-      @client.getbit("key1", 2).should == "1"
-      @client.getbit("key1", 3).should == "0"
-      @client.getbit("key1", 4).should == "0"
-      @client.getbit("key1", 5).should == "0"
-      @client.getbit("key1", 6).should == "0"
-      @client.getbit("key1", 7).should == "1"
+      @client.getbit("key1", 1).should == 1
+      @client.getbit("key1", 2).should == 1
+      @client.getbit("key1", 3).should == 0
+      @client.getbit("key1", 4).should == 0
+      @client.getbit("key1", 5).should == 0
+      @client.getbit("key1", 6).should == 0
+      @client.getbit("key1", 7).should == 1
+    end
+
+    it "should allow direct bit manipulation even if the string isn't set" do
+      @client.setbit("key1", 10, 1)
+      @client.getbit("key1", 10).should == 1
     end
 
     it "should get a substring of the string stored at a key" do
       @client.set("key1", "This a message")
 
       @client.getrange("key1", 0, 3).should == "This"
+      @client.substr("key1", 0, 3).should == "This"
     end
 
     it "should set the string value of a key and return its old value" do
@@ -56,7 +62,7 @@ module FakeRedis
       @client.getset("key1", "value2").should == "value1"
       @client.get("key1").should == "value2"
     end
-    
+
     it "should return nil for #getset if the key does not exist when setting" do
       @client.getset("key1", "value1").should == nil
       @client.get("key1").should == "value1"
@@ -68,11 +74,11 @@ module FakeRedis
 
       @client.get("counter").should == "2"
     end
-    
+
     it "should decrement the integer value of a key by one" do
       @client.set("counter", "1")
       @client.decr("counter").should == 0
-      
+
       @client.get("counter").should == "0"
     end
 
@@ -98,15 +104,10 @@ module FakeRedis
       @client.mget("key1", "key2", "key3").should == ["value1", "value2", "value3"]
     end
 
-    it "should get the values of all the given keys mapped" do
-      @client.set("key1", "value1")
-      @client.set("key2", "value2")
+    it 'raises an argument error when not passed any fields' do
       @client.set("key3", "value3")
-      response = @client.mapped_mget("key1", "key2", "key3")
 
-      response["key1"].should == "value1"
-      response["key2"].should == "value2"
-      response["key3"].should == "value3"
+      lambda { @client.mget }.should raise_error(ArgumentError)
     end
 
     it "should set multiple keys to multiple values" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fakeredis
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-20 00:00:00.000000000 Z
+date: 2012-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &70160189787260 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,15 @@ dependencies:
         version: 2.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *70160189787260
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.0
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70160189786740 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +37,12 @@ dependencies:
         version: 2.0.0
   type: :development
   prerelease: false
-  version_requirements: *70160189786740
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
 description: Fake (In-memory) driver for redis-rb. Useful for testing environment
   and machines without Redis.
 email:
@@ -84,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: fakeredis
-rubygems_version: 1.8.17
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Fake (In-memory) driver for redis-rb.
@@ -100,3 +110,4 @@ test_files:
 - spec/spec_helper.rb
 - spec/strings_spec.rb
 - spec/transactions_spec.rb
+has_rdoc: