redis-objects 0.2.1 → 0.2.4

data/lib/redis/objects/counters.rb

@@ -4,9 +4,10 @@ require 'redis/counter'
 class Redis
   module Objects
     class UndefinedCounter < StandardError; end #:nodoc:
+    class MissingID < StandardError; end #:nodoc:
+
     module Counters
       def self.included(klass)
-        klass.instance_variable_set('@counters', {})
         klass.instance_variable_set('@initialized_counters', {})
         klass.send :include, InstanceMethods
         klass.extend ClassMethods
@@ -14,64 +15,81 @@ class Redis
 
       # Class methods that appear in your class when you include Redis::Objects.
       module ClassMethods
-        attr_reader :counters, :initialized_counters
+        attr_reader :initialized_counters
 
         # Define a new counter.  It will function like a regular instance
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def counter(name, options={})
           options[:start] ||= 0
           options[:type]  ||= options[:start] == 0 ? :increment : :decrement
-          @counters[name] = options
-          class_eval <<-EndMethods
-            def #{name}
-              @#{name} ||= Redis::Counter.new(field_key(:#{name}), redis, self.class.counters[:#{name}])
-            end
-          EndMethods
+          @redis_objects[name] = options.merge(:type => :counter)
+          if options[:global]
+            instance_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::Counter.new(field_key(:#{name}, ''), redis, @redis_objects[:#{name}])
+              end
+            EndMethods
+            class_eval <<-EndMethods
+              def #{name}
+                self.class.#{name}
+              end
+            EndMethods
+          else
+            class_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::Counter.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+              end
+            EndMethods
+          end
         end
 
         # Get the current value of the counter. It is more efficient
         # to use the instance method if possible.
-        def get_counter(name, id)
-          verify_counter_defined!(name)
+        def get_counter(name, id=nil)
+          verify_counter_defined!(name, id)
           initialize_counter!(name, id)
           redis.get(field_key(name, id)).to_i
         end
 
         # 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, by=1, &block)
-          verify_counter_defined!(name)
+        def increment_counter(name, id=nil, by=1, &block)
+          verify_counter_defined!(name, id)
           initialize_counter!(name, id)
-          value = redis.incr(field_key(name, id), by).to_i
+          value = redis.incrby(field_key(name, id), by).to_i
           block_given? ? rewindable_block(:decrement_counter, name, id, value, &block) : value
         end
 
         # 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, by=1, &block)
-          verify_counter_defined!(name)
+        def decrement_counter(name, id=nil, by=1, &block)
+          verify_counter_defined!(name, id)
           initialize_counter!(name, id)
-          value = redis.decr(field_key(name, id), by).to_i
+          value = redis.decrby(field_key(name, id), by).to_i
           block_given? ? rewindable_block(:increment_counter, name, id, value, &block) : value
         end
 
         # Reset a counter to its starting value.
-        def reset_counter(name, id, to=nil)
-          verify_counter_defined!(name)
-          to = @counters[name][:start] if to.nil?
-          redis.set(field_key(name, id), to)
+        def reset_counter(name, id=nil, to=nil)
+          verify_counter_defined!(name, id)
+          to = @redis_objects[name][:start] if to.nil?
+          redis.set(field_key(name, id), to.to_i)
+          true
         end
         
         private
         
-        def verify_counter_defined!(name) #:nodoc:
-          raise Redis::Objects::UndefinedCounter, "Undefined counter :#{name} for class #{self.name}" unless @counters.has_key?(name)
+        def verify_counter_defined!(name, id) #:nodoc:
+          raise Redis::Objects::UndefinedCounter, "Undefined counter :#{name} for class #{self.name}" unless @redis_objects.has_key?(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 initialize_counter!(name, id) #:nodoc:
           key = field_key(name, id)
           unless @initialized_counters[key]
-            redis.setnx(key, @counters[name][:start])
+            redis.setnx(key, @redis_objects[name][:start])
           end
           @initialized_counters[key] = true
         end

data/lib/redis/objects/lists.rb

@@ -5,24 +5,34 @@ class Redis
   module Objects
     module Lists
       def self.included(klass)
-        klass.instance_variable_set('@lists', {})
         klass.send :include, InstanceMethods
         klass.extend ClassMethods
       end
 
       # Class methods that appear in your class when you include Redis::Objects.
       module ClassMethods
-        attr_reader :lists
-
         # 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={})
-          @lists[name] = options
-          class_eval <<-EndMethods
-            def #{name}
-              @#{name} ||= Redis::List.new(field_key(:#{name}), redis, self.class.lists[:#{name}])
-            end
-          EndMethods
+          @redis_objects[name] = options.merge(:type => :list)
+          if options[:global]
+            instance_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::List.new(field_key(:#{name}, ''), redis, @redis_objects[:#{name}])
+              end
+            EndMethods
+            class_eval <<-EndMethods
+              def #{name}
+                self.class.#{name}
+              end
+            EndMethods
+          else
+            class_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::List.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+              end
+            EndMethods
+          end
         end
       end
 

data/lib/redis/objects/locks.rb

@@ -6,25 +6,35 @@ class Redis
     class UndefinedLock < StandardError; end #:nodoc:
     module Locks
       def self.included(klass)
-        klass.instance_variable_set('@locks', {})
         klass.send :include, InstanceMethods
         klass.extend ClassMethods
       end
 
       # Class methods that appear in your class when you include Redis::Objects.
       module ClassMethods
-        attr_reader :locks
-
         # Define a new lock.  It will function like a model attribute,
         # so it can be used alongside ActiveRecord/DataMapper, etc.
         def lock(name, options={})
           options[:timeout] ||= 5  # seconds
-          @locks[name] = options
-          class_eval <<-EndMethods
-            def #{name}_lock(&block)
-              @#{name}_lock ||= Redis::Lock.new(field_key(:#{name}_lock), redis, self.class.locks[:#{name}])
-            end
-          EndMethods
+          @redis_objects[name] = options.merge(:type => :lock)
+          if options[:global]
+            instance_eval <<-EndMethods
+              def #{name}_lock(&block)
+                @#{name} ||= Redis::Lock.new(field_key(:#{name}_lock, ''), redis, @redis_objects[:#{name}])
+              end
+            EndMethods
+            class_eval <<-EndMethods
+              def #{name}_lock(&block)
+                self.class.#{name}(block)
+              end
+            EndMethods
+          else
+            class_eval <<-EndMethods
+              def #{name}_lock(&block)
+                @#{name} ||= Redis::Lock.new(field_key(:#{name}_lock), redis, self.class.redis_objects[:#{name}])
+              end
+            EndMethods
+          end
         end
 
         # Obtain a lock, and execute the block synchronously.  Any other code
@@ -34,7 +44,7 @@ class Redis
           verify_lock_defined!(name)
           raise ArgumentError, "Missing block to #{self.name}.obtain_lock" unless block_given?
           lock_name = field_key("#{name}_lock", id)
-          Redis::Lock.new(redis, lock_name, self.class.locks[name]).lock(&block)
+          Redis::Lock.new(lock_name, redis, self.redis_objects[name]).lock(&block)
         end
 
         # Clear the lock.  Use with care - usually only in an Admin page to clear
@@ -48,7 +58,7 @@ class Redis
         private
         
         def verify_lock_defined!(name)
-          raise Redis::Objects::UndefinedLock, "Undefined lock :#{name} for class #{self.name}" unless @locks.has_key?(name)
+          raise Redis::Objects::UndefinedLock, "Undefined lock :#{name} for class #{self.name}" unless @redis_objects.has_key?(name)
         end
       end
     end

data/lib/redis/objects/sets.rb

@@ -5,24 +5,35 @@ class Redis
   module Objects
     module Sets
       def self.included(klass)
-        klass.instance_variable_set('@sets', {})
         klass.send :include, InstanceMethods
         klass.extend ClassMethods
       end
 
       # Class methods that appear in your class when you include Redis::Objects.
       module ClassMethods
-        attr_reader :sets
-
         # 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={})
-          @sets[name] = options
-          class_eval <<-EndMethods
-            def #{name}
-              @#{name} ||= Redis::Set.new(field_key(:#{name}), redis, self.class.sets[:#{name}])
-            end
-          EndMethods
+          @redis_objects[name] = options.merge(:type => :set)
+          if options[:global]
+            instance_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::Set.new(field_key(:#{name}, ''), redis, @redis_objects[:#{name}])
+              end
+            EndMethods
+            class_eval <<-EndMethods
+              def #{name}
+                self.class.#{name}
+              end
+            EndMethods
+          else
+            class_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::Set.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+              end
+            EndMethods
+          end
+          
         end
       end
 

data/lib/redis/objects/sorted_sets.rb

@@ -0,0 +1,45 @@
+# This is the class loader, for use as "include Redis::Objects::Sets"
+# For the object itself, see "Redis::Set"
+require 'redis/sorted_set'
+class Redis
+  module Objects
+    module SortedSets
+      def self.included(klass)
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+
+      # Class methods that appear in your class when you include Redis::Objects.
+      module ClassMethods
+        # 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] = options.merge(:type => :sorted_set)
+          if options[:global]
+            instance_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::SortedSet.new(field_key(:#{name}, ''), redis, @redis_objects[:#{name}])
+              end
+            EndMethods
+            class_eval <<-EndMethods
+              def #{name}
+                self.class.#{name}
+              end
+            EndMethods
+          else
+            class_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::SortedSet.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+              end
+            EndMethods
+          end
+          
+        end
+      end
+
+      # Instance methods that appear in your class when you include Redis::Objects.
+      module InstanceMethods
+      end
+    end
+  end
+end

data/lib/redis/objects/values.rb

@@ -5,27 +5,44 @@ class Redis
   module Objects
     module Values
       def self.included(klass)
-        klass.instance_variable_set('@values', {})
         klass.send :include, InstanceMethods
         klass.extend ClassMethods
       end
 
       # Class methods that appear in your class when you include Redis::Objects.
       module ClassMethods
-        attr_reader :values
-        
         # Define a new simple value.  It will function like a regular instance
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def value(name, options={})
-          @values[name] = options
-          class_eval <<-EndMethods
-            def #{name}
-              @#{name} ||= Redis::Value.new(field_key(:#{name}), redis, self.class.values[:#{name}])
-            end
-            def #{name}=(value)
-              #{name}.value = value
-            end
-          EndMethods
+          @redis_objects[name] = options.merge(:type => :value)
+          if options[:global]
+            instance_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::Value.new(field_key(:#{name}, ''), redis, @redis_objects[:#{name}])
+              end
+              def #{name}=(value)
+                #{name}.value = value
+              end
+            EndMethods
+            class_eval <<-EndMethods
+              def #{name}
+                self.class.#{name}
+              end
+              def #{name}=(value)
+                self.class.#{name} = value
+              end
+            EndMethods
+          else
+            class_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::Value.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+              end
+              def #{name}=(value)
+                #{name}.value = value
+              end
+            EndMethods
+          end
+          
         end
       end
       

data/lib/redis/objects.rb

@@ -6,7 +6,7 @@ class Redis
   # Redis::Objects enables high-performance atomic operations in your app
   # by leveraging the atomic features of the Redis server.  To use Redis::Objects,
   # first include it in any class you want.  (This example uses an ActiveRecord
-  # subclass, but that is *not* required.) Then, use +counter+ and +lock+
+  # subclass, but that is *not* required.) Then, use +counter+, +lock+, +set+, etc
   # to define your primitives:
   #
   #   class Game < ActiveRecord::Base
@@ -14,8 +14,8 @@ class Redis
   #
   #     counter :joined_players
   #     counter :active_players
-  #     set :player_ids
   #     lock :archive_game
+  #     set :player_ids
   #   end
   # 
   # The, you can use these counters both for bookeeping and as atomic actions:
@@ -39,10 +39,11 @@ class Redis
     dir = File.expand_path(__FILE__.sub(/\.rb$/,''))
 
     autoload :Counters, File.join(dir, 'counters')
-    autoload :Values, File.join(dir, 'values')
     autoload :Lists, File.join(dir, 'lists')
-    autoload :Sets, File.join(dir, 'sets')
     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')
 
     class NotConnected  < StandardError; end
 
@@ -55,22 +56,23 @@ class Redis
       def included(klass)
         # Core (this file)
         klass.instance_variable_set('@redis', @redis)
+        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::Values
         klass.send :include, Redis::Objects::Lists
-        klass.send :include, Redis::Objects::Sets
         klass.send :include, Redis::Objects::Locks
+        klass.send :include, Redis::Objects::Sets
+        klass.send :include, Redis::Objects::SortedSets
+        klass.send :include, Redis::Objects::Values
       end
     end
 
     # Class methods that appear in your class when you include Redis::Objects.
     module ClassMethods
-      attr_accessor :redis
-      
+      attr_accessor :redis, :redis_objects
 
       # Set the Redis prefix to use. Defaults to model_name
       def prefix=(prefix) @prefix = prefix end

data/lib/redis/set.rb

@@ -5,16 +5,18 @@ class Redis
   class Set
     require 'enumerator'
     include Enumerable
-    require 'redis/serialize'
-    include Redis::Serialize
+    require 'redis/helpers/core_commands'
+    include Redis::Helpers::CoreCommands
+    require 'redis/helpers/serialize'
+    include Redis::Helpers::Serialize
 
     attr_reader :key, :options, :redis
     
     # Create a new Set.
-    def initialize(key, redis=$redis, options={})
+    def initialize(key, *args)
       @key = key
-      @redis = redis
-      @options = options
+      @options = args.last.is_a?(Hash) ? args.pop : {}
+      @redis = args.first || $redis
     end
 
     # Works like add.  Can chain together: list << 'a' << 'b'
@@ -46,11 +48,6 @@ class Redis
       redis.srem(key, value)
     end
 
-    # Wipe the set entirely.  Redis: DEL
-    def clear
-      redis.del(key)
-    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)
@@ -99,11 +96,36 @@ class Redis
     alias_method :+, :union
 
     # Calculate the union and store it in Redis as +name+. Returns the number
-    # of elements in the stored union. Redis: SINTERSTORE
+    # of elements in the stored union. Redis: SUNIONSTORE
     def unionstore(name, *sets)
       redis.sunionstore(name, key, *keys_from_objects(sets))
     end
 
+    # Return the difference vs another set.  Can pass it either another set
+    # object or set name. Also available as ^ or - which is a bit cleaner:
+    #
+    #    members_difference = set1 ^ set2
+    #    members_difference = set1 - set2
+    #
+    # If you want to specify multiple sets, you must use +difference+:
+    #
+    #    members_difference = set1.difference(set2, set3, set4)
+    #    members_difference = set1.diff(set2, set3, set4)
+    #
+    # Redis: SDIFF
+    def difference(*sets)
+      from_redis redis.sdiff(key, *keys_from_objects(sets))
+    end
+    alias_method :diff, :difference
+    alias_method :^, :difference
+    alias_method :-, :difference
+
+    # Calculate the diff and store it in Redis as +name+. Returns the number
+    # of elements in the stored union. Redis: SDIFFSTORE
+    def diffstore(name, *sets)
+      redis.sdiffstore(name, key, *keys_from_objects(sets))
+    end
+
     # The number of members in the set. Aliased as size. Redis: SCARD
     def length
       redis.scard(key)