redis-objects 0.4.1 → 0.5.1

data/CHANGELOG.rdoc

@@ -1,5 +1,29 @@
 = Changelog for Redis::Objects
 
+== 0.5.1 [Final] (23 May 2011)
+
+* Fixed super class delegation conflicts with Redis Counters vs ActiveRecord [Tim Aßmann]
+
+* Added zcount method to SortedSet [dunedain289]
+
+* Updated redis-objects to look for Redis.current and prefer it over global $redis variable [Jean Boussier] 
+
+* Updated URLs to reflect new redis.io website [Jérémy Lecour]
+
+== 0.5.0 [Final] (8 November 2010)
+
+* Incompatible change: Had to rename Redis::Hash to Redis::HashKey due to internal conflicts with Redis lib and Ruby [Nate Wiger]
+
+* Fixed AR counter override so that Redis::Objects doesn't hide AR counters [Mattias Pfeiffer]
+
+* Fixed delete problem with Redis::List and complex values [Esdras Mayrink]
+
+* Fix Redis::HashKey to support complex (marshaled) types [Mattias Pfeiffer]
+
+* Group results of SortedSet#rangebyscore and #revrangebyscore if :withscores option is passed [Szymon Nowak]
+
+* Updated Redis DEL semantics per API change [Gabe da Silveira]
+
 == 0.4.1 [Final] (23 August 2010)
 
 * Fixes for Ruby 1.8 failures due to missing flatten() [Gabe da Silveira]

data/README.rdoc

@@ -7,7 +7,7 @@ on _individual_ data structures, like counters, lists, and sets.  The *atomic* p
 Using an ORM wrapper that retrieves a "record", updates values, then sends those values back,
 _removes_ the atomicity, cutting the nuts off the major advantage of Redis.  Just use MySQL, k?
 
-This gem provides a Rubyish interface to Redis, by mapping {Redis types}[http://code.google.com/p/redis/wiki/CommandReference]
+This gem provides a Rubyish interface to Redis, by mapping {Redis types}[http://redis.io/commands]
 to Ruby objects, via a thin layer over Ezra's +redis+ gem.  It offers several advantages
 over the lower-level redis-rb API:
 
@@ -45,7 +45,7 @@ config/initializers/redis.rb is a good place for this.)
 
     require 'redis'
     require 'redis/objects'
-    Redis::Objects.redis = Redis.new(:host => 127.0.0.1, :port => 6379)
+    Redis::Objects.redis = Redis.new(:host => '127.0.0.1', :port => 6379)
 
 Remember you can use Redis::Objects in any Ruby code.  There are *no* dependencies
 on Rails.  Standalone, Sinatra, Resque - no problem.
@@ -111,12 +111,12 @@ Finally, for free, you get a +redis+ method that points directly to a Redis conn
     @team.redis.get('somekey')
     @team.redis.smembers('someset')
 
-You can use the +redis+ handle to directly call any {Redis API command}[http://code.google.com/p/redis/wiki/CommandReference].
+You can use the +redis+ handle to directly call any {Redis API command}[http://redis.io/commands].
 
 == Example 2: Standalone Usage
 
 There is a Ruby class that maps to each Redis type, with methods for each
-{Redis API command}[http://code.google.com/p/redis/wiki/CommandReference].
+{Redis API command}[http://redis.io/commands].
 Note that calling +new+ does not imply it's actually a "new" value - it just
 creates a mapping between that object and the corresponding Redis data structure,
 which may already exist on the redis-server.
@@ -154,7 +154,7 @@ See the section on "Atomicity" for cool uses of atomic counter blocks.
 
 === Locks
 
-A convenience class that wraps the pattern of {using +setnx+ to perform locking}[http://code.google.com/p/redis/wiki/SetnxCommand].
+A convenience class that wraps the pattern of {using +setnx+ to perform locking}[http://redis.io/commands/setnx].
 
     require 'redis/lock'
     @lock = Redis::Lock.new('image_resizing', :expiration => 15, :timeout => 0.1)
@@ -217,10 +217,11 @@ Complex data types are no problem with :marshal => true:
 === Hashes
 
 Hashes work like a Ruby {Hash}[http://ruby-doc.org/core/classes/Hash.html], with
-a few Redis-specific additions.
+a few Redis-specific additions.  (The class name is "HashKey" not just "Hash", due to
+conflicts with the Ruby core Hash class in other gems.)
 
-    require 'redis/hash'
-    @hash = Redis::Hash.new('hash_name')
+    require 'redis/hash_key'
+    @hash = Redis::HashKey.new('hash_name')
     @hash['a'] = 1
     @hash['b'] = 2
     @hash.each do |k,v|
@@ -330,7 +331,7 @@ a Hash and an Array.  You assign like a Hash, but retrieve like an Array:
     @sorted_set.incr('Peter')   # shorthand
     @sorted_set.incr('Jeff', 4)
 
-The other Redis Sorted Set commands are supported as well; see {Sorted Sets API}[http://code.google.com/p/redis/wiki/SortedSets].
+The other Redis Sorted Set commands are supported as well; see {Sorted Sets API}[http://redis.io/commands#sorted_set].
 
 == Atomic Counters and Locks
 

data/Rakefile

@@ -11,8 +11,8 @@ begin
     gem.homepage = "http://github.com/nateware/redis-objects"
     gem.authors = ["Nate Wiger"]
     gem.add_development_dependency "bacon", ">= 0"
-    gem.requirements << 'redis, v2.0.4 or greater'
-    gem.add_dependency('redis', '>= 2.0.4')
+    gem.requirements << 'redis, v2.1.1 or greater'
+    gem.add_dependency('redis', '>= 2.1.1')  # ALSO: update spec/spec_helper.rb
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new
@@ -27,6 +27,7 @@ end
 #   spec.verbose = true
 # end
 
+desc "run all the specs"
 task :test do
   sh "bacon spec/*_spec.rb"
 end

data/VERSION

@@ -1 +1 @@
-0.4.1
+0.5.1

data/lib/redis/base_object.rb

@@ -3,8 +3,10 @@ class Redis
   class BaseObject
     def initialize(key, *args)
       @key     = key.is_a?(Array) ? key.flatten.join(':') : key
-      @options = args.last.is_a?(::Hash) ? args.pop : {}  # ::Hash because of Redis::Hash
-      @redis   = args.first || $redis
+      @options = args.last.is_a?(Hash) ? args.pop : {}
+      @redis   = args.first || $redis || Redis.current
     end
+
+    alias :inspect :to_s  # Ruby 1.9.2
   end
 end

data/lib/redis/counter.rb

@@ -62,7 +62,6 @@ class Redis
     ##
     # Proxy methods to help make @object.counter == 10 work
     def to_s; value.to_s; end
-    alias_method :to_str, :to_s
     alias_method :to_i, :value
     def nil?; value.nil? end
 

data/lib/redis/{hash.rb → hash_key.rb}

@@ -1,8 +1,10 @@
+require File.dirname(__FILE__) + '/base_object'
+
 class Redis
   #
   # Class representing a Redis hash.
   #
-  class Hash < BaseObject
+  class HashKey < BaseObject
     require 'enumerator'
     include Enumerable
     require 'redis/helpers/core_commands'
@@ -10,7 +12,12 @@ class Redis
     require 'redis/helpers/serialize'
     include Redis::Helpers::Serialize
 
-    attr_reader :key, :redis
+    attr_reader :key, :options, :redis
+
+    def initialize(key, *args)
+      super
+      @options[:marshal_keys] ||= {} 
+    end
 
     # Needed since Redis::Hash masks bare Hash in redis.rb
     def self.[](*args)
@@ -19,7 +26,7 @@ class Redis
 
     # Sets a field to value
     def []=(field, value)
-      store(field, value)
+      store(field, to_redis(value))
     end
 
     # Gets the value of a field
@@ -29,12 +36,12 @@ class Redis
 
     # Redis: HSET
     def store(field, value)
-      redis.hset(key, field, value)
+      redis.hset(key, field, to_redis(value, options[:marshal_keys][field]))
     end
 
     # Redis: HGET
     def fetch(field)
-      redis.hget(key, field)
+      from_redis redis.hget(key, field), options[:marshal_keys][field]
     end
 
     # Verify that a field exists. Redis: HEXISTS
@@ -57,13 +64,15 @@ class Redis
 
     # Return all the values of the hash. Redis: HVALS
     def values
-      redis.hvals(key)
+      from_redis redis.hvals(key)
     end
     alias_method :vals, :values
 
     # Retrieve the entire hash.  Redis: HGETALL
     def all
-      redis.hgetall(key)
+      h = redis.hgetall(key)
+      h.each { |k,v| h[k] = from_redis(v, options[:marshal_keys][k]) }
+      h
     end
     alias_method :clone, :all
 
@@ -102,7 +111,9 @@ class Redis
     # Set keys in bulk, takes a hash of field/values {'field1' => 'val1'}. Redis: HMSET
     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 })
+      redis.hmset(key, *args.last.inject([]){ |arr,kv|
+        arr + [kv[0], to_redis(kv[1], options[:marshal_keys][kv[0]])]
+      })
     end
 
     # Get keys in bulk, takes an array of fields as arguments. Redis: HMGET
@@ -110,14 +121,19 @@ class Redis
       hsh = {}
       res = redis.hmget(key, *fields.flatten)
       fields.each do |k|
-        hsh[k] = res.shift
+        hsh[k] = from_redis(res.shift, options[:marshal_keys][k])
       end
       hsh
     end
 
     # Increment value by integer at field. Redis: HINCRBY
     def incrby(field, val = 1)
-      redis.hincrby(key, field, val).to_i
+      ret = redis.hincrby(key, field, val)
+      unless ret.is_a? Array
+        ret.to_i
+      else
+        nil
+      end
     end
     alias_method :incr, :incrby
 

data/lib/redis/helpers/core_commands.rb

@@ -41,14 +41,12 @@ class Redis
       def move(dbindex)
         redis.move key, dbindex
       end
-      
-      # See the documentation for SORT: http://code.google.com/p/redis/wiki/SortCommand
-      # TODO
-      # def sort(options)
-      #   args = []
-      #   args += ['sort']
-      #   from_redis redis.sort key
-      # end
+
+      def sort(options={})
+        options[:order] ||= "asc alpha"
+        redis.sort(key, options)
+      end
     end
+
   end
 end

data/lib/redis/helpers/serialize.rb

@@ -3,8 +3,8 @@ class Redis
     module Serialize
       include Marshal
 
-      def to_redis(value)
-        return value unless options[:marshal]
+      def to_redis(value, marshal=false)
+        return value unless options[:marshal] || marshal
         case value
         when String, Fixnum, Bignum, Float
           value
@@ -13,15 +13,17 @@ class Redis
         end
       end
     
-      def from_redis(value)
-        return value unless options[:marshal]
+      def from_redis(value, marshal=false)
+        return value unless options[:marshal] || marshal
         case value
         when Array
           value.collect{|v| from_redis(v)}
+        when Hash
+          value.inject({}) { |h, (k, v)| h[k] = from_redis(v); h }
         else
           restore(value) rescue value
         end
       end
     end
   end
-end
+end

data/lib/redis/list.rb

@@ -73,7 +73,7 @@ class Redis
     # Use .del to completely delete the entire key.
     # Redis: LREM
     def delete(name, count=0)
-      redis.lrem(key, count, name)  # weird api
+      redis.lrem(key, count, to_redis(name))  # weird api
     end
 
     # Iterate through each member of the set.  Redis::Objects mixes in Enumerable,

data/lib/redis/lock.rb

@@ -41,7 +41,7 @@ class Redis
 
         # Lock is being held.  Now check to see if it's expired (if we're using
         # lock expiration).
-        # See "Handling Deadlocks" section on http://code.google.com/p/redis/wiki/SetnxCommand
+        # See "Handling Deadlocks" section on http://redis.io/commands/setnx
         if !@options[:expiration].nil?
           old_expiration = redis.get(key).to_f
 

data/lib/redis/objects/counters.rb

@@ -55,6 +55,7 @@ class Redis
         # Increment a counter with the specified name and id.  Accepts a block
         # like the instance method.  See Redis::Objects::Counter for details.
         def increment_counter(name, id=nil, by=1, &block)
+          return super(name, id) unless counter_defined?(name)
           verify_counter_defined!(name, id)
           initialize_counter!(name, id)
           value = redis.incrby(redis_field_key(name, id), by).to_i
@@ -64,6 +65,7 @@ class Redis
         # Decrement a counter with the specified name and id.  Accepts a block
         # like the instance method.  See Redis::Objects::Counter for details.
         def decrement_counter(name, id=nil, by=1, &block)
+          return super(name, id) unless counter_defined?(name)
           verify_counter_defined!(name, id)
           initialize_counter!(name, id)
           value = redis.decrby(redis_field_key(name, id), by).to_i
@@ -81,12 +83,16 @@ class Redis
         private
         
         def verify_counter_defined!(name, id) #:nodoc:
-          raise Redis::Objects::UndefinedCounter, "Undefined counter :#{name} for class #{self.name}" unless @redis_objects.has_key?(name)
+          raise NoMethodError, "Undefined counter :#{name} for class #{self.name}" unless counter_defined?(name)
           if id.nil? and !@redis_objects[name][:global]
             raise Redis::Objects::MissingID, "Missing ID for non-global counter #{self.name}##{name}"
           end
         end
         
+        def counter_defined?(name) #:nodoc:
+          @redis_objects && @redis_objects.has_key?(name)
+        end
+        
         def initialize_counter!(name, id) #:nodoc:
           key = redis_field_key(name, id)
           unless @initialized_counters[key]
@@ -117,16 +123,24 @@ class Redis
         # It is more efficient to use increment_[counter_name] directly.
         # This is mainly just for completeness to override ActiveRecord.
         def increment(name, by=1)
-          send(name).increment(by)
+          if self.class.send("counter_defined?", name)
+            send(name).increment(by)
+          else
+            super
+          end
         end
 
         # Decrement a counter.
         # It is more efficient to use increment_[counter_name] directly.
         # This is mainly just for completeness to override ActiveRecord.
         def decrement(name, by=1)
-          send(name).decrement(by)
+          if self.class.send("counter_defined?", name)
+            send(name).decrement(by)
+          else
+            super
+          end
         end
       end
     end
   end
-end
+end

data/lib/redis/objects/hashes.rb

@@ -1,6 +1,6 @@
 # This is the class loader, for use as "include Redis::Objects::Hashes"
 # For the object itself, see "Redis::Hash"
-require 'redis/hash'
+require 'redis/hash_key'
 class Redis
   module Objects
     module Hashes
@@ -19,7 +19,7 @@ class Redis
           if options[:global]
             instance_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::Hash.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
+                @#{name} ||= Redis::HashKey.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
               end
             EndMethods
             class_eval <<-EndMethods
@@ -30,7 +30,7 @@ class Redis
           else
             class_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::Hash.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
+                @#{name} ||= Redis::HashKey.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
               end
             EndMethods
           end

data/lib/redis/objects.rb

@@ -46,12 +46,13 @@ class Redis
     autoload :Values, File.join(dir, 'values')
     autoload :Hashes, File.join(dir, 'hashes')
 
-    class NotConnected  < StandardError; end
+    class NotConnected < StandardError; end
+    class NilObjectId  < StandardError; end
 
     class << self
       def redis=(conn) @redis = conn end
       def redis
-        @redis ||= $redis || raise(NotConnected, "Redis::Objects.redis not set to a Redis.new connection")
+        @redis ||= $redis || Redis.current || raise(NotConnected, "Redis::Objects.redis not set to a Redis.new connection")
       end
 
       def included(klass)
@@ -74,7 +75,9 @@ class Redis
 
     # Class methods that appear in your class when you include Redis::Objects.
     module ClassMethods
-      attr_accessor :redis, :redis_objects
+      attr_writer   :redis
+      attr_accessor :redis_objects
+      def redis() @redis ||= Objects.redis end
 
       # Set the Redis redis_prefix to use. Defaults to model_name
       def redis_prefix=(redis_prefix) @redis_prefix = redis_prefix end
@@ -86,10 +89,19 @@ class Redis
           downcase
       end
 
-      def redis_field_key(name, id='') #:nodoc:
+      def redis_field_key(name, id=nil) #:nodoc:
         klass = first_ancestor_with(name)
-        # This can never ever ever ever change or upgrades will corrupt all data
-        klass.redis_objects[name.to_sym][:key] || "#{redis_prefix(klass)}:#{id}:#{name}"
+        # READ THIS: This can never ever ever ever change or upgrades will corrupt all data
+        # I don't think people were using Proc as keys before (that would create a weird key). Should be ok
+        key = klass.redis_objects[name.to_sym][:key]
+        if key && key.respond_to?(:call)
+          key = key.call self
+        end
+        if id.nil? and !klass.redis_objects[name.to_sym][:global]
+          raise NilObjectId,
+            "[#{klass.redis_objects[name.to_sym]}] Attempt to address redis-object :#{name} on class #{klass.name} with nil id (unsaved record?) [object_id=#{object_id}]"
+        end
+        key || "#{redis_prefix(klass)}:#{id}:#{name}"
       end
 
       def first_ancestor_with(name)
@@ -107,8 +119,16 @@ class Redis
       def redis_field_key(name) #:nodoc:
         klass = self.class.first_ancestor_with(name)
         if key = klass.redis_objects[name.to_sym][:key]
-          eval "%(#{key})"
+          if key.respond_to?(:call)
+            key.call self
+          else
+            eval "%(#{key})"
+          end
         else
+          if id.nil? and !klass.redis_objects[name.to_sym][:global]
+            raise NilObjectId,
+              "Attempt to address redis-object :#{name} on class #{klass.name} with nil id (unsaved record?) [object_id=#{object_id}]"
+          end
           # don't try to refactor into class redis_field_key because fucks up eval context
           "#{klass.redis_prefix}:#{id}:#{name}"
         end

data/lib/redis/sorted_set.rb

@@ -16,7 +16,7 @@ class Redis
 
     # How to add values using a sorted set.  The key is the member, eg,
     # "Peter", and the value is the score, eg, 163.  So:
-    #    num_posts['Peter'] = 163 
+    #    num_posts['Peter'] = 163
     def []=(member, score)
       add(member, score)
     end
@@ -77,11 +77,7 @@ class Redis
     def range(start_index, end_index, options={})
       if options[:withscores] || options[:with_scores]
         val = from_redis redis.zrange(key, start_index, end_index, :with_scores => true)
-        ret = []
-        while k = val.shift and v = val.shift
-          ret << [k, v.to_f]
-        end
-        ret
+        group_set_with_scores(val)
       else
         from_redis redis.zrange(key, start_index, end_index)
       end
@@ -91,11 +87,7 @@ class Redis
     def revrange(start_index, end_index, options={})
       if options[:withscores] || options[:with_scores]
         val = from_redis redis.zrevrange(key, start_index, end_index, :with_scores => true)
-        ret = []
-        while k = val.shift and v = val.shift
-          ret << [k, v.to_f]
-        end
-        ret
+        group_set_with_scores(val)
       else
         from_redis redis.zrevrange(key, start_index, end_index)
       end
@@ -111,7 +103,13 @@ class Redis
       args[:limit] = [options[:offset] || 0, options[:limit] || options[:count]] if
                 options[:offset] || options[:limit] || options[:count]
       args[:with_scores] = true if options[:withscores] || options[:with_scores]
-      from_redis redis.zrangebyscore(key, min, max, args)
+
+      if args[:with_scores]
+        val = from_redis redis.zrangebyscore(key, min, max, args)
+        group_set_with_scores(val)
+      else
+        from_redis redis.zrangebyscore(key, min, max, args)
+      end
     end
 
     # Forwards compat (not yet implemented in Redis)
@@ -120,13 +118,19 @@ class Redis
       args[:limit] = [options[:offset] || 0, options[:limit] || options[:count]] if
                 options[:offset] || options[:limit] || options[:count]
       args[:with_scores] = true if options[:withscores] || options[:with_scores]
-      from_redis redis.zrevrangebyscore(key, min, max, args)
+
+      if args[:with_scores]
+        val = from_redis redis.zrevrangebyscore(key, min, max, args)
+        group_set_with_scores(val)
+      else
+        from_redis redis.zrevrangebyscore(key, min, max, args)
+      end
     end
 
     # Remove all elements in the sorted set at key with rank between start and end. Start and end are
     # 0-based with rank 0 being the element with the lowest score. Both start and end can be negative
     # numbers, where they indicate offsets starting at the element with the highest rank. For example:
-    # -1 is the element with the highest score, -2 the element with the second highest score and so forth. 
+    # -1 is the element with the highest score, -2 the element with the second highest score and so forth.
     # Redis: ZREMRANGEBYRANK
     def remrangebyrank(min, max)
       redis.zremrangebyrank(key, min, max)
@@ -163,7 +167,7 @@ class Redis
     alias_method :incr, :increment
     alias_method :incrby, :increment
 
-    # Convenience to calling increment() with a negative number. 
+    # Convenience to calling increment() with a negative number.
     def decrement(by=1)
       redis.zincrby(key, -by).to_i
     end
@@ -187,7 +191,7 @@ class Redis
     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)
@@ -250,7 +254,7 @@ class Redis
     def ==(x)
       members == x
     end
-    
+
     def to_s
       members.join(', ')
     end
@@ -270,19 +274,31 @@ class Redis
     def last
       at(-1)
     end
-    
+
     # The number of members in the set. Aliased as size. Redis: ZCARD
     def length
       redis.zcard(key)
     end
     alias_method :size, :length
+    
+    # The number of members within a range of scores. Redis: ZCOUNT
+    def range_size(min, max)
+      redis.zcount(key, min, max)
+    end
 
     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::SortedSet) ? set.key : set}
     end
-    
+
+    def group_set_with_scores(set_with_scores)
+      ret = []
+      while k = set_with_scores.shift and v = set_with_scores.shift
+        ret << [k, v.to_f]
+      end
+      ret
+    end
   end
 end

data/lib/redis/value.rb

@@ -27,8 +27,6 @@ class Redis
     alias_method :get, :value
 
     def to_s;  value.to_s; end
-    alias_method :to_str, :to_s
-
     def ==(x); value == x; end
     def nil?;  value.nil?; end
   end