redis-objects 0.2.1 → 0.2.2

data/ChangeLog

@@ -0,0 +1,15 @@
+
+*0.2.2 [Final] (14 December 2009)*
+
+* Added @set.diff(@set2) with "^" and "-" synonyms (oversight). [Nate Wiger]
+
+* Implemented Redis core commands in all data types, such as rename. [Nate Wiger]
+
+* Renamed Redis::Serialize to Redis::Helpers::Serialize to keep Redis:: cleaner. [Nate Wiger]
+
+* More spec coverage. [Nate Wiger]
+
+*0.2.1 [Final] (27 November 2009)*
+
+* First worthwhile public release, with good spec coverage and functionality. [Nate Wiger]
+

data/README.rdoc

@@ -6,8 +6,8 @@ the point.
 The killer feature of Redis that it allows you to perform atomic operations
 on _individual_ data structures, like counters, lists, and sets. You can then use
 these *with* your existing ActiveRecord/DataMapper/etc models, or in classes that have
-nothing to do with an ORM or even a database.  This gem maps Ezra's +redis+ library
-to Ruby objects to make use seamless.
+nothing to do with an ORM or even a database.  This gem maps {Redis types}[http://code.google.com/p/redis/wiki/CommandReference]
+to Ruby objects, via a thin layer over Ezra's +redis+ gem.
 
 This gem originally arose out of a need for high-concurrency atomic operations;
 for a fun rant on the topic, see
@@ -23,13 +23,14 @@ or by using +new+ with the type of data structure you want to create.
     gem tumble
     gem install redis-objects
 
-== Example 1: Individual Usage
+== Example 1: Standalone Usage
 
 There is a Ruby object that maps to each Redis type.
 
 === Initialization
 
-You can either set the $redis global variable to your Redis handle:
+This gem needs a handle to the +redis+ server.  For standalone use, you can
+either set the $redis global variable to your Redis.new handle:
 
     $redis = Redis.new(:host => 'localhost', :port => 6379)
     @value = Redis::Value.new('myvalue')
@@ -43,6 +44,7 @@ Or you can pass the Redis handle into the new method:
 
 Create a new counter. The +counter_name+ is the key stored in Redis.
 
+    require 'redis/counter'
     @counter = Redis::Counter.new('counter_name')
     @counter.increment
     @counter.decrement
@@ -60,6 +62,7 @@ See the section on "Atomicity" for cool uses of atomic counter blocks.
 
 Lists work just like Ruby arrays:
 
+    require 'redis/list'
     @list = Redis::List.new('list_name')
     @list << 'a'
     @list << 'b'
@@ -87,6 +90,7 @@ Complex data types are no problem:
 
 Sets work like the Ruby {Set}[http://ruby-doc.org/core/classes/Set.html] class:
 
+    require 'redis/set'
     @set = Redis::Set.new('set_name')
     @set << 'a'
     @set << 'b'
@@ -99,7 +103,7 @@ Sets work like the Ruby {Set}[http://ruby-doc.org/core/classes/Set.html] class:
     @set.clear
     # etc
 
-You can perform Redis intersections/unions easily:
+You can perform Redis intersections/unions/diffs easily:
 
     @set1 = Redis::Set.new('set1')
     @set2 = Redis::Set.new('set2')
@@ -107,8 +111,11 @@ You can perform Redis intersections/unions easily:
     members = @set1 & @set2   # intersection
     members = @set1 | @set2   # union
     members = @set1 + @set2   # union
+    members = @set1 ^ @set2   # union
+    members = @set1 - @set2   # union
     members = @set1.intersection(@set2, @set3)  # multiple
     members = @set1.union(@set2, @set3)         # multiple
+    members = @set1.difference(@set2, @set3)    # multiple
 
 Or store them in Redis:
 
@@ -116,6 +123,8 @@ Or store them in Redis:
     members = @set1.redis.get('intername')
     @set1.unionstore('unionname', @set2, @set3)
     members = @set1.redis.get('unionname')
+    @set1.diffstore('diffname', @set2, @set3)
+    members = @set1.redis.get('diffname')
 
 And use complex data types too:
 
@@ -125,12 +134,14 @@ And use complex data types too:
     @set2 << {:name => "Jeff", :city => "Del Mar"}
 
     @set1 & @set2  # Nate
+    @set1 - @set2  # Peter
     @set1 | @set2  # all 3 people
 
 === Values
 
 Simple values are easy as well:
 
+    require 'redis/value'
     @value = Redis::Value.new('value_name')
     @value.value = 'a'
     @value.delete
@@ -141,11 +152,11 @@ Of course complex data is no problem:
     @newest  = Redis::Value.new('newest_account')
     @newest.value = @account
 
-== Example 2: Class Usage
+== Example 2: Model Class Usage
 
 Using Redis::Objects this way makes it trivial to integrate Redis types with an
 existing ActiveRecord model, DataMapper resource, or other class.  Redis::Objects
-will work with any class that provides an +id+ method that returns a unique
+will work with _any_ class that provides an +id+ method that returns a unique
 value.  Redis::Objects will automatically create keys that are unique to
 each object.
 
@@ -185,7 +196,7 @@ Familiar Ruby array operations Just Work (TM):
     @team.on_base.length  # 1
     @team.on_base.delete('player3')
 
-Sets operations work too:
+Sets work too:
     
     @team.outfielders << 'outfielder1' << 'outfielder1'
     @team.outfielders << 'outfielder2'
@@ -195,6 +206,11 @@ Sets operations work too:
     end
     player = @team.outfielders.detect{|of| of == 'outfielder2'}
 
+And you can do intersections between ORM objects (kinda cool):
+
+    @team1.outfielders | @team2.outfielders   # all outfielders
+    @team1.outfielders & @team2.outfielders   # should be empty
+
 Counters can be atomically incremented/decremented (but not assigned):
 
     @team.hits.increment  # or incr
@@ -202,14 +218,15 @@ Counters can be atomically incremented/decremented (but not assigned):
     @team.hits.incr(3)    # add 3
     @team.runs = 4        # exception
 
-For free, you get a +redis+ handle usable in your class:
+Finally, for free, you get a +redis+ handle usable in your class that
+points directly to a Redis API object:
 
     @team.redis.get('somekey')
     @team.redis.smembers('someset')
 
-You can call any operation supported by {Redis}[http://code.google.com/p/redis/wiki/CommandReference]
+You can use the +redis+ handle to directly call any {Redis command}[http://code.google.com/p/redis/wiki/CommandReference]
 
-== Atomicity
+== Atomic Counters and Locks
 
 You are probably not handling atomicity correctly in your app.  For a fun rant
 on the topic, see

data/lib/redis/counter.rb

@@ -7,6 +7,9 @@ class Redis
   # class to define a counter.
   #
   class Counter
+    require 'redis/helpers/core_commands'
+    include Redis::Helpers::CoreCommands
+
     attr_reader :key, :options, :redis
     def initialize(key, redis=$redis, options={})
       @key = key
@@ -21,7 +24,7 @@ class Redis
     # with a parent and starting over (for example, restarting a game and
     # disconnecting all players).
     def reset(to=options[:start])
-      redis.set(key, to.to_i)
+      redis.set key, to.to_i
     end
 
     # Returns the current value of the counter.  Normally just calling the
@@ -33,12 +36,6 @@ class Redis
     end
     alias_method :get, :value
 
-    # Delete a counter.  Usage discouraged.  Consider +reset+ instead.
-    def delete
-      redis.del(key)
-    end
-    alias_method :del, :delete
-
     # 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

data/lib/redis/helpers/core_commands.rb

@@ -0,0 +1,46 @@
+class Redis
+  module Helpers
+    # These are core commands that all types share (rename, etc)
+    module CoreCommands
+      def exists?
+        redis.exists key
+      end
+      
+      def delete
+        redis.del key
+      end
+      alias_method :del, :delete
+      alias_method :clear, :delete
+      
+      def type
+        redis.type key
+      end
+      
+      def rename(name, setkey=true)
+        dest = name.is_a?(self.class) ? name.key : name
+        ret  = redis.rename key, dest
+        @key = dest if ret && setkey
+        ret
+      end
+
+      def renamenx(name, setkey=true)
+        dest = name.is_a?(self.class) ? name.key : name
+        ret  = redis.renamenx key, dest
+        @key = dest if ret && setkey
+        ret
+      end
+    
+      def expire(seconds)
+        redis.expire key, seconds
+      end
+
+      def expireat(unixtime)
+        redis.expire key, unixtime
+      end
+    
+      def move(dbindex)
+        redis.move key, dbindex
+      end
+    end
+  end
+end

data/lib/redis/helpers/serialize.rb

@@ -0,0 +1,25 @@
+class Redis
+  module Helpers
+    module Serialize
+      include Marshal
+
+      def to_redis(value)
+        case value
+        when String, Fixnum, Bignum, Float
+          value
+        else
+          dump(value)
+        end
+      end
+    
+      def from_redis(value)
+        case value
+        when Array
+          value.collect{|v| from_redis(v)}
+        else
+          restore(value) rescue value
+        end
+      end
+    end
+  end
+end

data/lib/redis/list.rb

@@ -6,8 +6,10 @@ class Redis
   class List
     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
     def initialize(key, redis=$redis, options={})
@@ -63,6 +65,7 @@ class Redis
     
     # Delete the element(s) from the list that match name. If count is specified,
     # only the first-N (if positive) or last-N (if negative) will be removed.
+    # Use .del to completely delete the entire key.
     # Redis: LREM
     def delete(name, count=0)
       redis.lrem(key, count, name)  # weird api
@@ -96,11 +99,6 @@ class Redis
       at(-1)
     end
 
-    # Clear the list entirely. Redis: DEL
-    def clear
-      redis.del(key)
-    end
-
     # Return the length of the list. Aliased as size. Redis: LLEN
     def length
       redis.llen(key)

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,33 +15,46 @@ 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
           block_given? ? rewindable_block(:decrement_counter, name, id, value, &block) : value
@@ -48,30 +62,33 @@ 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, 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
           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?
+        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)
         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,38 @@ 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 +47,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(redis, lock_name, self.class.redis_objects[name]).lock(&block)
         end
 
         # Clear the lock.  Use with care - usually only in an Admin page to clear
@@ -48,7 +61,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/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

@@ -55,6 +55,7 @@ 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
         
@@ -69,8 +70,7 @@ class Redis
 
     # 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,8 +5,10 @@ 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
     
@@ -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)

data/lib/redis/value.rb

@@ -3,8 +3,10 @@ class Redis
   # Class representing a simple value.  You can use standard Ruby operations on it.
   #
   class Value
-    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
     def initialize(key, redis=$redis, options={})
@@ -15,19 +17,15 @@ class Redis
     end
 
     def value=(val)
-      redis.set(key, to_redis(val))
+      redis.set key, to_redis(val)
     end
-    
+    alias_method :set, :value=
+
     def value
       from_redis redis.get(key)
     end
     alias_method :get, :value
 
-    def delete
-      redis.del(key)
-    end
-    alias_method :del, :delete
-
     def to_s;  value.to_s; end
     alias_method :to_str, :to_s
 

data/spec/redis_objects_instance_spec.rb

@@ -36,6 +36,18 @@ describe Redis::Value do
     @value.should be_nil
   end
 
+  it "should support renaming values" do
+    @value.value = 'Peter Pan'
+    @value.key.should == 'spec/value'
+    @value.rename('spec/value2').should be_true
+    @value.key.should == 'spec/value2'
+    @value.should == 'Peter Pan'
+    old = Redis::Value.new('spec/value')
+    old.should be_nil
+    old.value = 'Tuff'
+    @value.renamenx('spec/value').should be_false
+  end
+
   after :all do
     @value.delete
   end
@@ -131,6 +143,28 @@ describe Redis::List do
     @list.last.should == [1,2,3,[4,5]]
     @list.shift.should == {:json => 'data'}
   end
+  
+  it "should support renaming lists" do
+    @list.should be_empty
+    @list << 'a' << 'b' << 'a' << 3
+    @list.should == ['a','b','a','3']
+    @list.key.should == 'spec/list'
+    @list.rename('spec/list3', false).should be_true
+    @list.key.should == 'spec/list'
+    @list.redis.del('spec/list3')
+    @list << 'a' << 'b' << 'a' << 3
+    @list.rename('spec/list2').should be_true
+    @list.key.should == 'spec/list2'
+    @list.redis.lrange(@list.key, 0, 3).should == ['a','b','a','3']
+    old = Redis::List.new('spec/list')
+    old.should be_empty
+    old << 'Tuff'
+    @list.renamenx('spec/list').should be_false
+    @list.renamenx(old).should be_false
+    @list.renamenx('spec/foo').should be_true
+    @list.clear
+    @list.redis.del('spec/list2')
+  end
 
   after :all do
     @list.clear
@@ -191,7 +225,7 @@ describe Redis::Set do
     @set.sort.should == ['a','b','c']
   end
   
-  it "should handle set intersections and unions" do
+  it "should handle set intersections, unions, and diffs" do
     @set_1 << 'a' << 'b' << 'c' << 'd' << 'e'
     @set_2 << 'c' << 'd' << 'e' << 'f' << 'g'
     @set_3 << 'a' << 'd' << 'g' << 'l' << 'm'
@@ -216,6 +250,34 @@ describe Redis::Set do
     @set_1.redis.smembers(UNIONSTORE_KEY).sort.should == ['a','b','c','d','e','f','g']
     @set_1.unionstore(UNIONSTORE_KEY, @set_2, @set_3).should == 9
     @set_1.redis.smembers(UNIONSTORE_KEY).sort.should == ['a','b','c','d','e','f','g','l','m']
+
+    (@set_1 ^ @set_2).sort.should == ["a", "b"]
+    (@set_1 - @set_2).sort.should == ["a", "b"]
+    (@set_2 - @set_1).sort.should == ["f", "g"]
+    @set_1.difference(@set_2).sort.should == ["a", "b"]
+    @set_1.diff(@set_2).sort.should == ["a", "b"]
+    @set_1.difference(@set_2, @set_3).sort.should == ['b']
+    @set_1.diffstore(DIFFSTORE_KEY, @set_2).should == 2
+    @set_1.redis.smembers(DIFFSTORE_KEY).sort.should == ['a','b']
+    @set_1.diffstore(DIFFSTORE_KEY, @set_2, @set_3).should == 1
+    @set_1.redis.smembers(DIFFSTORE_KEY).sort.should == ['b']
+  end
+
+  it "should support renaming sets" do
+    @set.should be_empty
+    @set << 'a' << 'b' << 'a' << 3
+    @set.sort.should == ['3','a','b']
+    @set.key.should == 'spec/set'
+    @set.rename('spec/set2').should be_true
+    @set.key.should == 'spec/set2'
+    old = Redis::Set.new('spec/set')
+    old.should be_empty
+    old << 'Tuff'
+    @set.renamenx('spec/set').should be_false
+    @set.renamenx(old).should be_false
+    @set.renamenx('spec/foo').should be_true
+    @set.clear
+    @set.redis.del('spec/set2')
   end
 
   after :all do

data/spec/redis_objects_model_spec.rb

@@ -9,12 +9,17 @@ class Roster
   counter :available_slots, :start => 10
   counter :pitchers, :limit => :max_pitchers
   counter :basic
-  counter :all_players_online, :global => true
   lock :resort, :timeout => 2
   value :starting_pitcher
   list :player_stats
   set :outfielders
 
+  # global class counters
+  counter :total_players_online, :global => true
+  list :all_player_stats, :global => true
+  set :all_players_online, :global => true
+  value :last_player, :global => true
+
   def initialize(id=1) @id = id end
   def id; @id; end
   def max_pitchers; 3; end
@@ -43,6 +48,12 @@ describe Redis::Objects do
     @roster_3.outfielders.clear
     @roster.redis.del(UNIONSTORE_KEY)
     @roster.redis.del(INTERSTORE_KEY)
+    @roster.redis.del(DIFFSTORE_KEY)
+    
+    Roster.total_players_online.reset
+    Roster.all_player_stats.clear
+    Roster.all_players_online.clear
+    Roster.last_player.delete
   end
 
   it "should provide a connection method" do
@@ -97,6 +108,24 @@ describe Redis::Objects do
     Roster.get_counter(:available_slots, @roster.id).should == 10
   end
 
+  it "should support class-level increment/decrement of global counters" do
+    Roster.total_players_online.should == 0
+    Roster.total_players_online.increment.should == 1
+    Roster.total_players_online.decrement.should == 0
+    Roster.total_players_online.increment(3).should == 3
+    Roster.total_players_online.decrement(2).should == 1
+    Roster.total_players_online.reset.should be_true
+    Roster.total_players_online.should == 0
+    
+    Roster.get_counter(:total_players_online).should == 0
+    Roster.increment_counter(:total_players_online).should == 1
+    Roster.increment_counter(:total_players_online, nil, 3).should == 4
+    Roster.decrement_counter(:total_players_online, nil, 2).should == 2
+    Roster.decrement_counter(:total_players_online).should == 1
+    Roster.reset_counter(:total_players_online).should == true
+    Roster.get_counter(:total_players_online).should == 0
+  end
+
   it "should take an atomic block for increment/decrement" do
     a = false
     @roster.available_slots.should == 10
@@ -259,6 +288,8 @@ describe Redis::Objects do
     @roster.starting_pitcher = 'Trevor Hoffman'
     @roster.starting_pitcher.should == 'Trevor Hoffman'
     @roster.starting_pitcher.get.should == 'Trevor Hoffman'
+    @roster.starting_pitcher = 'Tom Selleck'
+    @roster.starting_pitcher.should == 'Tom Selleck'
     @roster.starting_pitcher.del.should be_true
     @roster.starting_pitcher.should be_nil
   end
@@ -409,6 +440,162 @@ describe Redis::Objects do
     @roster_1.redis.smembers(UNIONSTORE_KEY).sort.should == ['a','b','c','d','e','f','g','l','m']
   end
 
+  it "should handle class-level global lists of simple values" do
+    Roster.all_player_stats.should be_empty
+    Roster.all_player_stats << 'a'
+    Roster.all_player_stats.should == ['a']
+    Roster.all_player_stats.get.should == ['a']
+    Roster.all_player_stats.unshift 'b'
+    Roster.all_player_stats.to_s.should == 'b, a'
+    Roster.all_player_stats.should == ['b','a']
+    Roster.all_player_stats.get.should == ['b','a']
+    Roster.all_player_stats.push 'c'
+    Roster.all_player_stats.should == ['b','a','c']
+    Roster.all_player_stats.get.should == ['b','a','c']
+    Roster.all_player_stats.first.should == 'b'
+    Roster.all_player_stats.last.should == 'c'
+    Roster.all_player_stats << 'd'
+    Roster.all_player_stats.should == ['b','a','c','d']
+    Roster.all_player_stats[1].should == 'a'
+    Roster.all_player_stats[0].should == 'b'
+    Roster.all_player_stats[2].should == 'c'
+    Roster.all_player_stats[3].should == 'd'
+    Roster.all_player_stats.include?('c').should be_true
+    Roster.all_player_stats.include?('no').should be_false
+    Roster.all_player_stats.pop.should == 'd'
+    Roster.all_player_stats[0].should == Roster.all_player_stats.at(0)
+    Roster.all_player_stats[1].should == Roster.all_player_stats.at(1)
+    Roster.all_player_stats[2].should == Roster.all_player_stats.at(2)
+    Roster.all_player_stats.should == ['b','a','c']
+    Roster.all_player_stats.get.should == ['b','a','c']
+    Roster.all_player_stats.shift.should == 'b'
+    Roster.all_player_stats.should == ['a','c']
+    Roster.all_player_stats.get.should == ['a','c']
+    Roster.all_player_stats << 'e' << 'f' << 'e'
+    Roster.all_player_stats.should == ['a','c','e','f','e']
+    Roster.all_player_stats.get.should == ['a','c','e','f','e']
+    Roster.all_player_stats.delete('e').should == 2
+    Roster.all_player_stats.should == ['a','c','f']
+    Roster.all_player_stats.get.should == ['a','c','f']
+    Roster.all_player_stats << 'j'
+    Roster.all_player_stats.should == ['a','c','f','j']
+    Roster.all_player_stats[0..2].should == ['a','c','f']
+    Roster.all_player_stats[1, 3].should == ['c','f','j']
+    Roster.all_player_stats.length.should == 4
+    Roster.all_player_stats.size.should == 4
+    Roster.all_player_stats.should == ['a','c','f','j']
+    Roster.all_player_stats.get.should == ['a','c','f','j']
+
+    i = -1
+    Roster.all_player_stats.each do |st|
+      st.should == Roster.all_player_stats[i += 1]
+    end
+    Roster.all_player_stats.should == ['a','c','f','j']
+    Roster.all_player_stats.get.should == ['a','c','f','j']
+
+    Roster.all_player_stats.each_with_index do |st,i|
+      st.should == Roster.all_player_stats[i]
+    end
+    Roster.all_player_stats.should == ['a','c','f','j']
+    Roster.all_player_stats.get.should == ['a','c','f','j']
+
+    coll = Roster.all_player_stats.collect{|st| st}
+    coll.should == ['a','c','f','j']
+    Roster.all_player_stats.should == ['a','c','f','j']
+    Roster.all_player_stats.get.should == ['a','c','f','j']
+
+    Roster.all_player_stats << 'a'
+    coll = Roster.all_player_stats.select{|st| st == 'a'}
+    coll.should == ['a','a']
+    Roster.all_player_stats.should == ['a','c','f','j','a']
+    Roster.all_player_stats.get.should == ['a','c','f','j','a']
+  end
+
+  it "should handle class-level global sets of simple values" do
+    Roster.all_players_online.should be_empty
+    Roster.all_players_online << 'a' << 'a' << 'a'
+    Roster.all_players_online.should == ['a']
+    Roster.all_players_online.get.should == ['a']
+    Roster.all_players_online << 'b' << 'b'
+    Roster.all_players_online.to_s.should == 'a, b'
+    Roster.all_players_online.should == ['a','b']
+    Roster.all_players_online.members.should == ['a','b']
+    Roster.all_players_online.get.should == ['a','b']
+    Roster.all_players_online << 'c'
+    Roster.all_players_online.sort.should == ['a','b','c']
+    Roster.all_players_online.get.sort.should == ['a','b','c']
+    Roster.all_players_online.delete('c')
+    Roster.all_players_online.should == ['a','b']
+    Roster.all_players_online.get.sort.should == ['a','b']
+    Roster.all_players_online.length.should == 2
+    Roster.all_players_online.size.should == 2
+    
+    i = 0
+    Roster.all_players_online.each do |st|
+      i += 1
+    end
+    i.should == Roster.all_players_online.length
+
+    coll = Roster.all_players_online.collect{|st| st}
+    coll.should == ['a','b']
+    Roster.all_players_online.should == ['a','b']
+    Roster.all_players_online.get.should == ['a','b']
+
+    Roster.all_players_online << 'c'
+    Roster.all_players_online.member?('c').should be_true
+    Roster.all_players_online.include?('c').should be_true
+    Roster.all_players_online.member?('no').should be_false
+    coll = Roster.all_players_online.select{|st| st == 'c'}
+    coll.should == ['c']
+    Roster.all_players_online.sort.should == ['a','b','c']
+  end
+  
+  it "should handle class-level global values" do
+    Roster.last_player.should == nil
+    Roster.last_player = 'Trevor Hoffman'
+    Roster.last_player.should == 'Trevor Hoffman'
+    Roster.last_player.get.should == 'Trevor Hoffman'
+    Roster.last_player = 'Tom Selleck'
+    Roster.last_player.should == 'Tom Selleck'
+    Roster.last_player.del.should be_true
+    Roster.last_player.should be_nil
+  end
+
+  it "should easily enable @object.class.global_objects" do
+    @roster.class.all_players_online.should be_empty
+    @roster.class.all_players_online << 'a' << 'a' << 'a'
+    @roster.class.all_players_online.should == ['a']
+    @roster2.class.all_players_online.should == ['a']
+
+    @roster.all_players_online.should == ['a']
+    @roster2.all_players_online.should == ['a']
+
+    @roster.class.all_player_stats.should be_empty
+    @roster.class.all_player_stats << 'a'
+    @roster.class.all_player_stats.should == ['a']
+    @roster.class.all_player_stats.get.should == ['a']
+    @roster.class.all_player_stats.unshift 'b'
+    @roster.class.all_player_stats.to_s.should == 'b, a'
+    @roster.class.all_player_stats.should == ['b','a']
+    @roster2.class.all_player_stats.should == ['b','a']
+
+    @roster.all_player_stats.should == ['b','a']
+    @roster2.all_player_stats.should == ['b','a']
+    @roster2.all_player_stats << 'b'
+    @roster.all_player_stats.should == ['b','a','b']
+    
+    @roster.last_player.should == nil
+    @roster.class.last_player = 'Trevor Hoffman'
+    @roster.last_player.should == 'Trevor Hoffman'
+    @roster.last_player.get.should == 'Trevor Hoffman'
+    @roster2.last_player.get.should == 'Trevor Hoffman'
+    @roster2.last_player = 'Tom Selleck'
+    @roster.last_player.should == 'Tom Selleck'
+    @roster.last_player.del.should be_true
+    @roster.last_player.should be_nil
+    @roster2.last_player.should be_nil
+  end
+
   it "should handle lists of complex data types" do
     @roster.player_stats << {:json => 'data'}
     @roster.player_stats << {:json2 => 'data2'}

data/spec/spec_helper.rb

@@ -5,3 +5,4 @@ $redis = Redis.new(:host => ENV['REDIS_HOST'], :port => ENV['REDIS_PORT'])
 
 UNIONSTORE_KEY = 'test:unionstore'
 INTERSTORE_KEY = 'test:interstore'
+DIFFSTORE_KEY  = 'test:diffstore'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: redis-objects
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors: 
 - Nate Wiger
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-27 00:00:00 -08:00
+date: 2009-12-14 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,25 +30,27 @@ extensions: []
 
 extra_rdoc_files: 
 - ATOMICITY.rdoc
+- ChangeLog
 - README.rdoc
 files: 
 - lib/redis/counter.rb
+- lib/redis/helpers/core_commands.rb
+- lib/redis/helpers/serialize.rb
 - lib/redis/list.rb
 - lib/redis/lock.rb
-- lib/redis/objects/core.rb
 - lib/redis/objects/counters.rb
 - lib/redis/objects/lists.rb
 - lib/redis/objects/locks.rb
 - lib/redis/objects/sets.rb
 - lib/redis/objects/values.rb
 - lib/redis/objects.rb
-- lib/redis/serialize.rb
 - lib/redis/set.rb
 - lib/redis/value.rb
 - spec/redis_objects_instance_spec.rb
 - spec/redis_objects_model_spec.rb
 - spec/spec_helper.rb
 - ATOMICITY.rdoc
+- ChangeLog
 - README.rdoc
 has_rdoc: true
 homepage: http://github.com/nateware/redis-objects

data/lib/redis/serialize.rb

@@ -1,23 +0,0 @@
-class Redis
-  module Serialize
-    include Marshal
-
-    def to_redis(value)
-      case value
-      when String, Fixnum, Bignum, Float
-        value
-      else
-        dump(value)
-      end
-    end
-    
-    def from_redis(value)
-      case value
-      when Array
-        value.collect{|v| from_redis(v)}
-      else
-        restore(value) rescue value
-      end
-    end
-  end
-end