redis-objects 0.5.0 → 0.5.1

data/CHANGELOG.rdoc

@@ -1,5 +1,15 @@
 = Changelog for Redis::Objects
 
+== 0.5.1 [Final] (23 May 2011)
+
+* Fixed super class delegation conflicts with Redis Counters vs ActiveRecord [Tim Aßmann]
+
+* Added zcount method to SortedSet [dunedain289]
+
+* Updated redis-objects to look for Redis.current and prefer it over global $redis variable [Jean Boussier] 
+
+* Updated URLs to reflect new redis.io website [Jérémy Lecour]
+
 == 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]

data/README.rdoc

@@ -7,7 +7,7 @@ on _individual_ data structures, like counters, lists, and sets.  The *atomic* p
 Using an ORM wrapper that retrieves a "record", updates values, then sends those values back,
 _removes_ the atomicity, cutting the nuts off the major advantage of Redis.  Just use MySQL, k?
 
-This gem provides a Rubyish interface to Redis, by mapping {Redis types}[http://code.google.com/p/redis/wiki/CommandReference]
+This gem provides a Rubyish interface to Redis, by mapping {Redis types}[http://redis.io/commands]
 to Ruby objects, via a thin layer over Ezra's +redis+ gem.  It offers several advantages
 over the lower-level redis-rb API:
 
@@ -111,12 +111,12 @@ Finally, for free, you get a +redis+ method that points directly to a Redis conn
     @team.redis.get('somekey')
     @team.redis.smembers('someset')
 
-You can use the +redis+ handle to directly call any {Redis API command}[http://code.google.com/p/redis/wiki/CommandReference].
+You can use the +redis+ handle to directly call any {Redis API command}[http://redis.io/commands].
 
 == Example 2: Standalone Usage
 
 There is a Ruby class that maps to each Redis type, with methods for each
-{Redis API command}[http://code.google.com/p/redis/wiki/CommandReference].
+{Redis API command}[http://redis.io/commands].
 Note that calling +new+ does not imply it's actually a "new" value - it just
 creates a mapping between that object and the corresponding Redis data structure,
 which may already exist on the redis-server.
@@ -154,7 +154,7 @@ See the section on "Atomicity" for cool uses of atomic counter blocks.
 
 === Locks
 
-A convenience class that wraps the pattern of {using +setnx+ to perform locking}[http://code.google.com/p/redis/wiki/SetnxCommand].
+A convenience class that wraps the pattern of {using +setnx+ to perform locking}[http://redis.io/commands/setnx].
 
     require 'redis/lock'
     @lock = Redis::Lock.new('image_resizing', :expiration => 15, :timeout => 0.1)
@@ -331,7 +331,7 @@ a Hash and an Array.  You assign like a Hash, but retrieve like an Array:
     @sorted_set.incr('Peter')   # shorthand
     @sorted_set.incr('Jeff', 4)
 
-The other Redis Sorted Set commands are supported as well; see {Sorted Sets API}[http://code.google.com/p/redis/wiki/SortedSets].
+The other Redis Sorted Set commands are supported as well; see {Sorted Sets API}[http://redis.io/commands#sorted_set].
 
 == Atomic Counters and Locks
 

data/Rakefile

@@ -27,6 +27,7 @@ end
 #   spec.verbose = true
 # end
 
+desc "run all the specs"
 task :test do
   sh "bacon spec/*_spec.rb"
 end

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.5.1

data/lib/redis/base_object.rb

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

data/lib/redis/hash_key.rb

@@ -1,3 +1,5 @@
+require File.dirname(__FILE__) + '/base_object'
+
 class Redis
   #
   # Class representing a Redis hash.
@@ -12,6 +14,16 @@ class Redis
 
     attr_reader :key, :options, :redis
 
+    def initialize(key, *args)
+      super
+      @options[:marshal_keys] ||= {} 
+    end
+
+    # Needed since Redis::Hash masks bare Hash in redis.rb
+    def self.[](*args)
+      ::Hash[*args]
+    end
+
     # Sets a field to value
     def []=(field, value)
       store(field, to_redis(value))
@@ -24,12 +36,12 @@ class Redis
 
     # Redis: HSET
     def store(field, value)
-      redis.hset(key, field, to_redis(value))
+      redis.hset(key, field, to_redis(value, options[:marshal_keys][field]))
     end
 
     # Redis: HGET
     def fetch(field)
-      from_redis redis.hget(key, field)
+      from_redis redis.hget(key, field), options[:marshal_keys][field]
     end
 
     # Verify that a field exists. Redis: HEXISTS
@@ -58,7 +70,9 @@ class Redis
 
     # Retrieve the entire hash.  Redis: HGETALL
     def all
-      from_redis redis.hgetall(key)
+      h = redis.hgetall(key)
+      h.each { |k,v| h[k] = from_redis(v, options[:marshal_keys][k]) }
+      h
     end
     alias_method :clone, :all
 
@@ -97,7 +111,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.inject([]){ |arr,kv| arr + [kv[0], to_redis(kv[1])] })
+      redis.hmset(key, *args.last.inject([]){ |arr,kv|
+        arr + [kv[0], to_redis(kv[1], options[:marshal_keys][kv[0]])]
+      })
     end
 
     # Get keys in bulk, takes an array of fields as arguments. Redis: HMGET
@@ -105,14 +121,19 @@ class Redis
       hsh = {}
       res = redis.hmget(key, *fields.flatten)
       fields.each do |k|
-        hsh[k] = from_redis(res.shift)
+        hsh[k] = from_redis(res.shift, options[:marshal_keys][k])
       end
       hsh
     end
 
     # Increment value by integer at field. Redis: HINCRBY
     def incrby(field, val = 1)
-      redis.hincrby(key, field, val).to_i
+      ret = redis.hincrby(key, field, val)
+      unless ret.is_a? Array
+        ret.to_i
+      else
+        nil
+      end
     end
     alias_method :incr, :incrby
 

data/lib/redis/helpers/core_commands.rb

@@ -41,14 +41,12 @@ class Redis
       def move(dbindex)
         redis.move key, dbindex
       end
-      
-      # See the documentation for SORT: http://code.google.com/p/redis/wiki/SortCommand
-      # TODO
-      # def sort(options)
-      #   args = []
-      #   args += ['sort']
-      #   from_redis redis.sort key
-      # end
+
+      def sort(options={})
+        options[:order] ||= "asc alpha"
+        redis.sort(key, options)
+      end
     end
+
   end
 end

data/lib/redis/helpers/serialize.rb

@@ -3,8 +3,8 @@ class Redis
     module Serialize
       include Marshal
 
-      def to_redis(value)
-        return value unless options[:marshal]
+      def to_redis(value, marshal=false)
+        return value unless options[:marshal] || marshal
         case value
         when String, Fixnum, Bignum, Float
           value
@@ -13,8 +13,8 @@ class Redis
         end
       end
     
-      def from_redis(value)
-        return value unless options[:marshal]
+      def from_redis(value, marshal=false)
+        return value unless options[:marshal] || marshal
         case value
         when Array
           value.collect{|v| from_redis(v)}
@@ -26,4 +26,4 @@ class Redis
       end
     end
   end
-end
+end

data/lib/redis/lock.rb

@@ -41,7 +41,7 @@ class Redis
 
         # Lock is being held.  Now check to see if it's expired (if we're using
         # lock expiration).
-        # See "Handling Deadlocks" section on http://code.google.com/p/redis/wiki/SetnxCommand
+        # See "Handling Deadlocks" section on http://redis.io/commands/setnx
         if !@options[:expiration].nil?
           old_expiration = redis.get(key).to_f
 

data/lib/redis/objects/counters.rb

@@ -55,6 +55,7 @@ class Redis
         # 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=nil, by=1, &block)
+          return super(name, id) unless counter_defined?(name)
           verify_counter_defined!(name, id)
           initialize_counter!(name, id)
           value = redis.incrby(redis_field_key(name, id), by).to_i
@@ -64,6 +65,7 @@ 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=nil, by=1, &block)
+          return super(name, id) unless counter_defined?(name)
           verify_counter_defined!(name, id)
           initialize_counter!(name, id)
           value = redis.decrby(redis_field_key(name, id), by).to_i
@@ -81,7 +83,7 @@ class Redis
         private
         
         def verify_counter_defined!(name, id) #:nodoc:
-          raise Redis::Objects::UndefinedCounter, "Undefined counter :#{name} for class #{self.name}" unless counter_defined?(name)
+          raise NoMethodError, "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
@@ -141,4 +143,4 @@ class Redis
       end
     end
   end
-end
+end

data/lib/redis/objects.rb

@@ -46,12 +46,13 @@ class Redis
     autoload :Values, File.join(dir, 'values')
     autoload :Hashes, File.join(dir, 'hashes')
 
-    class NotConnected  < StandardError; end
+    class NotConnected < StandardError; end
+    class NilObjectId  < StandardError; end
 
     class << self
       def redis=(conn) @redis = conn end
       def redis
-        @redis ||= $redis || raise(NotConnected, "Redis::Objects.redis not set to a Redis.new connection")
+        @redis ||= $redis || Redis.current || raise(NotConnected, "Redis::Objects.redis not set to a Redis.new connection")
       end
 
       def included(klass)
@@ -74,7 +75,9 @@ class Redis
 
     # Class methods that appear in your class when you include Redis::Objects.
     module ClassMethods
-      attr_accessor :redis, :redis_objects
+      attr_writer   :redis
+      attr_accessor :redis_objects
+      def redis() @redis ||= Objects.redis end
 
       # Set the Redis redis_prefix to use. Defaults to model_name
       def redis_prefix=(redis_prefix) @redis_prefix = redis_prefix end
@@ -86,10 +89,19 @@ class Redis
           downcase
       end
 
-      def redis_field_key(name, id='') #:nodoc:
+      def redis_field_key(name, id=nil) #:nodoc:
         klass = first_ancestor_with(name)
-        # This can never ever ever ever change or upgrades will corrupt all data
-        klass.redis_objects[name.to_sym][:key] || "#{redis_prefix(klass)}:#{id}:#{name}"
+        # READ THIS: This can never ever ever ever change or upgrades will corrupt all data
+        # I don't think people were using Proc as keys before (that would create a weird key). Should be ok
+        key = klass.redis_objects[name.to_sym][:key]
+        if key && key.respond_to?(:call)
+          key = key.call self
+        end
+        if id.nil? and !klass.redis_objects[name.to_sym][:global]
+          raise NilObjectId,
+            "[#{klass.redis_objects[name.to_sym]}] Attempt to address redis-object :#{name} on class #{klass.name} with nil id (unsaved record?) [object_id=#{object_id}]"
+        end
+        key || "#{redis_prefix(klass)}:#{id}:#{name}"
       end
 
       def first_ancestor_with(name)
@@ -107,8 +119,16 @@ class Redis
       def redis_field_key(name) #:nodoc:
         klass = self.class.first_ancestor_with(name)
         if key = klass.redis_objects[name.to_sym][:key]
-          eval "%(#{key})"
+          if key.respond_to?(:call)
+            key.call self
+          else
+            eval "%(#{key})"
+          end
         else
+          if id.nil? and !klass.redis_objects[name.to_sym][:global]
+            raise NilObjectId,
+              "Attempt to address redis-object :#{name} on class #{klass.name} with nil id (unsaved record?) [object_id=#{object_id}]"
+          end
           # don't try to refactor into class redis_field_key because fucks up eval context
           "#{klass.redis_prefix}:#{id}:#{name}"
         end

data/lib/redis/sorted_set.rb

@@ -280,6 +280,11 @@ class Redis
       redis.zcard(key)
     end
     alias_method :size, :length
+    
+    # The number of members within a range of scores. Redis: ZCOUNT
+    def range_size(min, max)
+      redis.zcount(key, min, max)
+    end
 
     private
 

data/redis-objects.gemspec

@@ -1,66 +1,58 @@
 # Generated by jeweler
 # DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{redis-objects}
-  s.version = "0.5.0"
+  s.version = "0.5.1"
 
   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.date = %q{2011-05-23}
   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"
+    "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_active_record_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.rubygems_version = %q{1.7.2}
   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

data/spec/redis_namespace_compat_spec.rb

@@ -4,15 +4,21 @@ require 'redis/objects'
 Redis::Objects.redis = $redis
 
 $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../../redis-namespace/lib')
-require 'redis/namespace'
+begin
+  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
+  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
-    ns.instance_eval { rem_namespace({"resque:x" => nil}) }.should == {"x"=>nil}
   end
+
+rescue LoadError
+  # Redis::Namespace not installed
+  puts "Skipping Redis::Namespace tests as redis-namespace is not installed"
 end

data/spec/redis_objects_active_record_spec.rb

@@ -0,0 +1,105 @@
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'redis/objects'
+Redis::Objects.redis = $redis
+
+begin
+  require 'active_record'
+  ActiveRecord::Base.establish_connection(
+    :adapter => 'sqlite3',
+    :database => File.expand_path(File.dirname(__FILE__) + '/redis_objects_test.sqlite3')
+  )
+
+  class CreateBlogs < ActiveRecord::Migration
+    def self.up
+      create_table :blogs do |t|
+        t.string :name
+        t.integer :posts_count, :default => 0
+        t.timestamps
+      end
+    end
+
+    def self.down
+      drop_table :blogs
+    end
+  end
+
+  class Blog < ActiveRecord::Base
+    include Redis::Objects
+    has_many :posts
+  end
+
+  class CreatePosts < ActiveRecord::Migration
+    def self.up
+      create_table :posts do |t|
+        t.string :title
+        t.string :description, :length => 200
+        t.integer :total
+        t.integer :blog_id
+        t.timestamps
+      end
+    end
+
+    def self.down
+      drop_table :posts
+    end
+  end
+
+  class Post < ActiveRecord::Base
+    include Redis::Objects
+    counter :total
+    belongs_to :blog, :counter_cache => true
+  end
+
+
+  describe Redis::Objects do
+    before do
+      CreatePosts.up
+      CreateBlogs.up
+    end
+    after do
+      CreatePosts.down
+      CreateBlogs.down
+    end
+
+    it "exercises ActiveRecord in more detail" do
+      @ar = Post.new
+      @ar.save!
+      @ar.destroy
+
+      # @ar.total.reset
+      @ar2 = Post.new
+      @ar2.save!
+      @ar2.total.reset
+      @ar2.total.increment.should == 1
+      @ar2.id.should == 2
+      @ar2.increment(:total).should == 2
+      @ar2[:total].should == nil  # DB column
+      @ar2.redis.get(@ar2.redis_field_key('total')).to_i.should == 2
+      @ar2[:total] = 3  # DB column
+      @ar2.total.decrement.should == 1
+      @ar2.total.reset
+      @ar2.total.should == 0
+      @ar2.destroy
+    end
+
+    it "falls back to ActiveRecord if redis counter is not defined" do
+      blog = Blog.create
+      blog.reload.posts_count.should == 0
+      post = Post.create :blog => blog
+      blog.reload.posts_count.should == 1
+      blog2 = Blog.create
+      Post.create :blog => blog2
+      Post.create :blog => blog2
+      blog.reload.posts_count.should == 1
+      blog2.reload.posts_count.should == 2
+      blog.posts_count.should == 1
+    end
+  end
+
+
+rescue LoadError
+  # ActiveRecord not install
+  puts "Skipping ActiveRecord tests as active_record is not installed"
+end

data/spec/redis_objects_instance_spec.rb

@@ -360,6 +360,39 @@ end
 
 
 describe Redis::HashKey do
+  describe "With Marshal" do
+    before do
+      @hash = Redis::HashKey.new('test_hash', $redis,
+                                {:marshal_keys=>{'created_at'=>true}})
+      @hash.clear
+    end
+
+    it "should marshal specified keys" do
+      @hash['created_at'] = Time.now
+      @hash['created_at'].class.should == Time
+    end
+
+    it "should not marshal unless required" do
+      @hash['updated_at'] = Time.now
+      @hash['updated_at'].class.should == String
+    end
+
+    it "should marshall appropriate key with bulk set and get" do
+      @hash.bulk_set({'created_at'=>Time.now, 'updated_at'=>Time.now})
+
+      @hash['created_at'].class.should == Time
+      @hash['updated_at'].class.should == String
+
+      h = @hash.bulk_get('created_at', 'updated_at')
+      h['created_at'].class.should == Time
+      h['updated_at'].class.should == String
+
+      h = @hash.all
+      h['created_at'].class.should == Time
+      h['updated_at'].class.should == String
+    end
+  end
+
   before do
     @hash  = Redis::HashKey.new('test_hash')
     @hash.clear
@@ -601,11 +634,40 @@ describe Redis::Set do
     @set.redis.del('spec/set2')
   end
 
+  it "should support sorting" do
+    @set_1 << 'a' << 'b' << 'c' << 'd' << 'e'
+    @set_2 << 1 << 2 << 3 << 4 << 5
+    @set_3 << 'm_1' << 'm_2'
+    @set_1.sort.should == %w(a b c d e)
+    @set_2.sort.should == %w(1 2 3 4 5)
+
+    @set_1.sort(SORT_ORDER).should == %w(e d c b a)
+    @set_3.sort(SORT_BY).should == %w(m_1 m_2)        
+    @set_2.sort(SORT_LIMIT).should == %w(3 4)
+
+    val1 = Redis::Value.new('spec/3/sorted')
+    val2 = Redis::Value.new('spec/4/sorted')
+
+    val1.set('val3')
+    val2.set('val4')
+ 
+    @set_2.sort(SORT_GET).should == ['val3', 'val4']
+    @set_2.sort(SORT_STORE).should == 2
+    @set_2.redis.type(SORT_STORE[:store]).should == 'list'
+    @set_2.redis.lrange(SORT_STORE[:store], 0, -1).should == ['val3', 'val4']
+
+    @set_1.redis.del val1.key
+    @set_1.redis.del val2.key
+    @set_1.redis.del SORT_STORE[:store]
+
+  end
+
   after do
     @set.clear
     @set_1.clear
     @set_2.clear
     @set_3.clear
+
   end
 end
 
@@ -698,6 +760,10 @@ describe Redis::SortedSet do
     @set.length.should == 4
     @set.size.should == 4
     
+    @set.range_size(100, 120).should == 0
+    @set.range_size(0, 100).should == 2
+    @set.range_size('-inf', 'inf').should == 4
+    
     @set.delete_if{|m| m == 'b'}
     @set.size.should == 3
   end

data/spec/redis_objects_model_spec.rb

@@ -9,7 +9,7 @@ class Roster
   counter :available_slots, :start => 10
   counter :pitchers, :limit => :max_pitchers
   counter :basic
-  hash_key :contact_information
+  hash_key :contact_information, :marshal_keys=>{'updated_at'=>true}
   lock :resort, :timeout => 2
   value :starting_pitcher, :marshal => true
   list :player_stats, :marshal => true
@@ -18,17 +18,19 @@ class Roster
 
   # 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
   
   # custom keys
   counter :player_totals, :key => 'players/#{username}/total'
-  list :all_player_stats, :key => 'players:all_stats'
+  list :all_player_stats, :key => 'players:all_stats', :global => true
   set :total_wins, :key => 'players:#{id}:all_stats'
   value :my_rank, :key => 'players:my_rank:#{username}'
   value :weird_key, :key => 'players:weird_key:#{raise}', :global => true
 
+  #callable as key
+  counter :daily, :global => true, :key => Proc.new { |roster| "#{roster.name}:#{Time.now.strftime('%Y-%m-%dT%H')}:daily" }
+
   def initialize(id=1) @id = id end
   def id; @id; end
   def username; "user#{id}"; end
@@ -100,6 +102,8 @@ describe Redis::Objects do
     @roster.total_wins.clear
     @roster.my_rank.clear
 
+    @roster.daily.clear
+
     @custom_roster.basic.reset
     @custom_roster.special.reset
   end
@@ -108,7 +112,7 @@ describe Redis::Objects do
     Roster.redis.should == Redis::Objects.redis
     # Roster.redis.should.be.kind_of(Redis)
   end
-  
+
   it "should support interpolation of key names" do
     @roster.player_totals.incr
     @roster.redis.get('players/user1/total').should == '1'
@@ -123,6 +127,10 @@ describe Redis::Objects do
     @roster.redis.get('players:my_rank:user1').should == 'a'
     Roster.weird_key = 'tuka'
     Roster.redis.get('players:weird_key:#{raise}').should == 'tuka'
+
+    k = "Roster:#{Time.now.strftime('%Y-%m-%dT%H')}:daily"
+    @roster.daily.incr
+    @roster.redis.get(k).should == '1'
   end
 
   it "should be able to get/set contact info" do
@@ -134,6 +142,10 @@ describe Redis::Objects do
     @roster.contact_information.size.should == 2
   end
 
+  it "should be marshalling hash keys" do
+    @roster.contact_information['updated_at'] = Time.now
+    @roster.contact_information['updated_at'].class.should == Time
+  end
 
 
   it "should create counter accessors" do
@@ -327,7 +339,7 @@ describe Redis::Objects do
       Roster.increment_counter(:badness, 2)
     rescue => error
     end
-    error.should.be.kind_of(Redis::Objects::UndefinedCounter)
+    error.should.be.kind_of(NoMethodError)
 
     error = nil
     begin
@@ -758,6 +770,7 @@ describe Redis::Objects do
     @custom_roster.basic.increment.should == 1
     @roster2.basic.should == 0
     CustomRoster.new.basic.should == 1
+    @custom_roster.basic.decrement.should == 0
   end
 
   it "should handle new subclass objects" do
@@ -767,10 +780,15 @@ describe Redis::Objects do
   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.increment.should == 2
+    @custom_method_roster.decrement(:basic).should == 1
+    @custom_method_roster.basic.decrement.should == 0
+    @custom_method_roster.basic.reset.should.be.true
+    @custom_method_roster.basic.should == 0
     @custom_method_roster.basic.should.be.kind_of(Redis::Counter)
   end
 end

data/spec/spec_helper.rb

@@ -12,3 +12,11 @@ UNIONSTORE_KEY = 'test:unionstore'
 INTERSTORE_KEY = 'test:interstore'
 DIFFSTORE_KEY  = 'test:diffstore'
 
+
+SORT_ORDER = {:order => 'desc alpha'}
+SORT_LIMIT = {:limit => [2, 2]}
+SORT_BY = {:by => 'm_*'}
+SORT_GET = {:get => 'spec/*/sorted'}.merge!(SORT_LIMIT)
+SORT_STORE = {:store => "spec/aftersort"}.merge!(SORT_GET)
+
+

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: redis-objects
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 5
-  - 0
-  version: 0.5.0
+  prerelease: 
+  version: 0.5.1
 platform: ruby
 authors: 
 - Nate Wiger
@@ -14,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-08 00:00:00 -08:00
-default_executable: 
+date: 2011-05-23 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: bacon
@@ -25,8 +20,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
   version_requirements: *id001
@@ -38,10 +31,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 1
-        - 1
         version: 2.1.1
   type: :runtime
   version_requirements: *id002
@@ -54,7 +43,6 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 files: 
-- .gitignore
 - ATOMICITY.rdoc
 - CHANGELOG.rdoc
 - README.rdoc
@@ -80,16 +68,16 @@ files:
 - lib/redis/value.rb
 - redis-objects.gemspec
 - spec/redis_namespace_compat_spec.rb
+- spec/redis_objects_active_record_spec.rb
 - spec/redis_objects_instance_spec.rb
 - spec/redis_objects_model_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: http://github.com/nateware/redis-objects
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -97,26 +85,19 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: 
 - redis, v2.1.1 or greater
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 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
+test_files: []
+

data/.gitignore

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