redis-objects 0.8.0 → 0.9.1

data/lib/redis/set.rb

@@ -9,8 +9,6 @@ class Redis
     include Enumerable
     require 'redis/helpers/core_commands'
     include Redis::Helpers::CoreCommands
-    require 'redis/helpers/serialize'
-    include Redis::Helpers::Serialize
 
     attr_reader :key, :options
 
@@ -23,49 +21,54 @@ class Redis
     # Add the specified value to the set only if it does not exist already.
     # Redis: SADD
     def add(value)
-      redis.sadd(key, to_redis(value))
+      redis.sadd(key, marshal(value)) if value.nil? || !Array(value).empty?
     end
 
     # Remove and return a random member.  Redis: SPOP
     def pop
-      from_redis redis.spop(key)
+      unmarshal redis.spop(key)
+    end
+
+    # return a random member.  Redis: SRANDMEMBER
+    def randmember
+      unmarshal redis.srandmember(key)
     end
 
     # Adds the specified values to the set. Only works on redis > 2.4
     # Redis: SADD
     def merge(*values)
-      redis.sadd(key, values.flatten.map{|v| to_redis(v)})
+      redis.sadd(key, values.flatten.map{|v| marshal(v)})
     end
 
     # Return all members in the set.  Redis: SMEMBERS
     def members
-      v = from_redis redis.smembers(key)
-      v.nil? ? [] : v
+      vals = redis.smembers(key)
+      vals.nil? ? [] : vals.map{|v| unmarshal(v) }
     end
     alias_method :get, :members
 
     # Returns true if the specified value is in the set.  Redis: SISMEMBER
     def member?(value)
-      redis.sismember(key, to_redis(value))
+      redis.sismember(key, marshal(value))
     end
     alias_method :include?, :member?
-    
+
     # Delete the value from the set.  Redis: SREM
     def delete(value)
-      redis.srem(key, to_redis(value))
+      redis.srem(key, marshal(value))
     end
-    
+
     # Delete if matches block
     def delete_if(&block)
       res = false
       redis.smembers(key).each do |m|
-        if block.call(from_redis(m))
+        if block.call(unmarshal(m))
           res = redis.srem(key, m)
         end
       end
       res
     end
-    
+
     # Iterate through each member of the set.  Redis::Objects mixes in Enumerable,
     # so you can also use familiar methods like +collect+, +detect+, and so forth.
     def each(&block)
@@ -84,12 +87,12 @@ class Redis
     #
     # Redis: SINTER
     def intersection(*sets)
-      from_redis redis.sinter(key, *keys_from_objects(sets))
+      redis.sinter(key, *keys_from_objects(sets)).map{|v| unmarshal(v)}
     end
     alias_method :intersect, :intersection
     alias_method :inter, :intersection
     alias_method :&, :intersection
-    
+
     # Calculate the intersection and store it in Redis as +name+. Returns the number
     # of elements in the stored intersection. Redis: SUNIONSTORE
     def interstore(name, *sets)
@@ -108,7 +111,7 @@ class Redis
     #
     # Redis: SUNION
     def union(*sets)
-      from_redis redis.sunion(key, *keys_from_objects(sets))
+      redis.sunion(key, *keys_from_objects(sets)).map{|v| unmarshal(v)}
     end
     alias_method :|, :union
     alias_method :+, :union
@@ -132,7 +135,7 @@ class Redis
     #
     # Redis: SDIFF
     def difference(*sets)
-      from_redis redis.sdiff(key, *keys_from_objects(sets))
+      redis.sdiff(key, *keys_from_objects(sets)).map{|v| unmarshal(v)}
     end
     alias_method :diff, :difference
     alias_method :^, :difference
@@ -172,17 +175,19 @@ class Redis
     def ==(x)
       members == x
     end
-    
+
     def to_s
       members.join(', ')
     end
 
+    expiration_filter :add
+
     private
-    
+
     def keys_from_objects(sets)
       raise ArgumentError, "Must pass in one or more set names" if sets.empty?
       sets.collect{|set| set.is_a?(Redis::Set) ? set.key : set}
     end
-    
+
   end
 end

data/lib/redis/sorted_set.rb

@@ -9,8 +9,6 @@ class Redis
     # include Enumerable
     require 'redis/helpers/core_commands'
     include Redis::Helpers::CoreCommands
-    require 'redis/helpers/serialize'
-    include Redis::Helpers::Serialize
 
     attr_reader :key, :options
 
@@ -25,9 +23,19 @@ class Redis
     # arguments to this are flipped; the member comes first rather than
     # the score, since the member is the unique item (not the score).
     def add(member, score)
-      redis.zadd(key, score, to_redis(member))
+      redis.zadd(key, score, marshal(member))
     end
 
+    # Add a list of members and their corresponding value (or a hash mapping
+    # values to scores) to Redis. Note that the arguments to this are flipped;
+    # the member comes first rather than the score, since the member is the unique
+    # item (not the score).
+    def merge(values)
+      vals = values.map{|v,s| [s, marshal(v)] }
+      redis.zadd(key, vals)
+    end
+    alias_method :add_all, :merge
+
     # Same functionality as Ruby arrays.  If a single number is given, return
     # just the element at that index using Redis: ZRANGE. Otherwise, return
     # a range of values using Redis: ZRANGE.
@@ -50,7 +58,7 @@ class Redis
     # specified element does not exist in the sorted set, or the key does not exist
     # at all, nil is returned. Redis: ZSCORE.
     def score(member)
-      result = redis.zscore(key, to_redis(member))
+      result = redis.zscore(key, marshal(member))
 
       result.to_f unless result.nil?
     end
@@ -60,7 +68,7 @@ class Redis
     # When the given member does not exist in the sorted set, nil is returned.
     # The returned rank (or index) of the member is 0-based for both commands
     def rank(member)
-      if n = redis.zrank(key, to_redis(member))
+      if n = redis.zrank(key, marshal(member))
         n.to_i
       else
         nil
@@ -68,7 +76,7 @@ class Redis
     end
 
     def revrank(member)
-      if n = redis.zrevrank(key, to_redis(member))
+      if n = redis.zrevrank(key, marshal(member))
         n.to_i
       else
         nil
@@ -78,26 +86,25 @@ class Redis
     # Return all members of the sorted set with their scores.  Extremely CPU-intensive.
     # Better to use a range instead.
     def members(options={})
-      v = from_redis range(0, -1, options)
-      v.nil? ? [] : v
+      range(0, -1, options) || []
     end
 
     # Return a range of values from +start_index+ to +end_index+.  Can also use
     # the familiar list[start,end] Ruby syntax. Redis: ZRANGE
     def range(start_index, end_index, options={})
       if options[:withscores] || options[:with_scores]
-        from_redis redis.zrange(key, start_index, end_index, :with_scores => true)
+        redis.zrange(key, start_index, end_index, :with_scores => true).map{|v,s| [unmarshal(v), s] }
       else
-        from_redis redis.zrange(key, start_index, end_index)
+        redis.zrange(key, start_index, end_index).map{|v| unmarshal(v) }
       end
     end
 
     # Return a range of values from +start_index+ to +end_index+ in reverse order. Redis: ZREVRANGE
     def revrange(start_index, end_index, options={})
       if options[:withscores] || options[:with_scores]
-        from_redis redis.zrevrange(key, start_index, end_index, :with_scores => true)
+        redis.zrevrange(key, start_index, end_index, :with_scores => true).map{|v,s| [unmarshal(v), s] }
       else
-        from_redis redis.zrevrange(key, start_index, end_index)
+        redis.zrevrange(key, start_index, end_index).map{|v| unmarshal(v) }
       end
     end
 
@@ -112,7 +119,7 @@ class Redis
                 options[:offset] || options[:limit] || options[:count]
       args[:with_scores] = true if options[:withscores] || options[:with_scores]
 
-      from_redis redis.zrangebyscore(key, min, max, args)
+      redis.zrangebyscore(key, min, max, args).map{|v| unmarshal(v) }
     end
 
     # Returns all the elements in the sorted set at key with a score between max and min
@@ -128,7 +135,7 @@ class Redis
                 options[:offset] || options[:limit] || options[:count]
       args[:with_scores] = true if options[:withscores] || options[:with_scores]
 
-      from_redis redis.zrevrangebyscore(key, max, min, args)
+      redis.zrevrangebyscore(key, max, min, args).map{|v| unmarshal(v) }
     end
 
     # Remove all elements in the sorted set at key with rank between start and end. Start and end are
@@ -148,7 +155,7 @@ class Redis
 
     # Delete the value from the set.  Redis: ZREM
     def delete(value)
-      redis.zrem(key, to_redis(value))
+      redis.zrem(key, marshal(value))
     end
 
     # Delete element if it matches block
@@ -156,7 +163,7 @@ class Redis
       raise ArgumentError, "Missing block to SortedSet#delete_if" unless block_given?
       res = false
       redis.zrange(key, 0, -1).each do |m|
-        if block.call(from_redis(m))
+        if block.call(unmarshal(m))
           res = redis.zrem(key, m)
         end
       end
@@ -166,14 +173,14 @@ class Redis
     # Increment the rank of that member atomically and return the new value. This
     # method is aliased as incr() for brevity. Redis: ZINCRBY
     def increment(member, by=1)
-      redis.zincrby(key, by, to_redis(member)).to_i
+      redis.zincrby(key, by, marshal(member)).to_i
     end
     alias_method :incr, :increment
     alias_method :incrby, :increment
 
     # Convenience to calling increment() with a negative number.
     def decrement(member, by=1)
-      redis.zincrby(key, -by, to_redis(member)).to_i
+      redis.zincrby(key, -by, marshal(member)).to_i
     end
     alias_method :decr, :decrement
     alias_method :decrby, :decrement
@@ -190,7 +197,7 @@ class Redis
     #
     # Redis: SINTER
     def intersection(*sets)
-      from_redis redis.zinter(key, *keys_from_objects(sets))
+      redis.zinter(key, *keys_from_objects(sets)).map{|v| unmarshal(v) }
     end
     alias_method :intersect, :intersection
     alias_method :inter, :intersection
@@ -214,7 +221,7 @@ class Redis
     #
     # Redis: SUNION
     def union(*sets)
-      from_redis redis.zunion(key, *keys_from_objects(sets))
+      redis.zunion(key, *keys_from_objects(sets)).map{|v| unmarshal(v) }
     end
     alias_method :|, :union
     alias_method :+, :union
@@ -238,7 +245,7 @@ class Redis
     #
     # Redis: SDIFF
     def difference(*sets)
-      from_redis redis.zdiff(key, *keys_from_objects(sets))
+      redis.zdiff(key, *keys_from_objects(sets)).map{|v| unmarshal(v) }
     end
     alias_method :diff, :difference
     alias_method :^, :difference
@@ -292,9 +299,11 @@ class Redis
 
     # Return a boolean indicating whether +value+ is a member.
     def member?(value)
-      !redis.zscore(key, to_redis(value)).nil?
+      !redis.zscore(key, marshal(value)).nil?
     end
 
+    expiration_filter :[]=, :add, :merge, :diffstore, :increment, :decrement, :intersection, :interstore, :unionstore
+
     private
 
     def keys_from_objects(sets)

data/lib/redis/value.rb

@@ -7,26 +7,24 @@ class Redis
   class Value < BaseObject
     require 'redis/helpers/core_commands'
     include Redis::Helpers::CoreCommands
-    require 'redis/helpers/serialize'
-    include Redis::Helpers::Serialize
 
     attr_reader :key, :options
     def initialize(key, *args)
       super(key, *args)
-      redis.setnx(key, to_redis(@options[:default])) if @options[:default]
+      redis.setnx(key, marshal(@options[:default])) if @options[:default]
     end
 
     def value=(val)
       if val.nil?
         delete
       else
-        redis.set key, to_redis(val)
+        redis.set key, marshal(val)
       end
     end
     alias_method :set, :value=
 
     def value
-      from_redis redis.get(key)
+      unmarshal redis.get(key)
     end
     alias_method :get, :value
 
@@ -42,5 +40,7 @@ class Redis
     def method_missing(*args)
       self.value.send *args
     end
+
+    expiration_filter :value=
   end
 end

data/spec/redis_objects_conn_spec.rb

@@ -9,6 +9,38 @@ BAD_REDIS = "totally bad bogus redis handle"
 
 # Grab a global handle
 describe 'Connection tests' do
+  it "should support overriding object handles" do
+
+    class CustomConnectionObject
+      include Redis::Objects
+
+      def id
+        return 1
+      end
+
+      redis_handle = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT, :db => 31)
+      value :redis_value, :redis => redis_handle, :key => 'rval'
+      value :default_redis_value, :key => 'rval'
+    end
+
+    obj = CustomConnectionObject.new
+
+    obj.default_redis_value.value.should == nil
+    obj.redis_value.value.should == nil
+
+    obj.default_redis_value.value = 'foo'
+    obj.default_redis_value.value.should == 'foo'
+    obj.redis_value.value.should == nil
+
+    obj.default_redis_value.clear
+    obj.redis_value.value = 'foo'
+    obj.redis_value.value.should == 'foo'
+    obj.default_redis_value.value.should == nil
+
+    obj.redis_value.clear
+    obj.default_redis_value.clear
+  end
+
   it "should support local handles" do
     Redis.current = nil  # reset from other tests
     Redis::Objects.redis = nil
@@ -100,5 +132,3 @@ describe 'Connection tests' do
   end
 
 end
-
-

data/spec/redis_objects_instance_spec.rb

@@ -46,6 +46,24 @@ describe Redis::Value do
     @value.options[:marshal] = false
   end
 
+  it "should not erroneously unmarshall a string" do
+    json_string = {json: 'value'}
+    @value = Redis::Value.new('spec/value', :marshal => true)
+    @value.value = json_string
+    @value.value.should == json_string
+    @value.clear
+
+    default_json_string = {json: 'default'}
+    @value = Redis::Value.new('spec/default', :default => default_json_string, :marshal => true)
+    @value.value.should == default_json_string
+    @value.clear
+
+    marshalled_string = Marshal.dump({json: 'marshal'})
+    @value = Redis::Value.new('spec/marshal', :default => marshalled_string, :marshal => true)
+    @value.value.should == marshalled_string
+    @value.clear
+  end
+
   it "should support renaming values" do
     @value.value = 'Peter Pan'
     @value.key.should == 'spec/value'
@@ -86,6 +104,19 @@ describe Redis::Value do
     @value.nil?.should == true
   end
 
+  it 'should set time to live in seconds when expiration option assigned' do
+    @value = Redis::Value.new('spec/value', :expiration => 10)
+    @value.value = 'monkey'
+    @value.ttl.should > 0
+    @value.ttl.should <= 10
+  end
+
+  it 'should set expiration when expireat option assigned' do
+    @value = Redis::Value.new('spec/value', :expireat => Time.now + 10.seconds)
+    @value.value = 'monkey'
+    @value.ttl.should > 0
+  end
+
   after do
     @value.delete
   end
@@ -298,6 +329,20 @@ describe Redis::List do
       @list.redis.del('spec/list2')
     end
 
+    it 'should set time to live in seconds when expiration option assigned' do
+      @list = Redis::List.new('spec/list', :expiration => 10)
+      @list << 'val'
+      @list.ttl.should > 0
+      @list.ttl.should <= 10
+    end
+
+    it 'should set expiration when expireat option assigned' do
+      @list = Redis::List.new('spec/list', :expireat => Time.now + 10.seconds)
+      @list << 'val'
+      @list.ttl.should > 0
+      @list.ttl.should <= 10
+    end
+
     after do
       @list.clear
     end
@@ -341,6 +386,33 @@ describe Redis::Counter do
     @counter.should == 111
   end
 
+  it "should support increment/decrement by float" do
+    @counter = Redis::Counter.new('spec/floater')
+    @counter.set 10.5
+    @counter.incrbyfloat 1
+    @counter.incrbyfloat 0.01
+    @counter.to_f.should == 11.51
+    @counter.set '5.0e3'
+    @counter.decrbyfloat -14.31
+    @counter.incrbyfloat 2.0e2
+    @counter.to_f.should == 5214.31
+    @counter.clear
+  end
+
+  it 'should set time to live in seconds when expiration option assigned' do
+    @counter = Redis::Counter.new('spec/counter', :expiration => 10)
+    @counter.increment
+    @counter.ttl.should > 0
+    @counter.ttl.should <= 10
+  end
+
+  it 'should set expiration when expireat option assigned' do
+    @counter = Redis::Counter.new('spec/counter', :expireat => Time.now + 10.seconds)
+    @counter.increment
+    @counter.ttl.should > 0
+    @counter.ttl.should <= 10
+  end
+
   after do
     @counter.delete
   end
@@ -473,8 +545,8 @@ describe Redis::HashKey do
   it "should handle complex marshaled values" do
     @hash.options[:marshal] = true
     @hash['abc'].should == nil
-    @hash['abc'] = {:json => 'data'}
-    @hash['abc'].should == {:json => 'data'}
+    @hash['abc'] = {:json => 'hash marshal'}
+    @hash['abc'].should == {:json => 'hash marshal'}
 
     # no marshaling
     @hash.options[:marshal] = false
@@ -508,6 +580,18 @@ describe Redis::HashKey do
     @hash.options[:marshal] = false
   end
 
+  it "should marshal nil correctly" do
+    @hash.options[:marshal] = true
+
+    @hash['test'].should.be.nil
+    @hash['test'] = nil
+    @hash['test'].should.be.nil
+    @hash.delete('test').should == 1
+    @hash['test'].should.be.nil
+
+    @hash.options[:marshal] = false
+  end
+
   it "should get and set values" do
     @hash['foo'] = 'bar'
     @hash['foo'].should == 'bar'
@@ -544,6 +628,29 @@ describe Redis::HashKey do
     end
   end
 
+  it "should handle increment/decrement" do
+    @hash['integer'] = 1
+    @hash.incrby('integer')
+    @hash.incrby('integer', 2)
+    @hash.get('integer').to_i.should == 4
+
+    @hash['integer'] = 9
+    @hash.decrby('integer')
+    @hash.decrby('integer', 6)
+    @hash.get('integer').to_i.should == 2
+
+    @hash['float'] = 12.34
+    @hash.decrbyfloat('float')
+    @hash.decrbyfloat('float', 6.3)
+    @hash.get('float').to_f.should == 5.04
+
+    @hash['float'] = '5.0e3'
+    @hash.incrbyfloat('float')
+    @hash.incrbyfloat('float', '1.23e3')
+    @hash.incrbyfloat('float', 45.3)
+    @hash.get('float').to_f.should == 6276.3
+  end
+
   it "should respond to each_value" do
     @hash['foo'] = 'bar'
     @hash.each_value do |val|
@@ -603,6 +710,31 @@ describe Redis::HashKey do
     end
   end
 
+  it "should fetch default values" do
+    @hash['abc'] = "123"
+
+    value = @hash.fetch('missing_key','default_value')
+    block = @hash.fetch("missing_key") {|key| "oops: #{key}" }
+    no_error = @hash.fetch("abc") rescue "error"
+
+    no_error.should == "123"
+    value.should == "default_value"
+    block.should == "oops: missing_key"
+  end
+
+  it 'should set time to live in seconds when expiration option assigned' do
+    @hash = Redis::HashKey.new('spec/hash_key', :expiration => 10)
+    @hash['foo'] = 'bar'
+    @hash.ttl.should > 0
+    @hash.ttl.should <= 10
+  end
+
+  it 'should set expiration when expireat option assigned' do
+    @hash = Redis::HashKey.new('spec/hash_key', :expireat => Time.now + 10.seconds)
+    @hash['foo'] = 'bar'
+    @hash.ttl.should > 0
+  end
+
   after do
     @hash.clear
   end
@@ -665,6 +797,17 @@ describe Redis::Set do
     @set.sort.should == ['a','b','c']
     @set.delete_if{|m| m == 'c'}
     @set.sort.should == ['a','b']
+
+    @set << nil
+    @set.include?("").should.be.true
+  end
+
+  it "should handle empty array adds" do
+    should.not.raise(Redis::CommandError) { @set.add([]) }
+    @set.should.be.empty
+
+    should.not.raise(Redis::CommandError) { @set << [] }
+    @set.should.be.empty
   end
 
   it "should handle set intersections, unions, and diffs" do
@@ -764,7 +907,20 @@ describe Redis::Set do
     @set_1.redis.del val1.key
     @set_1.redis.del val2.key
     @set_1.redis.del SORT_STORE[:store]
+  end
 
+  it 'should set time to live in seconds when expiration option assigned' do
+    @set = Redis::Set.new('spec/set', :expiration => 10)
+    @set << 'val'
+    @set.ttl.should > 0
+    @set.ttl.should <= 10
+  end
+
+  it 'should set expiration when expireat option assigned' do
+    @set = Redis::Set.new('spec/set', :expireat => Time.now + 10.seconds)
+    @set << 'val'
+    @set.ttl.should > 0
+    @set.ttl.should <= 10
   end
 
   after do
@@ -810,6 +966,7 @@ describe Redis::SortedSet do
     @set.range(0, 2).should == a[0..2]
     @set[0, 0].should == []
     @set.range(0,1,:withscores => true).should == [['a',3],['c',4]]
+    @set.revrange(0,1,:withscores => true).should == [['b',5.6],['c',4]]
     @set.range(0,-1).should == a[0..-1]
     @set.revrange(0,-1).should == a[0..-1].reverse
     @set[0..1].should == a[0..1]
@@ -823,6 +980,8 @@ describe Redis::SortedSet do
     @set.members(:withscores => true).should == [['a',3],['c',4],['b',5.6]]
     @set.members(:with_scores => true).should == [['a',3],['c',4],['b',5.6]]
     @set.members(:withscores => true).reverse.should == [['b',5.6],['c',4],['a',3]]
+    @set.members(:withscores => true).should == @set.range(0,-1,:withscores => true)
+    @set.members(:withscores => true).reverse.should == @set.revrange(0,-1,:withscores => true)
 
     @set['b'] = 5
     @set['b'] = 6
@@ -882,13 +1041,33 @@ describe Redis::SortedSet do
     @set.size.should == 3
   end
 
+  it "should handle inserting multiple values at once" do
+    @set.merge({ 'a' => 1, 'b' => 2 })
+    @set.merge([['a', 4], ['c', 5]])
+    @set.merge({d: 0, e: 9 })
+
+    @set.members.should == ["d", "b", "a", "c", "e"]
+
+    @set[:f] = 3
+    @set.members.should == ["d", "b", "f", "a", "c", "e"]
+  end
+
   it "should support marshaling key names" do
+    @set_4.members.should == []
+
     @set_4[Object] = 1.20
     @set_4[Module] = 2.30
+    @set_4[nil] = 3.40
+
     @set_4.incr(Object, 0.5)
     @set_4.decr(Module, 0.5)
+    @set_4.incr(nil, 0.5)
+
     @set_4[Object].round(1).should == 1.7
     @set_4[Module].round(1).should == 1.8
+    @set_4[nil].round(1).should == 3.9
+
+    @set_4.members.should == [Object, Module, nil]
   end
 
   it "should support renaming sorted sets" do
@@ -909,6 +1088,20 @@ describe Redis::SortedSet do
     @set.redis.del('spec/zset2')
   end
 
+  it 'should set time to live in seconds when expiration option assigned' do
+    @set = Redis::SortedSet.new('spec/zset', :expiration => 10)
+    @set['val'] = 1
+    @set.ttl.should > 0
+    @set.ttl.should <= 10
+  end
+
+  it 'should set expiration when expireat option assigned' do
+    @set = Redis::SortedSet.new('spec/zset', :expireat => Time.now + 10.seconds)
+    @set['val'] = 1
+    @set.ttl.should > 0
+    @set.ttl.should <= 10
+  end
+
   after do
     @set.clear
     @set_1.clear