redis-objects 0.8.0 → 0.9.0

data/lib/redis/objects/counters.rb

@@ -29,7 +29,7 @@ class Redis
               instance_variable_get("@#{name}") or
                 instance_variable_set("@#{name}",
                   Redis::Counter.new(
-                    redis_field_key(name), redis, redis_objects[name.to_sym]
+                    redis_field_key(name), redis_field_redis(name), redis_objects[name.to_sym]
                   )
                 )
             end

data/lib/redis/objects/hashes.rb

@@ -21,7 +21,7 @@ class Redis
               instance_variable_get("@#{name}") or
                 instance_variable_set("@#{name}",
                   Redis::HashKey.new(
-                    redis_field_key(name), redis, redis_objects[name.to_sym]
+                    redis_field_key(name), redis_field_redis(name), redis_objects[name.to_sym]
                   )
                 )
             end

data/lib/redis/objects/lists.rb

@@ -21,7 +21,7 @@ class Redis
               instance_variable_get("@#{name}") or
                 instance_variable_set("@#{name}",
                   Redis::List.new(
-                    redis_field_key(name), redis, redis_objects[name.to_sym]
+                    redis_field_key(name), redis_field_redis(name), redis_objects[name.to_sym]
                   )
                 )
             end

data/lib/redis/objects/locks.rb

@@ -24,7 +24,7 @@ class Redis
               instance_variable_get("@#{lock_name}") or
                 instance_variable_set("@#{lock_name}",
                   Redis::Lock.new(
-                    redis_field_key(lock_name), redis, redis_objects[lock_name.to_sym]
+                    redis_field_key(lock_name), redis_field_redis(lock_name), redis_objects[lock_name.to_sym]
                   )
                 )
             end
@@ -49,7 +49,7 @@ class Redis
           verify_lock_defined!(name)
           raise ArgumentError, "Missing block to #{self.name}.obtain_lock" unless block_given?
           lock_name = "#{name}_lock"
-          Redis::Lock.new(redis_field_key(lock_name, id), redis, redis_objects[lock_name.to_sym]).lock(&block)
+          Redis::Lock.new(redis_field_key(lock_name, id), redis_field_redis(lock_name), redis_objects[lock_name.to_sym]).lock(&block)
         end
 
         # Clear the lock.  Use with care - usually only in an Admin page to clear

data/lib/redis/objects/sets.rb

@@ -21,7 +21,7 @@ class Redis
               instance_variable_get("@#{name}") or
                 instance_variable_set("@#{name}",
                   Redis::Set.new(
-                    redis_field_key(name), redis, redis_objects[name.to_sym]
+                    redis_field_key(name), redis_field_redis(name), redis_objects[name.to_sym]
                   )
                 )
             end

data/lib/redis/objects/sorted_sets.rb

@@ -21,7 +21,7 @@ class Redis
               instance_variable_get("@#{name}") or
                 instance_variable_set("@#{name}",
                   Redis::SortedSet.new(
-                    redis_field_key(name), redis, redis_objects[name.to_sym]
+                    redis_field_key(name), redis_field_redis(name), redis_objects[name.to_sym]
                   )
                 )
             end

data/lib/redis/objects/values.rb

@@ -21,7 +21,7 @@ class Redis
               instance_variable_get("@#{name}") or
                 instance_variable_set("@#{name}",
                   Redis::Value.new(
-                    redis_field_key(name), redis, redis_objects[name.to_sym]
+                    redis_field_key(name), redis_field_redis(name), redis_objects[name.to_sym]
                   )
                 )
             end

data/lib/redis/objects/version.rb

@@ -1,5 +1,5 @@
 class Redis
   module Objects
-    VERSION = "0.8.0"
+    VERSION = "0.9.0"
   end
 end

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,26 @@ 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
+      vals = range(0, -1, options)
+      vals.nil? ? [] : vals.map{|v| unmarshal(v) }
     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| unmarshal(v) }
       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 +120,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 +136,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 +156,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 +164,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 +174,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 +198,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 +222,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 +246,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 +300,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
-
-