redis-objects 0.6.1 → 0.7.0

data/Rakefile

@@ -7,7 +7,7 @@ begin
     gem.name = "redis-objects"
     gem.summary = %Q{Map Redis types directly to Ruby objects}
     gem.description = %Q{Map Redis types directly to Ruby objects. Works with any class or ORM.}
-    gem.email = "nate@wiger.org"
+    gem.email = "nwiger@gmail.com"
     gem.homepage = "http://github.com/nateware/redis-objects"
     gem.authors = ["Nate Wiger"]
     gem.add_development_dependency "bacon", ">= 0"
@@ -30,7 +30,7 @@ end
 
 desc "run all the specs"
 task :test do
-  sh "bundle exec bacon spec/*_spec.rb"
+  sh "bacon spec/*_spec.rb"
 end
 
 

data/VERSION

@@ -1 +1 @@
-0.6.1
+0.7.0

data/lib/redis-objects.rb

@@ -0,0 +1 @@
+require 'redis/objects'

data/lib/redis/base_object.rb

@@ -4,7 +4,12 @@ class Redis
     def initialize(key, *args)
       @key     = key.is_a?(Array) ? key.flatten.join(':') : key
       @options = args.last.is_a?(Hash) ? args.pop : {}
-      @redis   = args.first || $redis || Redis.current
+      @myredis = args.first
+    end
+
+    # Dynamically query the handle to enable resetting midstream
+    def redis
+      @myredis || ::Redis::Objects.redis
     end
 
     alias :inspect :to_s  # Ruby 1.9.2

data/lib/redis/counter.rb

@@ -12,11 +12,11 @@ class Redis
     require 'redis/helpers/core_commands'
     include Redis::Helpers::CoreCommands
 
-    attr_reader :key, :options, :redis
+    attr_reader :key, :options
     def initialize(key, *args)
       super(key, *args)
       @options[:start] ||= 0
-      @redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
+      redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
     end
 
     # Reset the counter to its starting value.  Not atomic, so use with care.
@@ -52,7 +52,7 @@ class Redis
     # method is aliased as incr() for brevity.
     def increment(by=1, &block)
       val = redis.incrby(key, by).to_i
-      block_given? ? rewindable_block(:decrement, val, &block) : val
+      block_given? ? rewindable_block(:decrement, by, val, &block) : val
     end
     alias_method :incr, :increment
 
@@ -60,10 +60,10 @@ class Redis
     # 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
     # counter will automatically be incremented to its previous value.  This
-    # method is aliased as incr() for brevity.
+    # method is aliased as decr() for brevity.
     def decrement(by=1, &block)
       val = redis.decrby(key, by).to_i
-      block_given? ? rewindable_block(:increment, val, &block) : val
+      block_given? ? rewindable_block(:increment, by, val, &block) : val
     end
     alias_method :decr, :decrement
 
@@ -85,16 +85,16 @@ class Redis
     private
 
     # Implements atomic increment/decrement blocks
-    def rewindable_block(rewind, value, &block)
+    def rewindable_block(rewind, by, value, &block)
       raise ArgumentError, "Missing block to rewindable_block somehow" unless block_given?
       ret = nil
       begin
         ret = yield value
       rescue
-        send(rewind)
+        send(rewind, by)
         raise
       end
-      send(rewind) if ret.nil?
+      send(rewind, by) if ret.nil?
       ret
     end
   end

data/lib/redis/hash_key.rb

@@ -12,8 +12,7 @@ class Redis
     require 'redis/helpers/serialize'
     include Redis::Helpers::Serialize
 
-    attr_reader :key, :options, :redis
-
+    attr_reader :key, :options
     def initialize(key, *args)
       super
       @options[:marshal_keys] ||= {} 

data/lib/redis/helpers/core_commands.rb

@@ -35,7 +35,7 @@ class Redis
       end
 
       def expireat(unixtime)
-        redis.expire key, unixtime
+        redis.expireat key, unixtime
       end
 
       def persist

data/lib/redis/helpers/serialize.rb

@@ -12,8 +12,20 @@ class Redis
           dump(value)
         end
       end
-    
+ 
       def from_redis(value, marshal=false)
+        # This was removed because we can't reliably determine
+        # if a person said @value = "123.4" maybe for space/etc.
+        #begin
+        #  case value
+        #  when /^\d+$/
+        #    return Integer(value)
+        #  when /^(?:\d+\d.\d*|\d*\.\d+)$/
+        #    return Float(value)
+        #  end
+        #rescue
+        #  # continue below
+        #end
         return value unless options[:marshal] || marshal
         case value
         when Array

data/lib/redis/list.rb

@@ -13,7 +13,7 @@ class Redis
     require 'redis/helpers/serialize'
     include Redis::Helpers::Serialize
 
-    attr_reader :key, :options, :redis
+    attr_reader :key, :options
 
     # Works like push.  Can chain together: list << 'a' << 'b'
     def <<(value)
@@ -21,10 +21,10 @@ class Redis
       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))
-		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))
+    end
 
     # Add a member to the end of the list. Redis: RPUSH
     def push(value)

data/lib/redis/lock.rb

@@ -11,12 +11,12 @@ class Redis
   class Lock < BaseObject
     class LockTimeout < StandardError; end #:nodoc:
 
-    attr_reader :key, :options, :redis
+    attr_reader :key, :options
     def initialize(key, *args)
       super(key, *args)
       @options[:timeout] ||= 5
       @options[:init] = false if @options[:init].nil? # default :init to false
-      @redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
+      redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
     end
 
     # Clear the lock.  Should only be needed if there's a server crash

data/lib/redis/objects.rb

@@ -1,7 +1,16 @@
 # Redis::Objects - Lightweight object layer around redis-rb
 # See README.rdoc for usage and approach.
 require 'redis'
+
 class Redis
+  autoload :Counter,   'redis/counter'
+  autoload :List,      'redis/list'
+  autoload :Lock,      'redis/lock'
+  autoload :Set,       'redis/set'
+  autoload :SortedSet, 'redis/sorted_set'
+  autoload :Value,     'redis/value'
+  autoload :HashKey,   'redis/hash_key'
+
   #
   # Redis::Objects enables high-performance atomic operations in your app
   # by leveraging the atomic features of the Redis server.  To use Redis::Objects,
@@ -17,7 +26,7 @@ class Redis
   #     lock :archive_game
   #     set :player_ids
   #   end
-  # 
+  #
   # The, you can use these counters both for bookeeping and as atomic actions:
   #
   #   @game = Game.find(id)
@@ -38,30 +47,33 @@ class Redis
   module Objects
     dir = File.expand_path(__FILE__.sub(/\.rb$/,''))
 
-    autoload :Counters, File.join(dir, 'counters')
-    autoload :Lists, File.join(dir, 'lists')
-    autoload :Locks, File.join(dir, 'locks')
-    autoload :Sets, File.join(dir, 'sets')
-    autoload :SortedSets, File.join(dir, 'sorted_sets')
-    autoload :Values, File.join(dir, 'values')
-    autoload :Hashes, File.join(dir, 'hashes')
+    autoload :Counters,   'redis/objects/counters'
+    autoload :Lists,      'redis/objects/lists'
+    autoload :Locks,      'redis/objects/locks'
+    autoload :Sets,       'redis/objects/sets'
+    autoload :SortedSets, 'redis/objects/sorted_sets'
+    autoload :Values,     'redis/objects/values'
+    autoload :Hashes,     'redis/objects/hashes'
 
     class NotConnected < StandardError; end
     class NilObjectId  < StandardError; end
 
     class << self
-      def redis=(conn) @redis = conn end
+      def redis=(conn)
+        @redis = conn
+      end
       def redis
-        @redis ||= $redis || Redis.current || 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)
         # Core (this file)
-        klass.instance_variable_set('@redis', @redis)
+        klass.instance_variable_set('@redis', nil)
         klass.instance_variable_set('@redis_objects', {})
         klass.send :include, InstanceMethods
         klass.extend ClassMethods
-        
+
         # Pull in each object type
         klass.send :include, Redis::Objects::Counters
         klass.send :include, Redis::Objects::Lists
@@ -75,9 +87,17 @@ class Redis
 
     # Class methods that appear in your class when you include Redis::Objects.
     module ClassMethods
-      attr_writer   :redis
-      attr_accessor :redis_objects
-      def redis() @redis ||= Objects.redis end
+      # Enable per-class connections (eg, User and Post can use diff redis-server)
+      attr_writer :redis
+      def redis
+        @redis || Objects.redis
+      end
+
+      # Internal list of objects
+      attr_writer :redis_objects
+      def redis_objects
+        @redis_objects ||= {}
+      end
 
       # Set the Redis redis_prefix to use. Defaults to model_name
       def redis_prefix=(redis_prefix) @redis_prefix = redis_prefix end

data/lib/redis/objects/counters.rb

@@ -22,7 +22,7 @@ class Redis
         def counter(name, options={})
           options[:start] ||= 0
           options[:type]  ||= options[:start] == 0 ? :increment : :decrement
-          @redis_objects[name.to_sym] = options.merge(:type => :counter)
+          redis_objects[name.to_sym] = options.merge(:type => :counter)
           klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
@@ -60,7 +60,7 @@ class Redis
           verify_counter_defined!(name, id)
           initialize_counter!(name, id)
           value = redis.incrby(redis_field_key(name, id), by).to_i
-          block_given? ? rewindable_block(:decrement_counter, name, id, value, &block) : value
+          block_given? ? rewindable_block(:decrement_counter, name, id, by, value, &block) : value
         end
 
         # Decrement a counter with the specified name and id.  Accepts a block
@@ -71,13 +71,13 @@ class Redis
           verify_counter_defined!(name, id)
           initialize_counter!(name, id)
           value = redis.decrby(redis_field_key(name, id), by).to_i
-          block_given? ? rewindable_block(:increment_counter, name, id, value, &block) : value
+          block_given? ? rewindable_block(:increment_counter, name, id, by, value, &block) : value
         end
 
         # Reset a counter to its starting value.
         def reset_counter(name, id=nil, to=nil)
           verify_counter_defined!(name, id)
-          to = @redis_objects[name][:start] if to.nil?
+          to = redis_objects[name][:start] if to.nil?
           redis.set(redis_field_key(name, id), to.to_i)
           true
         end
@@ -85,7 +85,7 @@ class Redis
         # Set a counter to its starting value and return the old value.
         def getset_counter(name, id=nil, to=nil)
           verify_counter_defined!(name, id)
-          to = @redis_objects[name][:start] if to.nil?
+          to = redis_objects[name][:start] if to.nil?
           redis.getset(redis_field_key(name, id), to.to_i).to_i
         end
 
@@ -93,35 +93,35 @@ class Redis
 
         def verify_counter_defined!(name, id) #:nodoc:
           raise NoMethodError, "Undefined counter :#{name} for class #{self.name}" unless counter_defined?(name)
-          if id.nil? and !@redis_objects[name][:global]
+          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)
+          redis_objects && redis_objects.has_key?(name)
         end
 
         def initialize_counter!(name, id) #:nodoc:
           key = redis_field_key(name, id)
           unless @initialized_counters[key]
-            redis.setnx(key, @redis_objects[name][:start])
+            redis.setnx(key, redis_objects[name][:start])
           end
           @initialized_counters[key] = true
         end
 
         # Implements increment/decrement blocks on a class level
-        def rewindable_block(rewind, name, id, value, &block) #:nodoc:
+        def rewindable_block(rewind, name, id, by, value, &block) #:nodoc:
           # Unfortunately this is almost exactly duplicated from Redis::Counter
           raise ArgumentError, "Missing block to rewindable_block somehow" unless block_given?
           ret = nil
           begin
             ret = yield value
           rescue
-            send(rewind, name, id)
+            send(rewind, name, id, by)
             raise
           end
-          send(rewind, name, id) if ret.nil?
+          send(rewind, name, id, by) if ret.nil?
           ret
         end
       end

data/lib/redis/objects/hashes.rb

@@ -14,7 +14,7 @@ class Redis
         # Define a new hash key.  It will function like a regular instance
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def hash_key(name, options={})
-          @redis_objects[name.to_sym] = options.merge(:type => :dict)
+          redis_objects[name.to_sym] = options.merge(:type => :dict)
           klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods

data/lib/redis/objects/lists.rb

@@ -14,7 +14,7 @@ class Redis
         # Define a new list.  It will function like a regular instance
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def list(name, options={})
-          @redis_objects[name.to_sym] = options.merge(:type => :list)
+          redis_objects[name.to_sym] = options.merge(:type => :list)
           klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
@@ -42,4 +42,4 @@ class Redis
       end
     end
   end
-end
+end

data/lib/redis/objects/locks.rb

@@ -17,7 +17,7 @@ class Redis
         def lock(name, options={})
           options[:timeout] ||= 5  # seconds
           lock_name = "#{name}_lock"
-          @redis_objects[lock_name.to_sym] = options.merge(:type => :lock)
+          redis_objects[lock_name.to_sym] = options.merge(:type => :lock)
           klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
@@ -46,7 +46,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, redis_objects[lock_name.to_sym]).lock(&block)
         end
 
         # Clear the lock.  Use with care - usually only in an Admin page to clear
@@ -57,9 +57,9 @@ class Redis
         end
 
         private
-        
+
         def verify_lock_defined!(name)
-          unless @redis_objects.has_key?("#{name}_lock".to_sym)
+          unless redis_objects.has_key?("#{name}_lock".to_sym)
             raise Redis::Objects::UndefinedLock, "Undefined lock :#{name} for class #{self.name}"
           end
         end

data/lib/redis/objects/sets.rb

@@ -14,7 +14,7 @@ class Redis
         # Define a new list.  It will function like a regular instance
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def set(name, options={})
-          @redis_objects[name.to_sym] = options.merge(:type => :set)
+          redis_objects[name.to_sym] = options.merge(:type => :set)
           klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
@@ -34,7 +34,7 @@ class Redis
               end
             EndMethods
           end
-          
+
         end
       end
 
@@ -43,4 +43,4 @@ class Redis
       end
     end
   end
-end
+end

data/lib/redis/objects/sorted_sets.rb

@@ -14,7 +14,7 @@ class Redis
         # Define a new list.  It will function like a regular instance
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def sorted_set(name, options={})
-          @redis_objects[name.to_sym] = options.merge(:type => :sorted_set)
+          redis_objects[name.to_sym] = options.merge(:type => :sorted_set)
           klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
@@ -42,4 +42,4 @@ class Redis
       end
     end
   end
-end
+end