redis-objects 0.4.0 → 0.5.0

data/.gitignore

@@ -0,0 +1,3 @@
+*.gemspec
+nbproject
+pkg/

data/CHANGELOG.rdoc

@@ -1,5 +1,29 @@
 = Changelog for Redis::Objects
 
+== 0.5.0 [Final] (8 November 2010)
+
+* Incompatible change: Had to rename Redis::Hash to Redis::HashKey due to internal conflicts with Redis lib and Ruby [Nate Wiger]
+
+* Fixed AR counter override so that Redis::Objects doesn't hide AR counters [Mattias Pfeiffer]
+
+* Fixed delete problem with Redis::List and complex values [Esdras Mayrink]
+
+* Fix Redis::HashKey to support complex (marshaled) types [Mattias Pfeiffer]
+
+* Group results of SortedSet#rangebyscore and #revrangebyscore if :withscores option is passed [Szymon Nowak]
+
+* Updated Redis DEL semantics per API change [Gabe da Silveira]
+
+== 0.4.1 [Final] (23 August 2010)
+
+* Fixes for Ruby 1.8 failures due to missing flatten() [Gabe da Silveira]
+
+* 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/README.rdoc

@@ -45,7 +45,7 @@ config/initializers/redis.rb is a good place for this.)
 
     require 'redis'
     require 'redis/objects'
-    Redis::Objects.redis = Redis.new(:host => 127.0.0.1, :port => 6379)
+    Redis::Objects.redis = Redis.new(:host => '127.0.0.1', :port => 6379)
 
 Remember you can use Redis::Objects in any Ruby code.  There are *no* dependencies
 on Rails.  Standalone, Sinatra, Resque - no problem.
@@ -217,10 +217,11 @@ Complex data types are no problem with :marshal => true:
 === Hashes
 
 Hashes work like a Ruby {Hash}[http://ruby-doc.org/core/classes/Hash.html], with
-a few Redis-specific additions.
+a few Redis-specific additions.  (The class name is "HashKey" not just "Hash", due to
+conflicts with the Ruby core Hash class in other gems.)
 
-    require 'redis/hash'
-    @hash = Redis::Hash.new('hash_name')
+    require 'redis/hash_key'
+    @hash = Redis::HashKey.new('hash_name')
     @hash['a'] = 1
     @hash['b'] = 2
     @hash.each do |k,v|

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.1.1 or greater'
+    gem.add_dependency('redis', '>= 2.1.1')  # ALSO: update spec/spec_helper.rb
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+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.5.0

data/lib/redis/base_object.rb

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

data/lib/redis/counter.rb

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

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

@@ -2,7 +2,7 @@ class Redis
   #
   # Class representing a Redis hash.
   #
-  class Hash < BaseObject
+  class HashKey < BaseObject
     require 'enumerator'
     include Enumerable
     require 'redis/helpers/core_commands'
@@ -10,16 +10,11 @@ class Redis
     require 'redis/helpers/serialize'
     include Redis::Helpers::Serialize
 
-    attr_reader :key, :redis
-    
-    # Needed since Redis::Hash masks bare Hash in redis.rb
-    def self.[](*args)
-      ::Hash[*args]
-    end
+    attr_reader :key, :options, :redis
 
     # Sets a field to value
     def []=(field, value)
-      store(field, value)
+      store(field, to_redis(value))
     end
 
     # Gets the value of a field
@@ -29,12 +24,12 @@ class Redis
 
     # Redis: HSET
     def store(field, value)
-      redis.hset(key, field, value)
+      redis.hset(key, field, to_redis(value))
     end
 
     # Redis: HGET
     def fetch(field)
-      redis.hget(key, field)
+      from_redis redis.hget(key, field)
     end
 
     # Verify that a field exists. Redis: HEXISTS
@@ -57,13 +52,13 @@ class Redis
 
     # Return all the values of the hash. Redis: HVALS
     def values
-      redis.hvals(key)
+      from_redis redis.hvals(key)
     end
     alias_method :vals, :values
 
     # Retrieve the entire hash.  Redis: HGETALL
     def all
-      redis.hgetall(key)
+      from_redis redis.hgetall(key)
     end
     alias_method :clone, :all
 
@@ -71,7 +66,7 @@ class Redis
     def each(&block)
       all.each(&block)
     end
-    
+
     # Enumerate through each keys. Redis: HKEYS
     def each_key(&block)
       keys.each(&block)
@@ -102,24 +97,24 @@ 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[0], to_redis(kv[1])] })
     end
-    
+
     # Get keys in bulk, takes an array of fields as arguments. Redis: HMGET
     def bulk_get(*fields)
       hsh = {}
       res = redis.hmget(key, *fields.flatten)
       fields.each do |k|
-        hsh[k] = res.shift
+        hsh[k] = from_redis(res.shift)
       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/helpers/serialize.rb

@@ -18,6 +18,8 @@ class Redis
         case value
         when Array
           value.collect{|v| from_redis(v)}
+        when Hash
+          value.inject({}) { |h, (k, v)| h[k] = from_redis(v); h }
         else
           restore(value) rescue value
         end

data/lib/redis/list.rb

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

data/lib/redis/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,21 +74,25 @@ 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
         
         private
         
         def verify_counter_defined!(name, id) #:nodoc:
-          raise Redis::Objects::UndefinedCounter, "Undefined counter :#{name} for class #{self.name}" unless @redis_objects.has_key?(name)
+          raise Redis::Objects::UndefinedCounter, "Undefined counter :#{name} for class #{self.name}" unless counter_defined?(name)
           if id.nil? and !@redis_objects[name][:global]
             raise Redis::Objects::MissingID, "Missing ID for non-global counter #{self.name}##{name}"
           end
         end
         
+        def counter_defined?(name) #:nodoc:
+          @redis_objects && @redis_objects.has_key?(name)
+        end
+        
         def initialize_counter!(name, id) #:nodoc:
-          key = field_key(name, id)
+          key = redis_field_key(name, id)
           unless @initialized_counters[key]
             redis.setnx(key, @redis_objects[name][:start])
           end
@@ -116,14 +121,22 @@ class Redis
         # It is more efficient to use increment_[counter_name] directly.
         # This is mainly just for completeness to override ActiveRecord.
         def increment(name, by=1)
-          send(name).increment(by)
+          if self.class.send("counter_defined?", name)
+            send(name).increment(by)
+          else
+            super
+          end
         end
 
         # Decrement a counter.
         # It is more efficient to use increment_[counter_name] directly.
         # This is mainly just for completeness to override ActiveRecord.
         def decrement(name, by=1)
-          send(name).decrement(by)
+          if self.class.send("counter_defined?", name)
+            send(name).decrement(by)
+          else
+            super
+          end
         end
       end
     end

data/lib/redis/objects/hashes.rb

@@ -1,6 +1,6 @@
 # This is the class loader, for use as "include Redis::Objects::Hashes"
 # For the object itself, see "Redis::Hash"
-require 'redis/hash'
+require 'redis/hash_key'
 class Redis
   module Objects
     module Hashes
@@ -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::HashKey.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::HashKey.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/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/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

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

data/lib/redis/value.rb

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

data/redis-objects.gemspec

@@ -0,0 +1,78 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{redis-objects}
+  s.version = "0.5.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Nate Wiger"]
+  s.date = %q{2010-11-08}
+  s.description = %q{Map Redis types directly to Ruby objects. Works with any class or ORM.}
+  s.email = %q{nate@wiger.org}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "ATOMICITY.rdoc",
+     "CHANGELOG.rdoc",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/redis/base_object.rb",
+     "lib/redis/counter.rb",
+     "lib/redis/hash_key.rb",
+     "lib/redis/helpers/core_commands.rb",
+     "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",
+     "lib/redis/objects/locks.rb",
+     "lib/redis/objects/sets.rb",
+     "lib/redis/objects/sorted_sets.rb",
+     "lib/redis/objects/values.rb",
+     "lib/redis/set.rb",
+     "lib/redis/sorted_set.rb",
+     "lib/redis/value.rb",
+     "redis-objects.gemspec",
+     "spec/redis_namespace_compat_spec.rb",
+     "spec/redis_objects_instance_spec.rb",
+     "spec/redis_objects_model_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/nateware/redis-objects}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.requirements = ["redis, v2.1.1 or greater"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Map Redis types directly to Ruby objects}
+  s.test_files = [
+    "spec/redis_namespace_compat_spec.rb",
+     "spec/redis_objects_instance_spec.rb",
+     "spec/redis_objects_model_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bacon>, [">= 0"])
+      s.add_runtime_dependency(%q<redis>, [">= 2.1.1"])
+    else
+      s.add_dependency(%q<bacon>, [">= 0"])
+      s.add_dependency(%q<redis>, [">= 2.1.1"])
+    end
+  else
+    s.add_dependency(%q<bacon>, [">= 0"])
+    s.add_dependency(%q<redis>, [">= 2.1.1"])
+  end
+end
+

data/spec/redis_namespace_compat_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'redis/objects'
+Redis::Objects.redis = $redis
+
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../../redis-namespace/lib')
+require 'redis/namespace'
+
+describe 'Redis::Namespace compat' do
+  it "tests the compatibility of Hash and ::Hash conflicts" do
+    ns = Redis::Namespace.new("resque", :redis => $redis)
+    ns.instance_eval { rem_namespace({"resque:x" => nil}) }.should == {"x"=>nil}
+    class Foo
+      include Redis::Objects
+    end
+    ns.instance_eval { rem_namespace({"resque:x" => nil}) }.should == {"x"=>nil}
+  end
+end

data/spec/redis_objects_instance_spec.rb

@@ -7,7 +7,7 @@ require 'redis/value'
 require 'redis/lock'
 require 'redis/set'
 require 'redis/sorted_set'
-require 'redis/hash'
+require 'redis/hash_key'
 
 describe Redis::Value do
   before do
@@ -20,7 +20,7 @@ describe Redis::Value do
     @value.value = 'Trevor Hoffman'
     @value.should == 'Trevor Hoffman'
     @value.get.should == 'Trevor Hoffman'
-    @value.del.should.be.true
+    @value.del.should == 1
     @value.should.be.nil
   end
 
@@ -40,7 +40,7 @@ describe Redis::Value do
     @value.value = [[1,2], {:t3 => 4}]
     @value.should == [[1,2], {:t3 => 4}]
     @value.get.should == [[1,2], {:t3 => 4}]
-    @value.del.should.be.true
+    @value.del.should == 1
     @value.should.be.nil
     @value.options[:marshal] = false
   end
@@ -197,6 +197,9 @@ describe Redis::List do
       @list << [1,2,3,[4,5]]
       @list.last.should == [1,2,3,[4,5]]
       @list.shift.should == {:json => 'data'}
+      @list.size.should == 2
+      @list.delete(v2)
+      @list.size.should == 1
       @list.options[:marshal] = false
     end
     
@@ -356,12 +359,50 @@ describe Redis::Lock do
 end
 
 
-describe Redis::Hash do
+describe Redis::HashKey do
   before do
-    @hash  = Redis::Hash.new('test_hash')
+    @hash  = Redis::HashKey.new('test_hash')
     @hash.clear
   end
   
+  it "should handle complex marshaled values" do
+    @hash.options[:marshal] = true
+    @hash['abc'].should == nil
+    @hash['abc'] = {:json => 'data'}
+    @hash['abc'].should == {:json => 'data'}
+    
+    # no marshaling
+    @hash.options[:marshal] = false
+    v = {:json => 'data'}
+    @hash['abc'] = v
+    @hash['abc'].should == v.to_s
+
+    @hash.options[:marshal] = true
+    @hash['abc'] = [[1,2], {:t3 => 4}]
+    @hash['abc'].should == [[1,2], {:t3 => 4}]
+    @hash.fetch('abc').should == [[1,2], {:t3 => 4}]
+    @hash.delete('abc').should == 1
+    @hash.fetch('abc').should.be.nil
+    
+    @hash.options[:marshal] = true
+    @hash.bulk_set('abc' => [[1,2], {:t3 => 4}], 'def' => [[6,8], {:t4 => 8}])
+    hsh = @hash.bulk_get('abc', 'def', 'foo')
+    hsh['abc'].should == [[1,2], {:t3 => 4}]
+    hsh['def'].should == [[6,8], {:t4 => 8}]
+    hsh['foo'].should.be.nil
+    
+    hsh = @hash.all
+    hsh['abc'].should == [[1,2], {:t3 => 4}]
+    hsh['def'].should == [[6,8], {:t4 => 8}]
+    
+    @hash.values.should == [[[1,2], {:t3 => 4}], [[6,8], {:t4 => 8}]]
+    
+    @hash.delete('def').should == 1
+    @hash.delete('abc').should == 1
+    
+    @hash.options[:marshal] = false
+  end
+  
   it "should get and set values" do
     @hash['foo'] = 'bar'
     @hash['foo'].should == 'bar'
@@ -406,7 +447,7 @@ describe Redis::Hash do
   end
 
   it "should respond to empty?" do
-    @empty = Redis::Hash.new('test_empty_hash')
+    @empty = Redis::HashKey.new('test_empty_hash')
     @empty.respond_to?(:empty?).should == true
   end
 
@@ -501,6 +542,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 +697,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,33 @@ 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
+
+class MethodRoster
+  def increment(attribute, by=1)
+    42
+  end
+  
+  def initialize(id=1) @id = id end
+  def id; @id; end
+end
+
+class CustomMethodRoster < MethodRoster
+  include Redis::Objects
+  
+  attr_accessor :counter
+  counter :basic
+end
+
 describe Redis::Objects do
   before do
     @roster  = Roster.new
@@ -44,6 +71,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 +99,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
@@ -345,7 +378,7 @@ describe Redis::Objects do
     @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.del.should == 1
     @roster.starting_pitcher.should.be.nil
   end
 
@@ -354,7 +387,7 @@ describe Redis::Objects do
     @roster.starting_pitcher = {:json => 'data'}
     @roster.starting_pitcher.should == {:json => 'data'}
     @roster.starting_pitcher.get.should == {:json => 'data'}
-    @roster.starting_pitcher.del.should.be.true
+    @roster.starting_pitcher.del.should == 1
     @roster.starting_pitcher.should.be.nil
   end
 
@@ -612,7 +645,7 @@ describe Redis::Objects do
     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.del.should == 1
     Roster.last_player.should.be.nil
   end
 
@@ -646,7 +679,7 @@ describe Redis::Objects do
     @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.del.should == 1
     @roster.last_player.should.be.nil
     @roster2.last_player.should.be.nil
   end
@@ -690,4 +723,54 @@ 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
+  
+  it "should allow passing of increment/decrement to super class" do
+    @custom_method_roster = CustomMethodRoster.new
+    @custom_method_roster.counter.should.be.nil
+    
+    @custom_method_roster.increment(:counter).should == 42
+    
+    @custom_method_roster.increment(:basic).should == 1
+    @custom_method_roster.basic.should.be.kind_of(Redis::Counter)
+  end
 end

data/spec/spec_helper.rb

@@ -1,7 +1,8 @@
-$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+require 'rubygems'  # poor people still on 1.8
+gem 'redis', '>= 2.1.1'
 require 'redis'
 
-require 'rubygems'  # poor people still on 1.8
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
 require 'bacon'
 Bacon.summary_at_exit
 
@@ -10,3 +11,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

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 4
+  - 5
   - 0
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Nate Wiger
@@ -14,23 +14,37 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-11 00:00:00 -07:00
+date: 2010-11-08 00:00:00 -08: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 
         segments: 
-        - 2
         - 0
-        - 4
-        version: 2.0.4
-  type: :runtime
+        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 
+        segments: 
+        - 2
+        - 1
+        - 1
+        version: 2.1.1
+  type: :runtime
+  version_requirements: *id002
 description: Map Redis types directly to Ruby objects. Works with any class or ORM.
 email: nate@wiger.org
 executables: []
@@ -38,18 +52,22 @@ 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
+- lib/redis/hash_key.rb
 - lib/redis/helpers/core_commands.rb
 - 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,28 +75,25 @@ 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_namespace_compat_spec.rb
 - 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 
@@ -86,6 +101,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
@@ -93,11 +109,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       - 0
       version: "0"
 requirements: 
-- redis, v2.0.4 or greater
-rubyforge_project: redis-objects
-rubygems_version: 1.3.6
+- redis, v2.1.1 or greater
+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_namespace_compat_spec.rb
+- spec/redis_objects_instance_spec.rb
+- spec/redis_objects_model_spec.rb
+- spec/spec_helper.rb