redis-objects 0.4.0 → 0.4.1

data/.gitignore

@@ -0,0 +1,2 @@
+*.gemspec
+nbproject

data/CHANGELOG.rdoc

@@ -1,5 +1,15 @@
 = Changelog for Redis::Objects
 
+== 0.4.1 [Final] (23 August 2010)
+
+* Fixes for Ruby 1.8 failures due to missing flatten() [Gabe da Silveira]
+
+* Enable subclasses of classes mixing in Redis::Objects to automatically pick up objects from their superclasses [Gabe da Silveira]
+
+* Renamed prefix() and field_key() to redis_prefix() and redis_field_key() to prevent gem conflicts [Jason Meinzer]
+
+* Fixed a typo in delete_if and added missing test coverage [Julio Capote, Nate Wiger]
+
 == 0.4.0 [Final] (11 August 2010)
 
 * Full support for redis hashes via new Redis::Hash class [Julio Capote, Nate Wiger]

data/Rakefile

@@ -1,7 +1,60 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    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.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 is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+# require 'rake/testtask'
+# Rake::TestTask.new(:spec) do |spec|
+#   spec.libs << 'lib' << 'spec'
+#   spec.pattern = 'spec/**/*_spec.rb'
+#   spec.verbose = true
+# end
 
 task :test do
-  base = File.dirname(__FILE__)
-  Dir[base + '/spec/*_spec.rb'].each do |f|
-    sh "ruby #{f}"
+  sh "bacon spec/*_spec.rb"
+end
+
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |spec|
+    spec.libs << 'spec'
+    spec.pattern = 'spec/**/*_spec.rb'
+    spec.verbose = true
   end
-end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "Redis::Objects #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.4.1

data/lib/redis/hash.rb

@@ -11,7 +11,7 @@ class Redis
     include Redis::Helpers::Serialize
 
     attr_reader :key, :redis
-    
+
     # Needed since Redis::Hash masks bare Hash in redis.rb
     def self.[](*args)
       ::Hash[*args]
@@ -71,7 +71,7 @@ class Redis
     def each(&block)
       all.each(&block)
     end
-    
+
     # Enumerate through each keys. Redis: HKEYS
     def each_key(&block)
       keys.each(&block)
@@ -102,9 +102,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.flatten)
+      redis.hmset(key, *args.last.inject([]){ |arr,kv| arr + kv })
     end
-    
+
     # Get keys in bulk, takes an array of fields as arguments. Redis: HMGET
     def bulk_get(*fields)
       hsh = {}
@@ -114,12 +114,12 @@ class Redis
       end
       hsh
     end
-    
+
     # Increment value by integer at field. Redis: HINCRBY
     def incrby(field, val = 1)
       redis.hincrby(key, field, val).to_i
     end
-    alias_method :incr, :incrby 
+    alias_method :incr, :incrby
 
   end
 end

data/lib/redis/objects.rb

@@ -76,32 +76,41 @@ class Redis
     module ClassMethods
       attr_accessor :redis, :redis_objects
 
-      # Set the Redis prefix to use. Defaults to model_name
-      def prefix=(prefix) @prefix = prefix end
-      def prefix #:nodoc:
-        @prefix ||= self.name.to_s.
+      # Set the Redis redis_prefix to use. Defaults to model_name
+      def redis_prefix=(redis_prefix) @redis_prefix = redis_prefix end
+      def redis_prefix(klass = self) #:nodoc:
+        @redis_prefix ||= klass.name.to_s.
           sub(%r{(.*::)}, '').
           gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
           gsub(/([a-z\d])([A-Z])/,'\1_\2').
           downcase
       end
 
-      def field_key(name, id='') #:nodoc:
+      def redis_field_key(name, id='') #:nodoc:
+        klass = first_ancestor_with(name)
         # This can never ever ever ever change or upgrades will corrupt all data
-        @redis_objects[name.to_sym][:key] || "#{prefix}:#{id}:#{name}"
+        klass.redis_objects[name.to_sym][:key] || "#{redis_prefix(klass)}:#{id}:#{name}"
+      end
+
+      def first_ancestor_with(name)
+        if redis_objects && redis_objects.key?(name.to_sym)
+          self
+        elsif superclass && superclass.respond_to?(:redis_objects)
+          superclass.first_ancestor_with(name)
+        end
       end
     end
 
     # Instance methods that appear in your class when you include Redis::Objects.
     module InstanceMethods
       def redis() self.class.redis end
-      def field_key(name) #:nodoc:
-        # This can never ever ever ever change or upgrades will corrupt all data
-        if key = self.class.redis_objects[name.to_sym][:key]
+      def redis_field_key(name) #:nodoc:
+        klass = self.class.first_ancestor_with(name)
+        if key = klass.redis_objects[name.to_sym][:key]
           eval "%(#{key})"
         else
-          # don't try to refactor into class field_key because fucks up eval context
-          "#{self.class.prefix}:#{id}:#{name}"
+          # don't try to refactor into class redis_field_key because fucks up eval context
+          "#{klass.redis_prefix}:#{id}:#{name}"
         end
       end
     end

data/lib/redis/objects/counters.rb

@@ -23,10 +23,11 @@ class Redis
           options[:start] ||= 0
           options[:type]  ||= options[:start] == 0 ? :increment : :decrement
           @redis_objects[name.to_sym] = options.merge(:type => :counter)
+          klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::Counter.new(field_key(:#{name}), redis, @redis_objects[:#{name}])
+                @#{name} ||= Redis::Counter.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
               end
             EndMethods
             class_eval <<-EndMethods
@@ -37,7 +38,7 @@ class Redis
           else
             class_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::Counter.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+                @#{name} ||= Redis::Counter.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
               end
             EndMethods
           end
@@ -48,7 +49,7 @@ class Redis
         def get_counter(name, id=nil)
           verify_counter_defined!(name, id)
           initialize_counter!(name, id)
-          redis.get(field_key(name, id)).to_i
+          redis.get(redis_field_key(name, id)).to_i
         end
 
         # Increment a counter with the specified name and id.  Accepts a block
@@ -56,7 +57,7 @@ class Redis
         def increment_counter(name, id=nil, by=1, &block)
           verify_counter_defined!(name, id)
           initialize_counter!(name, id)
-          value = redis.incrby(field_key(name, id), by).to_i
+          value = redis.incrby(redis_field_key(name, id), by).to_i
           block_given? ? rewindable_block(:decrement_counter, name, id, value, &block) : value
         end
 
@@ -65,7 +66,7 @@ class Redis
         def decrement_counter(name, id=nil, by=1, &block)
           verify_counter_defined!(name, id)
           initialize_counter!(name, id)
-          value = redis.decrby(field_key(name, id), by).to_i
+          value = redis.decrby(redis_field_key(name, id), by).to_i
           block_given? ? rewindable_block(:increment_counter, name, id, value, &block) : value
         end
 
@@ -73,7 +74,7 @@ class Redis
         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)
+          redis.set(redis_field_key(name, id), to.to_i)
           true
         end
         
@@ -87,7 +88,7 @@ class Redis
         end
         
         def initialize_counter!(name, id) #:nodoc:
-          key = field_key(name, id)
+          key = redis_field_key(name, id)
           unless @initialized_counters[key]
             redis.setnx(key, @redis_objects[name][:start])
           end

data/lib/redis/objects/hashes.rb

@@ -15,10 +15,11 @@ class Redis
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def hash_key(name, options={})
           @redis_objects[name.to_sym] = options.merge(:type => :dict)
+          klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::Hash.new(field_key(:#{name}), redis, @redis_objects[:#{name}])
+                @#{name} ||= Redis::Hash.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
               end
             EndMethods
             class_eval <<-EndMethods
@@ -29,7 +30,7 @@ class Redis
           else
             class_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::Hash.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+                @#{name} ||= Redis::Hash.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
               end
             EndMethods
           end

data/lib/redis/objects/lists.rb

@@ -15,10 +15,11 @@ class Redis
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def list(name, options={})
           @redis_objects[name.to_sym] = options.merge(:type => :list)
+          klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::List.new(field_key(:#{name}), redis, @redis_objects[:#{name}])
+                @#{name} ||= Redis::List.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
               end
             EndMethods
             class_eval <<-EndMethods
@@ -29,7 +30,7 @@ class Redis
           else
             class_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::List.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+                @#{name} ||= Redis::List.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
               end
             EndMethods
           end

data/lib/redis/objects/locks.rb

@@ -18,10 +18,11 @@ class Redis
           options[:timeout] ||= 5  # seconds
           lock_name = "#{name}_lock"
           @redis_objects[lock_name.to_sym] = options.merge(:type => :lock)
+          klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
               def #{lock_name}(&block)
-                @#{lock_name} ||= Redis::Lock.new(field_key(:#{lock_name}), redis, @redis_objects[:#{lock_name}])
+                @#{lock_name} ||= Redis::Lock.new(redis_field_key(:#{lock_name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{lock_name}])
               end
             EndMethods
             class_eval <<-EndMethods
@@ -32,7 +33,7 @@ class Redis
           else
             class_eval <<-EndMethods
               def #{lock_name}(&block)
-                @#{lock_name} ||= Redis::Lock.new(field_key(:#{lock_name}), redis, self.class.redis_objects[:#{lock_name}])
+                @#{lock_name} ||= Redis::Lock.new(redis_field_key(:#{lock_name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{lock_name}])
               end
             EndMethods
           end
@@ -45,14 +46,14 @@ 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(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
         # stale locks (a stale lock should only happen if a server crashes.)
         def clear_lock(name, id)
           verify_lock_defined!(name)
-          redis.del(field_key("#{name}_lock", id))
+          redis.del(redis_field_key("#{name}_lock", id))
         end
 
         private

data/lib/redis/objects/sets.rb

@@ -15,10 +15,11 @@ class Redis
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def set(name, options={})
           @redis_objects[name.to_sym] = options.merge(:type => :set)
+          klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::Set.new(field_key(:#{name}), redis, @redis_objects[:#{name}])
+                @#{name} ||= Redis::Set.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
               end
             EndMethods
             class_eval <<-EndMethods
@@ -29,7 +30,7 @@ class Redis
           else
             class_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::Set.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+                @#{name} ||= Redis::Set.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
               end
             EndMethods
           end

data/lib/redis/objects/sorted_sets.rb

@@ -15,10 +15,11 @@ class Redis
         # 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)
+          klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::SortedSet.new(field_key(:#{name}), redis, @redis_objects[:#{name}])
+                @#{name} ||= Redis::SortedSet.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
               end
             EndMethods
             class_eval <<-EndMethods
@@ -29,7 +30,7 @@ class Redis
           else
             class_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::SortedSet.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+                @#{name} ||= Redis::SortedSet.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
               end
             EndMethods
           end

data/lib/redis/objects/values.rb

@@ -15,10 +15,11 @@ class Redis
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def value(name, options={})
           @redis_objects[name.to_sym] = options.merge(:type => :value)
+          klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::Value.new(field_key(:#{name}), redis, @redis_objects[:#{name}])
+                @#{name} ||= Redis::Value.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
               end
               def #{name}=(value)
                 #{name}.value = value
@@ -35,7 +36,7 @@ class Redis
           else
             class_eval <<-EndMethods
               def #{name}
-                @#{name} ||= Redis::Value.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+                @#{name} ||= Redis::Value.new(redis_field_key(:#{name}), #{klass_name}.redis, #{klass_name}.redis_objects[:#{name}])
               end
               def #{name}=(value)
                 #{name}.value = value

data/lib/redis/set.rb

@@ -45,10 +45,10 @@ class Redis
     end
     
     # Delete if matches block
-    def delete_if(&blk)
+    def delete_if(&block)
       res = false
       redis.smembers(key).each do |m|
-        if blk.call(from_redis(m))
+        if block.call(from_redis(m))
           res = redis.srem(key, m)
         end
       end

data/lib/redis/sorted_set.rb

@@ -144,10 +144,10 @@ class Redis
     end
 
     # Delete element if it matches block
-    def delete_if(&blocK)
+    def delete_if(&block)
       raise ArgumentError, "Missing block to SortedSet#delete_if" unless block_given?
       res = false
-      redis.zrevrange(key, 0, -1).each do |m|
+      redis.zrange(key, 0, -1).each do |m|
         if block.call(from_redis(m))
           res = redis.zrem(key, m)
         end

data/spec/redis_objects_instance_spec.rb

@@ -501,6 +501,8 @@ describe Redis::Set do
     coll = @set.select{|st| st == 'c'}
     coll.should == ['c']
     @set.sort.should == ['a','b','c']
+    @set.delete_if{|m| m == 'c'}
+    @set.sort.should == ['a','b']
   end
   
   it "should handle set intersections, unions, and diffs" do
@@ -654,61 +656,11 @@ describe Redis::SortedSet do
     @set.delete('c')
     @set.length.should == 4
     @set.size.should == 4
+    
+    @set.delete_if{|m| m == 'b'}
+    @set.size.should == 3
   end
 
-=begin
-
-  # Not until Redis 1.3.5 with hashes
-  it "Redis 1.3.5: should handle set intersections, unions, and diffs" do
-    @set_1['a'] = 5
-    @set_2['b'] = 18
-    @set_2['c'] = 12
-
-    @set_2['a'] = 10
-    @set_2['b'] = 15
-    @set_2['c'] = 15
-
-    (@set_1 & @set_2).sort.should == ['c','d','e']
-
-    @set_1 << 'a' << 'b' << 'c' << 'd' << 'e'
-    @set_2 << 'c' << 'd' << 'e' << 'f' << 'g'
-    @set_3 << 'a' << 'd' << 'g' << 'l' << 'm'
-    @set_1.sort.should == %w(a b c d e)
-    @set_2.sort.should == %w(c d e f g)
-    @set_3.sort.should == %w(a d g l m)
-    (@set_1 & @set_2).sort.should == ['c','d','e']
-    @set_1.intersection(@set_2).sort.should == ['c','d','e']
-    @set_1.intersection(@set_2, @set_3).sort.should == ['d']
-    @set_1.intersect(@set_2).sort.should == ['c','d','e']
-    @set_1.inter(@set_2, @set_3).sort.should == ['d']
-    @set_1.interstore(INTERSTORE_KEY, @set_2).should == 3
-    @set_1.redis.smembers(INTERSTORE_KEY).sort.should == ['c','d','e']
-    @set_1.interstore(INTERSTORE_KEY, @set_2, @set_3).should == 1
-    @set_1.redis.smembers(INTERSTORE_KEY).sort.should == ['d']
-
-    (@set_1 | @set_2).sort.should == ['a','b','c','d','e','f','g']
-    (@set_1 + @set_2).sort.should == ['a','b','c','d','e','f','g']
-    @set_1.union(@set_2).sort.should == ['a','b','c','d','e','f','g']
-    @set_1.union(@set_2, @set_3).sort.should == ['a','b','c','d','e','f','g','l','m']
-    @set_1.unionstore(UNIONSTORE_KEY, @set_2).should == 7
-    @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
-
-=end
-
   it "should support renaming sets" do
     @set.should.be.empty
     @set['zynga'] = 151

data/spec/redis_objects_model_spec.rb

@@ -35,6 +35,18 @@ class Roster
   def max_pitchers; 3; end
 end
 
+class VanillaRoster < Roster
+  # No explicit Redis::Objects
+end
+
+class CustomRoster < Roster
+  include Redis::Objects
+
+  counter :basic # Override
+  counter :special # New
+end
+
+
 describe Redis::Objects do
   before do
     @roster  = Roster.new
@@ -44,6 +56,9 @@ describe Redis::Objects do
     @roster_2 = Roster.new(2)
     @roster_3 = Roster.new(3)
 
+    @vanilla_roster = VanillaRoster.new
+    @custom_roster  = CustomRoster.new
+
     @roster.available_slots.reset
     @roster.pitchers.reset
     @roster.basic.reset
@@ -69,6 +84,9 @@ describe Redis::Objects do
     @roster.all_player_stats.clear
     @roster.total_wins.clear
     @roster.my_rank.clear
+
+    @custom_roster.basic.reset
+    @custom_roster.special.reset
   end
 
   it "should provide a connection method" do
@@ -690,4 +708,44 @@ describe Redis::Objects do
     error.should.not.be.nil
     error.should.be.kind_of(Redis::Lock::LockTimeout)
   end
+
+  it "should pick up objects from superclass automatically" do
+    @vanilla_roster.available_slots.should.be.kind_of(Redis::Counter)
+    @vanilla_roster.pitchers.should.be.kind_of(Redis::Counter)
+    @vanilla_roster.basic.should.be.kind_of(Redis::Counter)
+    @vanilla_roster.resort_lock.should.be.kind_of(Redis::Lock)
+    @vanilla_roster.starting_pitcher.should.be.kind_of(Redis::Value)
+    @vanilla_roster.player_stats.should.be.kind_of(Redis::List)
+    @vanilla_roster.outfielders.should.be.kind_of(Redis::Set)
+    @vanilla_roster.rank.should.be.kind_of(Redis::SortedSet)
+
+    # custom keys
+    @vanilla_roster.player_totals.should.be.kind_of(Redis::Counter)
+    @vanilla_roster.all_player_stats.should.be.kind_of(Redis::List)
+    @vanilla_roster.total_wins.should.be.kind_of(Redis::Set)
+    @vanilla_roster.my_rank.should.be.kind_of(Redis::Value)
+    @vanilla_roster.weird_key.should.be.kind_of(Redis::Value)
+
+    # globals via class
+    @vanilla_roster.total_players_online.should.be.kind_of(Redis::Counter)
+    @vanilla_roster.all_player_stats.should.be.kind_of(Redis::List)
+    @vanilla_roster.all_players_online.should.be.kind_of(Redis::Set)
+    @vanilla_roster.last_player.should.be.kind_of(Redis::Value)
+
+    VanillaRoster.total_players_online.should.be.kind_of(Redis::Counter)
+    VanillaRoster.all_player_stats.should.be.kind_of(Redis::List)
+    VanillaRoster.all_players_online.should.be.kind_of(Redis::Set)
+    VanillaRoster.last_player.should.be.kind_of(Redis::Value)
+  end
+
+  it "should allow subclass overrides of the same redis object" do
+    @roster.basic.should == 0
+    @custom_roster.basic.increment.should == 1
+    @roster2.basic.should == 0
+    CustomRoster.new.basic.should == 1
+  end
+
+  it "should handle new subclass objects" do
+    @custom_roster.special.increment.should == 1
+  end
 end

data/spec/spec_helper.rb

@@ -1,7 +1,8 @@
+require 'rubygems'  # poor people still on 1.8
+
 $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
 require 'redis'
 
-require 'rubygems'  # poor people still on 1.8
 require 'bacon'
 Bacon.summary_at_exit
 

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: redis-objects
 version: !ruby/object:Gem::Version 
+  hash: 13
   prerelease: false
   segments: 
   - 0
   - 4
-  - 0
-  version: 0.4.0
+  - 1
+  version: 0.4.1
 platform: ruby
 authors: 
 - Nate Wiger
@@ -14,23 +15,39 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-11 00:00:00 -07:00
+date: 2010-08-23 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: redis
+  name: bacon
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 7
         segments: 
         - 2
         - 0
         - 4
         version: 2.0.4
   type: :runtime
-  version_requirements: *id001
+  version_requirements: *id002
 description: Map Redis types directly to Ruby objects. Works with any class or ORM.
 email: nate@wiger.org
 executables: []
@@ -38,11 +55,14 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
 - ATOMICITY.rdoc
 - CHANGELOG.rdoc
-- Rakefile
 - README.rdoc
-files: 
+- Rakefile
+- VERSION
 - lib/redis/base_object.rb
 - lib/redis/counter.rb
 - lib/redis/hash.rb
@@ -50,6 +70,7 @@ files:
 - lib/redis/helpers/serialize.rb
 - lib/redis/list.rb
 - lib/redis/lock.rb
+- lib/redis/objects.rb
 - lib/redis/objects/counters.rb
 - lib/redis/objects/hashes.rb
 - lib/redis/objects/lists.rb
@@ -57,47 +78,48 @@ files:
 - lib/redis/objects/sets.rb
 - lib/redis/objects/sorted_sets.rb
 - lib/redis/objects/values.rb
-- lib/redis/objects.rb
 - lib/redis/set.rb
 - lib/redis/sorted_set.rb
 - lib/redis/value.rb
+- redis-objects.gemspec
 - spec/redis_objects_instance_spec.rb
 - spec/redis_objects_model_spec.rb
 - spec/spec_helper.rb
-- ATOMICITY.rdoc
-- CHANGELOG.rdoc
-- Rakefile
-- README.rdoc
 has_rdoc: true
 homepage: http://github.com/nateware/redis-objects
 licenses: []
 
 post_install_message: 
 rdoc_options: 
-- --title
-- Redis::Objects -- Use Redis types as Ruby objects
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: 
 - redis, v2.0.4 or greater
-rubyforge_project: redis-objects
-rubygems_version: 1.3.6
+rubyforge_project: 
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Maps Redis types to Ruby objects
-test_files: []
-
+summary: Map Redis types directly to Ruby objects
+test_files: 
+- spec/redis_objects_instance_spec.rb
+- spec/redis_objects_model_spec.rb
+- spec/spec_helper.rb