redis-objects 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c9dea664a6595b39e8542280a5b91091d204d72
-  data.tar.gz: 953f0b08f429ee68d58bb50d4db16c2f93840781
+  metadata.gz: 95f1e710f5708a5b30fb2a843fcfdacaff0af044
+  data.tar.gz: 1d4816620d04019576ae1e277be3c5676b0c5be0
 SHA512:
-  metadata.gz: 7ad7b1a216ff428b194bc2b6156f5fde907cbed35dd93780e3193b69cee1306f1b66a20cb3e952fbee3280b2acf4e9a1b7d83c3caea56e95f616a9f962e2bdc9
-  data.tar.gz: a08b2a851e6390ab78e9ca8102efab41784468aa2fbc9f3471327b13f271dc3ab981a4c055963de4ad4ad397fe7539826bef3d1f90af887bc620986ebcecd72e
+  metadata.gz: d68499ab0eafd74dcd51838f1723ee14d561bd772725dbef69ce26d86dc66bca412c7520be5f02c5cad9b761a77670e9c8707f5b34737409ada232c99b5a44d4
+  data.tar.gz: 0a59d05c7d974f0e7d20f5f938b6451a582ec5c025d450cb85073ff328b9abc19d250971f13fe6e2b191f3f3e7c6312a3f81f8f10e93c1b47c9459b12680f775

data/CHANGELOG.rdoc

@@ -1,5 +1,25 @@
 = Changelog for Redis::Objects
 
+== 0.9.0 (6 Feb 2014)
+
+* Ensure we don't double-unmarshal values, which could be a security issue [markijbema, nateware]
+
+* Support a custom redis connection per redis key [hfwang]
+
+* HashKey#fetch now behaves more similarly to Ruby [datapimp]
+
+* Add incrbyfloat and decrbyfloat for values and hashes [nateware]
+
+* Add support for @sorted_set.merge and variadic zadd [hfwang]
+
+* Add support for srandmember for sets [LYY]
+
+* Handle @set << [] in an intelligent way [kitchen]
+
+* Add multi-unshift functionality [nateware]
+
+* Additional test coverage for @sorted_set.merge and other ops [nateware]
+
 == 0.8.0 (9 Nov 2013)
 
 * Refactor to modular include/extend approach to enable hooking and remove evals [nateware]

data/README.md

@@ -452,6 +452,13 @@ lock time.
 Keep in mind that true locks serialize your entire application at that point.  As
 such, atomic counters are strongly preferred.
 
+### Expiration ###
+
+Use :expiration and :expireat options to set default expiration.
+
+    value :value_with_expiration, :expiration => 1.hour
+    value :value_with_expireat, :expireat => Time.now + 1.hour
+
 Author
 =======
 Copyright (c) 2009-2013 [Nate Wiger](http://nateware.com).  All Rights Reserved.

data/lib/redis/base_object.rb

@@ -13,5 +13,37 @@ class Redis
     end
 
     alias :inspect :to_s  # Ruby 1.9.2
+
+    def set_expiration
+      if !@options[:expiration].nil?
+        redis.expire(@key, @options[:expiration]) if redis.ttl(@key) < 0
+      elsif !@options[:expireat].nil?
+        redis.expireat(@key, @options[:expireat].to_i) if redis.ttl(@key) < 0
+      end
+    end
+
+    class << self
+      def expiration_filter(*names)
+        names.each do |name|
+          if ['=', '?', '!'].include? name.to_s[-1]
+            with_name = "#{name[0..-2]}_with_expiration#{name[-1]}".to_sym
+            without_name = "#{name[0..-2]}_without_expiration#{name[-1]}".to_sym
+          else
+            with_name = "#{name}_with_expiration".to_sym
+            without_name = "#{name}_without_expiration".to_sym
+          end
+
+          alias_method without_name, name
+
+          define_method(with_name) do |*args|
+            result = send(without_name, *args)
+            set_expiration
+            result
+          end
+
+          alias_method name, with_name
+        end
+      end
+    end
   end
 end

data/lib/redis/counter.rb

@@ -16,6 +16,7 @@ class Redis
     def initialize(key, *args)
       super(key, *args)
       @options[:start] ||= 0
+      raise ArgumentError, "Marshalling redis counters does not make sense" if @options[:marshal]
       redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
     end
 
@@ -45,6 +46,20 @@ class Redis
     end
     alias_method :get, :value
 
+    def value=(val)
+      if val.nil?
+        delete
+      else
+        redis.set key, val
+      end
+    end
+    alias_method :set, :value=
+
+    # Like .value but casts to float since Redis addresses these differently.
+    def to_f
+      redis.get(key).to_f
+    end
+
     # Increment the counter atomically and return the new value.  If passed
     # a block, that block will be evaluated with the new value of the counter
     # as an argument. If the block returns nil or throws an exception, the
@@ -55,6 +70,7 @@ class Redis
       block_given? ? rewindable_block(:decrement, by, val, &block) : val
     end
     alias_method :incr, :increment
+    alias_method :incrby, :increment
 
     # Decrement the counter atomically and return the new value.  If passed
     # a block, that block will be evaluated with the new value of the counter
@@ -66,6 +82,21 @@ class Redis
       block_given? ? rewindable_block(:increment, by, val, &block) : val
     end
     alias_method :decr, :decrement
+    alias_method :decrby, :decrement
+
+    # Increment a floating point counter atomically.
+    # Redis uses separate API's to interact with integers vs floats.
+    def incrbyfloat(by=1.0, &block)
+      val = redis.incrbyfloat(key, by).to_f
+      block_given? ? rewindable_block(:decrbyfloat, by, val, &block) : val
+    end
+
+    # Decrement a floating point counter atomically.
+    # Redis uses separate API's to interact with integers vs floats.
+    def decrbyfloat(by=1.0, &block)
+      val = redis.incrbyfloat(key, -by).to_f
+      block_given? ? rewindable_block(:incrbyfloat, -by, val, &block) : val
+    end
 
     ##
     # Proxy methods to help make @object.counter == 10 work
@@ -81,6 +112,8 @@ class Redis
         end
       EndOverload
     end
+
+    expiration_filter :increment, :decrement
    
     private
 

data/lib/redis/hash_key.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
     def initialize(key, *args)
@@ -18,30 +16,18 @@ class Redis
       @options[:marshal_keys] ||= {} 
     end
 
-    # Needed since Redis::Hash masks bare Hash in redis.rb
-    def self.[](*args)
-      ::Hash[*args]
-    end
-
-    # Sets a field to value
-    def []=(field, value)
-      store(field, to_redis(value))
-    end
-
-    # Gets the value of a field
-    def [](field)
-      fetch(field)
-    end
-
     # Redis: HSET
     def store(field, value)
-      redis.hset(key, field, to_redis(value, options[:marshal_keys][field]))
+      redis.hset(key, field, marshal(value, options[:marshal_keys][field]))
     end
+    alias_method :[]=, :store
 
     # Redis: HGET
-    def fetch(field)
-      from_redis redis.hget(key, field), options[:marshal_keys][field]
+    def hget(field)
+      unmarshal redis.hget(key, field), options[:marshal_keys][field]
     end
+    alias_method :get, :hget
+    alias_method :[],  :hget
 
     # Verify that a field exists. Redis: HEXISTS
     def has_key?(field)
@@ -56,6 +42,16 @@ class Redis
       redis.hdel(key, field)
     end
 
+    # Fetch a key in a way similar to Ruby's Hash#fetch
+    def fetch(field, *args, &block)
+      value = hget(field)
+      default = args[0]
+
+      return value if value || (!default && !block_given?)
+
+      block_given? ? block.call(field) : default
+    end
+
     # Return all the keys of the hash. Redis: HKEYS
     def keys
       redis.hkeys(key)
@@ -63,14 +59,14 @@ class Redis
 
     # Return all the values of the hash. Redis: HVALS
     def values
-      from_redis redis.hvals(key)
+      redis.hvals(key).map{|v| unmarshal(v) }
     end
     alias_method :vals, :values
 
     # Retrieve the entire hash.  Redis: HGETALL
     def all
       h = redis.hgetall(key) || {}
-      h.each { |k,v| h[k] = from_redis(v, options[:marshal_keys][k]) }
+      h.each{|k,v| h[k] = unmarshal(v, options[:marshal_keys][k]) }
       h
     end
     alias_method :clone, :all
@@ -111,7 +107,7 @@ class Redis
     def bulk_set(*args)
       raise ArgumentError, "Argument to bulk_set must be hash of key/value pairs" unless args.last.is_a?(::Hash)
       redis.hmset(key, *args.last.inject([]){ |arr,kv|
-        arr + [kv[0], to_redis(kv[1], options[:marshal_keys][kv[0]])]
+        arr + [kv[0], marshal(kv[1], options[:marshal_keys][kv[0]])]
       })
     end
     alias_method :update, :bulk_set
@@ -120,7 +116,7 @@ class Redis
     def fill(pairs={})
       raise ArgumentError, "Arugment to fill must be a hash of key/value pairs" unless pairs.is_a?(::Hash)
       pairs.each do |field, value|
-        redis.hsetnx(key, field, to_redis(value, options[:marshal_keys][field]))
+        redis.hsetnx(key, field, marshal(value, options[:marshal_keys][field]))
       end
     end
 
@@ -129,7 +125,7 @@ class Redis
       hsh = {}
       res = redis.hmget(key, *fields.flatten)
       fields.each do |k|
-        hsh[k] = from_redis(res.shift, options[:marshal_keys][k])
+        hsh[k] = unmarshal(res.shift, options[:marshal_keys][k])
       end
       hsh
     end
@@ -138,12 +134,12 @@ class Redis
     # Values are returned in a collection in the same order than their keys in *keys Redis: HMGET
     def bulk_values(*keys)
       res = redis.hmget(key, *keys.flatten)
-      keys.inject([]){|collection, k| collection << from_redis(res.shift)}
+      keys.inject([]){|collection, k| collection << unmarshal(res.shift, options[:marshal_keys][k])}
     end
 
     # Increment value by integer at field. Redis: HINCRBY
-    def incrby(field, val = 1)
-      ret = redis.hincrby(key, field, val)
+    def incrby(field, by=1)
+      ret = redis.hincrby(key, field, by)
       unless ret.is_a? Array
         ret.to_i
       else
@@ -152,6 +148,28 @@ class Redis
     end
     alias_method :incr, :incrby
 
+    # Decrement value by integer at field. Redis: HINCRBY
+    def decrby(field, by=1)
+      incrby(field, -by)
+    end
+    alias_method :decr, :decrby
+
+    # Increment value by float at field. Redis: HINCRBYFLOAT
+    def incrbyfloat(field, by=1.0)
+      ret = redis.hincrbyfloat(key, field, by)
+      unless ret.is_a? Array
+        ret.to_i
+      else
+        nil
+      end
+    end
+
+    # Decrement value by float at field. Redis: HINCRBYFLOAT
+    def decrbyfloat(field, by=1.0)
+      incrbyfloat(field, -by)
+    end
+
+    expiration_filter :[]=, :store, :bulk_set, :fill, :incrby
   end
 end
 

data/lib/redis/helpers/core_commands.rb

@@ -52,9 +52,29 @@ class Redis
 
       def sort(options={})
         options[:order] = "asc alpha" if options.keys.count == 0  # compat with Ruby
-        redis.sort(key, options)
+        val = redis.sort(key, options)
+        val.is_a?(Array) ? val.map{|v| unmarshal(v)} : val
       end
-    end
 
+      def marshal(value, domarshal=false)
+        if value.nil?
+          nil
+        elsif options[:marshal] || domarshal
+          Marshal.dump(value)
+        else
+          value
+        end
+      end
+ 
+      def unmarshal(value, domarshal=false)
+        if value.nil?
+          nil
+        elsif options[:marshal] || domarshal
+          Marshal.load(value) 
+        else
+          value
+        end
+      end
+    end
   end
 end

data/lib/redis/list.rb

@@ -10,31 +10,29 @@ 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
 
     # Works like push.  Can chain together: list << 'a' << 'b'
     def <<(value)
-      push(value)
+      push(value) # marshal in push()
       self  # for << 'a' << 'b'
     end
 
     # Add a member before or after pivot in the list. Redis: LINSERT
     def insert(where,pivot,value)
-      redis.linsert(key,where,to_redis(pivot),to_redis(value))
+      redis.linsert(key,where,marshal(pivot),marshal(value))
     end
 
     # Add a member to the end of the list. Redis: RPUSH
     def push(*values)
-      redis.rpush(key, values.map{|v| to_redis(v) })
+      redis.rpush(key, values.map{|v| marshal(v) })
       redis.ltrim(key, -options[:maxlength], -1) if options[:maxlength]
     end
 
     # Remove a member from the end of the list. Redis: RPOP
     def pop
-      from_redis redis.rpop(key)
+      unmarshal redis.rpop(key)
     end
 
     # Atomically pops a value from one list, pushes to another and returns the
@@ -46,24 +44,24 @@ class Redis
     #
     # Redis: RPOPLPUSH
     def rpoplpush(destination)
-      from_redis redis.rpoplpush(key, destination.is_a?(Redis::List) ? destination.key : destination.to_s)
+      unmarshal redis.rpoplpush(key, destination.is_a?(Redis::List) ? destination.key : destination.to_s)
     end
 
     # Add a member to the start of the list. Redis: LPUSH
     def unshift(*values)
-      redis.lpush(key, values.map{|v| to_redis(v) })
+      redis.lpush(key, values.map{|v| marshal(v) })
       redis.ltrim(key, 0, options[:maxlength] - 1) if options[:maxlength]
     end
 
     # Remove a member from the start of the list. Redis: LPOP
     def shift
-      from_redis redis.lpop(key)
+      unmarshal redis.lpop(key)
     end
 
     # Return all values in the list. Redis: LRANGE(0,-1)
     def values
-      v = from_redis range(0, -1)
-      v.nil? ? [] : v
+      vals = range(0, -1)
+      vals.nil? ? [] : vals
     end
     alias_method :get, :values
 
@@ -88,7 +86,7 @@ class Redis
 
     # Same functionality as Ruby arrays.
     def []=(index, value)
-      redis.lset(key, index, to_redis(value))
+      redis.lset(key, index, marshal(value))
     end
 
     # Delete the element(s) from the list that match name. If count is specified,
@@ -96,7 +94,7 @@ class Redis
     # Use .del to completely delete the entire key.
     # Redis: LREM
     def delete(name, count=0)
-      redis.lrem(key, count, to_redis(name))  # weird api
+      redis.lrem(key, count, marshal(name))  # weird api
     end
 
     # Iterate through each member of the set.  Redis::Objects mixes in Enumerable,
@@ -108,13 +106,13 @@ class Redis
     # Return a range of values from +start_index+ to +end_index+.  Can also use
     # the familiar list[start,end] Ruby syntax. Redis: LRANGE
     def range(start_index, end_index)
-      from_redis redis.lrange(key, start_index, end_index)
+      redis.lrange(key, start_index, end_index).map{|v| unmarshal(v) }
     end
 
     # Return the value at the given index. Can also use familiar list[index] syntax.
     # Redis: LINDEX
     def at(index)
-      from_redis redis.lindex(key, index)
+      unmarshal redis.lindex(key, index)
     end
 
     # Return the first element in the list. Redis: LINDEX(0)
@@ -145,5 +143,7 @@ class Redis
     def to_s
       values.join(', ')
     end
+
+    expiration_filter :[]=, :push, :insert, :unshift
   end
 end

data/lib/redis/objects.rb

@@ -109,6 +109,11 @@ class Redis
           downcase
       end
 
+      def redis_field_redis(name) #:nodoc:
+        klass = first_ancestor_with(name)
+        return klass.redis_objects[name.to_sym][:redis] || self.redis
+      end
+
       def redis_field_key(name, id=nil, context=self) #:nodoc:
         klass = first_ancestor_with(name)
         # READ THIS: This can never ever ever ever change or upgrades will corrupt all data
@@ -148,8 +153,13 @@ class Redis
       def redis()         self.class.redis end
       def redis_objects() self.class.redis_objects end
 
+      def redis_field_redis(name) #:nodoc:
+        return self.class.redis_field_redis(name)
+      end
+
       def redis_field_key(name) #:nodoc:
-        self.class.redis_field_key(name, send(self.class.redis_id_field), self)
+        id = send(self.class.redis_id_field)
+        self.class.redis_field_key(name, id, self)
       end
     end
   end