redis-objects 0.3.2 → 0.4.0

data/CHANGELOG.rdoc

@@ -1,8 +1,30 @@
 = Changelog for Redis::Objects
 
+== 0.4.0 [Final] (11 August 2010)
+
+* Full support for redis hashes via new Redis::Hash class [Julio Capote, Nate Wiger]
+
+* Now dependent on redis-rb client 2.0.4 or later.  Should still be backwards compatible with redis-server 1.x
+
+* Fixes to sets and sorted sets to bring them up to speed with redis-rb 2.0 from tomstuart [Tom Stuart]
+
+* Incompatible change: Update list[x,y] and sorted_set[x,y] to work consistently with Ruby in all cases [Tom Stuart]
+
+* Refactoring to make constructors common across all object types from dbalatero [David Balatero]
+
+* Renamed :withscores option to :with_scores for consistency with redis-rb 2.0, but kept backwards compat [Tom Stuart, Nate Wiger]
+
+== 0.3.2 [Final] (21 July 2010)
+
+* New "maxlength" option to Redis::List can create length-limited lists (eg, like a ring buffer) from dbalatero [David Balatero]
+
+* Fix score conversions in Redis::SortedSet (scores are floats, not ints) from tomstuart [Tom Stuart]
+
+* Switched from rspec to bacon for tests
+
 == 0.3.1 [Final] (1 June 2010)
 
-* Integrated fixes for sorted_set deletions from capotej (Julio Capote)
+* Integrated fixes for sorted_set deletions from capotej [Julio Capote]
 
 == 0.3.0 [Final] (14 April 2010)
 

data/README.rdoc

@@ -65,6 +65,8 @@ You can include Redis::Objects in any type of class:
       list :on_base
       set :outfielders
       value :at_bat
+      sorted_set :rank, :global => true
+      hash_key :pitchers_faced  # "hash" is taken by Ruby
     end
 
 Familiar Ruby array operations Just Work (TM):
@@ -211,7 +213,31 @@ Complex data types are no problem with :marshal => true:
     @list.each do |el|
       puts "#{el[:name]} lives in #{el[:city]}"
     end
-    
+
+=== Hashes
+
+Hashes work like a Ruby {Hash}[http://ruby-doc.org/core/classes/Hash.html], with
+a few Redis-specific additions.
+
+    require 'redis/hash'
+    @hash = Redis::Hash.new('hash_name')
+    @hash['a'] = 1
+    @hash['b'] = 2
+    @hash.each do |k,v|
+      puts "#{k} = #{v}"
+    end
+    @hash['c'] = 3
+    puts @hash.all  # {"a"=>"1","b"=>"2","c"=>"3"}
+    @hash.clear
+
+Redis also adds incrementing and bulk operations:
+
+    @hash.incr('c', 6)  # 9
+    @hash.bulk_set('d' => 5, 'e' => 6)
+    @hash.bulk_get('d','e')  # "5", "6"
+
+Remember that numbers become strings in Redis.  Unlike with other Redis data types, redis-objects can't guess at your data type in this situation.
+
 === Sets
 
 Sets work like the Ruby {Set}[http://ruby-doc.org/core/classes/Set.html] class:
@@ -221,8 +247,9 @@ Sets work like the Ruby {Set}[http://ruby-doc.org/core/classes/Set.html] class:
     @set << 'a'
     @set << 'b'
     @set << 'a'  # dup ignored
-    @set.member? 'c'   # false
-    @set.members  # ['a','b']
+    @set.member? 'c'      # false
+    @set.members          # ['a','b']
+    @set.members.reverse  # ['b','a']
     @set.each do |member|
       puts member
     end
@@ -293,9 +320,10 @@ a Hash and an Array.  You assign like a Hash, but retrieve like an Array:
 
     @sorted_set['Newbie'] = 1
     @sorted_set.members         # => ["Newbie", "Nate", "Jeff", "Peter"]
+    @sorted_set.members.reverse # => ["Peter", "Jeff", "Nate", "Newbie"]
 
     @sorted_set.rangebyscore(10, 100, :limit => 2)   # => ["Nate", "Jeff"]
-    @sorted_set.members(:withscores => true)         # => [["Newbie", 1], ["Nate", 16], ["Jeff", 28], ["Peter", 76]]
+    @sorted_set.members(:with_scores => true)        # => [["Newbie", 1], ["Nate", 16], ["Jeff", 28], ["Peter", 76]]
 
     # atomic increment
     @sorted_set.increment('Nate')

data/lib/redis/base_object.rb

@@ -0,0 +1,10 @@
+class Redis
+  # Defines base functionality for all redis-objects.
+  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
+      @redis   = args.first || $redis
+    end
+  end
+end

data/lib/redis/counter.rb

@@ -1,3 +1,5 @@
+require File.dirname(__FILE__) + '/base_object'
+
 class Redis
   #
   # Class representing a Redis counter.  This functions like a proxy class, in
@@ -6,15 +8,13 @@ class Redis
   # directly, or you can use the counter :foo class method in your
   # class to define a counter.
   #
-  class Counter
+  class Counter < BaseObject
     require 'redis/helpers/core_commands'
     include Redis::Helpers::CoreCommands
 
     attr_reader :key, :options, :redis
     def initialize(key, *args)
-      @key = key
-      @options = args.last.is_a?(Hash) ? args.pop : {}
-      @redis = args.first || $redis
+      super(key, *args)
       @options[:start] ||= 0
       @redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
     end

data/lib/redis/hash.rb

@@ -0,0 +1,126 @@
+class Redis
+  #
+  # Class representing a Redis hash.
+  #
+  class Hash < BaseObject
+    require 'enumerator'
+    include Enumerable
+    require 'redis/helpers/core_commands'
+    include Redis::Helpers::CoreCommands
+    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
+
+    # Sets a field to value
+    def []=(field, value)
+      store(field, value)
+    end
+
+    # Gets the value of a field
+    def [](field)
+      fetch(field)
+    end
+
+    # Redis: HSET
+    def store(field, value)
+      redis.hset(key, field, value)
+    end
+
+    # Redis: HGET
+    def fetch(field)
+      redis.hget(key, field)
+    end
+
+    # Verify that a field exists. Redis: HEXISTS
+    def has_key?(field)
+      redis.hexists(key, field)
+    end
+    alias_method :include?, :has_key?
+    alias_method :key?, :has_key?
+    alias_method :member?, :has_key?
+
+    # Delete field. Redis: HDEL
+    def delete(field)
+      redis.hdel(key, field)
+    end
+
+    # Return all the keys of the hash. Redis: HKEYS
+    def keys
+      redis.hkeys(key)
+    end
+
+    # Return all the values of the hash. Redis: HVALS
+    def values
+      redis.hvals(key)
+    end
+    alias_method :vals, :values
+
+    # Retrieve the entire hash.  Redis: HGETALL
+    def all
+      redis.hgetall(key)
+    end
+    alias_method :clone, :all
+
+    # Enumerate through all fields. Redis: HGETALL
+    def each(&block)
+      all.each(&block)
+    end
+    
+    # Enumerate through each keys. Redis: HKEYS
+    def each_key(&block)
+      keys.each(&block)
+    end
+
+    # Enumerate through all values. Redis: HVALS
+    def each_value(&block)
+      values.each(&block)
+    end
+
+    # Return the size of the dict. Redis: HLEN
+    def size
+      redis.hlen(key)
+    end
+    alias_method :length, :size
+    alias_method :count, :size
+
+    # Returns true if dict is empty
+    def empty?
+      true if size == 0
+    end
+
+    # Clears the dict of all keys/values. Redis: DEL
+    def clear
+      redis.del(key)
+    end
+
+    # 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)
+    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
+      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 
+
+  end
+end
+

data/lib/redis/list.rb

@@ -1,9 +1,11 @@
+require File.dirname(__FILE__) + '/base_object'
+
 class Redis
   #
-  # Class representing a Redis list.  Instances of Redis::List are designed to 
+  # Class representing a Redis list.  Instances of Redis::List are designed to
   # behave as much like Ruby arrays as possible.
   #
-  class List
+  class List < BaseObject
     require 'enumerator'
     include Enumerable
     require 'redis/helpers/core_commands'
@@ -12,11 +14,6 @@ class Redis
     include Redis::Helpers::Serialize
 
     attr_reader :key, :options, :redis
-    def initialize(key, *args)
-      @key = key
-      @options = args.last.is_a?(Hash) ? args.pop : {}
-      @redis = args.first || $redis
-    end
 
     # Works like push.  Can chain together: list << 'a' << 'b'
     def <<(value)
@@ -48,7 +45,8 @@ class Redis
 
     # Return all values in the list. Redis: LRANGE(0,-1)
     def values
-      from_redis range(0, -1)
+      v = from_redis range(0, -1)
+      v.nil? ? [] : v
     end
     alias_method :get, :values
 
@@ -59,11 +57,16 @@ class Redis
       if index.is_a? Range
         range(index.first, index.last)
       elsif length
-        range(index, length)
+        case length <=> 0
+        when 1  then range(index, index + length - 1)
+        when 0  then []
+        when -1 then nil  # Ruby does this (a bit weird)
+        end
       else
         at(index)
       end
     end
+    alias_method :slice, :[]
 
     # Delete the element(s) from the list that match name. If count is specified,
     # only the first-N (if positive) or last-N (if negative) will be removed.

data/lib/redis/lock.rb

@@ -1,3 +1,5 @@
+require File.dirname(__FILE__) + '/base_object'
+
 class Redis
   #
   # Class representing a lock.  This functions like a proxy class, in
@@ -6,14 +8,12 @@ class Redis
   # directly, but it is better to use the lock :foo class method in your
   # class to define a lock.
   #
-  class Lock
+  class Lock < BaseObject
     class LockTimeout < StandardError; end #:nodoc:
 
     attr_reader :key, :options, :redis
     def initialize(key, *args)
-      @key = key
-      @options = args.last.is_a?(Hash) ? args.pop : {}
-      @redis = args.first || $redis
+      super(key, *args)
       @options[:timeout] ||= 5
       @options[:init] = false if @options[:init].nil? # default :init to false
       @redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
@@ -81,4 +81,4 @@ class Redis
       @options[:expiration].nil? ? 1 : (Time.now + @options[:expiration].to_f + 1).to_f
     end
   end
-end
+end

data/lib/redis/objects/hashes.rb

@@ -0,0 +1,46 @@
+# This is the class loader, for use as "include Redis::Objects::Hashes"
+# For the object itself, see "Redis::Hash"
+require 'redis/hash'
+class Redis
+  module Objects
+    module Hashes
+      def self.included(klass)
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+
+      # Class methods that appear in your class when you include Redis::Objects.
+      module ClassMethods
+        # Define a new hash key.  It will function like a regular instance
+        # method, so it can be used alongside ActiveRecord, DataMapper, etc.
+        def hash_key(name, options={})
+          @redis_objects[name.to_sym] = options.merge(:type => :dict)
+          if options[:global]
+            instance_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::Hash.new(field_key(:#{name}), redis, @redis_objects[:#{name}])
+              end
+            EndMethods
+            class_eval <<-EndMethods
+              def #{name}
+                self.class.#{name}
+              end
+            EndMethods
+          else
+            class_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::Hash.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+              end
+            EndMethods
+          end
+        end
+      end
+
+      # Instance methods that appear in your class when you include Redis::Objects.
+      module InstanceMethods
+      end
+    end
+  end
+end
+
+

data/lib/redis/objects.rb

@@ -44,6 +44,7 @@ class Redis
     autoload :Sets, File.join(dir, 'sets')
     autoload :SortedSets, File.join(dir, 'sorted_sets')
     autoload :Values, File.join(dir, 'values')
+    autoload :Hashes, File.join(dir, 'hashes')
 
     class NotConnected  < StandardError; end
 
@@ -67,6 +68,7 @@ class Redis
         klass.send :include, Redis::Objects::Sets
         klass.send :include, Redis::Objects::SortedSets
         klass.send :include, Redis::Objects::Values
+        klass.send :include, Redis::Objects::Hashes
       end
     end
 

data/lib/redis/set.rb

@@ -1,8 +1,10 @@
+require File.dirname(__FILE__) + '/base_object'
+
 class Redis
   #
   # Class representing a set.
   #
-  class Set
+  class Set < BaseObject
     require 'enumerator'
     include Enumerable
     require 'redis/helpers/core_commands'
@@ -11,20 +13,13 @@ class Redis
     include Redis::Helpers::Serialize
 
     attr_reader :key, :options, :redis
-    
-    # Create a new Set.
-    def initialize(key, *args)
-      @key = key
-      @options = args.last.is_a?(Hash) ? args.pop : {}
-      @redis = args.first || $redis
-    end
 
     # Works like add.  Can chain together: list << 'a' << 'b'
     def <<(value)
       add(value)
       self  # for << 'a' << 'b'
     end
-    
+
     # Add the specified value to the set only if it does not exist already.
     # Redis: SADD
     def add(value)
@@ -33,7 +28,8 @@ class Redis
 
     # Return all members in the set.  Redis: SMEMBERS
     def members
-      from_redis redis.smembers(key)
+      v = from_redis redis.smembers(key)
+      v.nil? ? [] : v
     end
     alias_method :get, :members
 
@@ -156,7 +152,7 @@ class Redis
     def to_s
       members.join(', ')
     end
-    
+
     private
     
     def keys_from_objects(sets)

data/lib/redis/sorted_set.rb

@@ -1,8 +1,10 @@
+require File.dirname(__FILE__) + '/base_object'
+
 class Redis
   #
   # Class representing a sorted set.
   #
-  class SortedSet
+  class SortedSet < BaseObject
     # require 'enumerator'
     # include Enumerable
     require 'redis/helpers/core_commands'
@@ -11,13 +13,6 @@ class Redis
     include Redis::Helpers::Serialize
 
     attr_reader :key, :options, :redis
-    
-    # Create a new SortedSet.
-    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
-    end
 
     # How to add values using a sorted set.  The key is the member, eg,
     # "Peter", and the value is the score, eg, 163.  So:
@@ -40,11 +35,16 @@ class Redis
       if index.is_a? Range
         range(index.first, index.last)
       elsif length
-        range(index, length)
+        case length <=> 0
+        when 1  then range(index, index + length - 1)
+        when 0  then []
+        when -1 then nil  # Ruby does this (a bit weird)
+        end
       else
         score(index)
       end
     end
+    alias_method :slice, :[]
 
     # Return the score of the specified element of the sorted set at key. If the
     # specified element does not exist in the sorted set, or the key does not exist
@@ -68,14 +68,15 @@ class Redis
     # Return all members of the sorted set with their scores.  Extremely CPU-intensive.
     # Better to use a range instead.
     def members(options={})
-      range(0, -1, options)
+      v = from_redis range(0, -1, options)
+      v.nil? ? [] : v
     end
 
     # Return a range of values from +start_index+ to +end_index+.  Can also use
     # the familiar list[start,end] Ruby syntax. Redis: ZRANGE
     def range(start_index, end_index, options={})
-      if options[:withscores]
-        val = from_redis redis.zrange(key, start_index, end_index, 'withscores')
+      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]
@@ -88,8 +89,8 @@ class Redis
 
     # Return a range of values from +start_index+ to +end_index+ in reverse order. Redis: ZREVRANGE
     def revrange(start_index, end_index, options={})
-      if options[:withscores]
-        val = from_redis redis.zrevrange(key, start_index, end_index, 'withscores')
+      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]
@@ -106,20 +107,20 @@ class Redis
     #     :withscores     - if true, scores are returned as well
     # Redis: ZRANGEBYSCORE
     def rangebyscore(min, max, options={})
-      args = []
-      args += ['limit', options[:offset] || 0, options[:limit] || options[:count]] if
+      args = {}
+      args[:limit] = [options[:offset] || 0, options[:limit] || options[:count]] if
                 options[:offset] || options[:limit] || options[:count]
-      args += ['withscores'] if options[:withscores]
-      from_redis redis.zrangebyscore(key, min, max, *args)
+      args[:with_scores] = true if options[:withscores] || options[:with_scores]
+      from_redis redis.zrangebyscore(key, min, max, args)
     end
 
     # Forwards compat (not yet implemented in Redis)
     def revrangebyscore(min, max, options={})
-      args = []
-      args += ['limit', options[:offset] || 0, options[:limit] || options[:count]] if
+      args = {}
+      args[:limit] = [options[:offset] || 0, options[:limit] || options[:count]] if
                 options[:offset] || options[:limit] || options[:count]
-      args += ['withscores'] if options[:withscores]
-      from_redis redis.zrevrangebyscore(key, min, max, *args)
+      args[:with_scores] = true if options[:withscores] || options[:with_scores]
+      from_redis redis.zrevrangebyscore(key, min, max, args)
     end
 
     # Remove all elements in the sorted set at key with rank between start and end. Start and end are
@@ -139,7 +140,19 @@ class Redis
 
     # Delete the value from the set.  Redis: ZREM
     def delete(value)
-      redis.zrem(key, value)
+      redis.zrem(key, to_redis(value))
+    end
+
+    # Delete element if it matches 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|
+        if block.call(from_redis(m))
+          res = redis.zrem(key, m)
+        end
+      end
+      res
     end
 
     # Increment the rank of that member atomically and return the new value. This
@@ -272,4 +285,4 @@ class Redis
     end
     
   end
-end
+end

data/lib/redis/value.rb

@@ -1,8 +1,10 @@
+require File.dirname(__FILE__) + '/base_object'
+
 class Redis
   #
   # Class representing a simple value.  You can use standard Ruby operations on it.
   #
-  class Value
+  class Value < BaseObject
     require 'redis/helpers/core_commands'
     include Redis::Helpers::CoreCommands
     require 'redis/helpers/serialize'
@@ -10,9 +12,7 @@ class Redis
 
     attr_reader :key, :options, :redis
     def initialize(key, *args)
-      @key = key
-      @options = args.last.is_a?(Hash) ? args.pop : {}
-      @redis = args.first || $redis
+      super(key, *args)
       @redis.setnx(key, @options[:default]) if @options[:default]
     end
 
@@ -32,4 +32,4 @@ class Redis
     def ==(x); value == x; end
     def nil?;  value.nil?; end
   end
-end
+end

data/spec/redis_objects_instance_spec.rb

@@ -7,6 +7,7 @@ require 'redis/value'
 require 'redis/lock'
 require 'redis/set'
 require 'redis/sorted_set'
+require 'redis/hash'
 
 describe Redis::Value do
   before do
@@ -143,13 +144,22 @@ describe Redis::List do
       @list.get.should == ['a','c','f']
       @list << 'j'
       @list.should == ['a','c','f','j']
-      @list[0..2].should == ['a','c','f']
-      @list[0, 2].should == ['a','c','f']  # consistent with Redis, not Ruby
-      @list[1, 3].should == ['c','f','j']
+      # Test against similar Ruby functionality
+      a = @list.values
+      @list[0..2].should == a[0..2]
+      @list.slice(0..2).should == a.slice(0..2)
+      @list[0, 2].should == a[0, 2]
+      @list.range(0, 2).should == a[0..2]  # range for Redis works like .. in Ruby
+      @list[0, 1].should == a[0, 1]
+      @list.range(0, 1).should == a[0..1]  # range for Redis works like .. in Ruby
+      @list[1, 3].should == a[1, 3]
+      @list.slice(1, 3).should == a.slice(1, 3)
+      @list[0, 0].should == []
+      @list[0, -1].should == a[0, -1]
       @list.length.should == 4
       @list.size.should == 4
-      @list.should == ['a','c','f','j']
-      @list.get.should == ['a','c','f','j']
+      @list.should == a
+      @list.get.should == a
 
       i = -1
       @list.each do |st|
@@ -345,6 +355,102 @@ describe Redis::Lock do
   end
 end
 
+
+describe Redis::Hash do
+  before do
+    @hash  = Redis::Hash.new('test_hash')
+    @hash.clear
+  end
+  
+  it "should get and set values" do
+    @hash['foo'] = 'bar'
+    @hash['foo'].should == 'bar'
+  end
+
+  it "should know what exists" do
+    @hash['foo'] = 'bar'
+    @hash.include?('foo').should == true
+  end
+
+  it "should delete values" do
+    @hash['abc'] = 'xyz'
+    @hash.delete('abc')
+    @hash['abc'].should == nil
+  end
+
+  it "should respond to each" do
+    @hash['foo'] = 'bar'
+    @hash.each do |key, val|
+      key.should == 'foo'
+      val.should == 'bar'
+    end
+  end
+  
+  it "should have 1 item" do
+    @hash['foo'] = 'bar'
+    @hash.size.should == 1
+  end
+
+  it "should respond to each_key" do
+    @hash['foo'] = 'bar'
+    @hash.each_key do |key|
+      key.should == 'foo'
+    end
+  end
+
+  it "should respond to each_value" do
+    @hash['foo'] = 'bar'
+    @hash.each_value do |val|
+      val.should == 'bar'
+    end
+  end
+
+  it "should respond to empty?" do
+    @empty = Redis::Hash.new('test_empty_hash')
+    @empty.respond_to?(:empty?).should == true
+  end
+
+  it "should be empty after a clear" do
+    @hash['foo'] = 'bar'
+    @hash.all.should == {'foo' => 'bar'}
+    @hash.clear
+    @hash.should.be.empty
+  end
+  
+  it "should respond to bulk_set" do
+    @hash.bulk_set({'abc' => 'xyz', 'bizz' => 'bazz'})
+    @hash['abc'].should == 'xyz'
+    @hash['bizz'].should == 'bazz'
+
+    @hash.bulk_set('abc' => '123', 'bang' => 'michael')
+    @hash['abc'].should == '123'
+    @hash['bang'].should == 'michael'
+
+    @hash.bulk_set(:sym1 => 'val1', :sym2 => 'val2')
+    @hash['sym1'].should == 'val1'
+    @hash['sym2'].should == 'val2'
+  end
+
+  it "should respond to bulk_get" do
+    @hash['foo'] = 'bar'
+    hsh = @hash.bulk_get('abc','foo')
+    hsh['abc'].should == nil
+    hsh['foo'].should == 'bar'
+  end
+
+  it "should increment field" do
+    @hash.incr('counter')
+    @hash.incr('counter')
+    @hash['counter'].to_i.should == 2
+  end
+  
+
+  after do
+    @hash.clear
+  end
+  
+end
+
 describe Redis::Set do
   before do
     @set = Redis::Set.new('spec/set')
@@ -366,6 +472,7 @@ describe Redis::Set do
     @set.to_s.should == 'a, b'
     @set.should == ['a','b']
     @set.members.should == ['a','b']
+    @set.members.reverse.should == ['b','a']  # common question
     @set.get.should == ['a','b']
     @set << 'c'
     @set.sort.should == ['a','b','c']
@@ -483,20 +590,28 @@ describe Redis::SortedSet do
     @set['b'].should == 5.6
     @set['c'] = 4
 
-    @set[0,-1].should == ['a','c','b']
-    @set[0..2].should == ['a','c','b']
-    @set[0,2].should == ['a','c','b']   # consistent with Redis, not Ruby
+    a = @set.members
+    @set[0,-1].should == a[0,-1]
+    @set[0..2].should == a[0..2]
+    @set.slice(0..2).should == a.slice(0..2)
+    @set[0, 2].should == a[0,2]
+    @set.slice(0, 2).should == a.slice(0, 2)
+    @set.range(0, 2).should == a[0..2]
+    @set[0, 0].should == []
     @set.range(0,1,:withscores => true).should == [['a',3],['c',4]]
-    @set.range(0,-1).should == ['a','c','b']
-    @set.revrange(0,-1).should == ['b','c','a']
-    @set[0..1].should == ['a','c']
+    @set.range(0,-1).should == a[0..-1]
+    @set.revrange(0,-1).should == a[0..-1].reverse
+    @set[0..1].should == a[0..1]
     @set[1].should == 0  # missing
     @set.at(1).should == 'c'
     @set.first.should == 'a'
     @set.last.should == 'b'
 
     @set.members.should == ['a','c','b']
+    @set.members.reverse.should == ['b','c','a']
     @set.members(:withscores => true).should == [['a',3],['c',4],['b',5.6]]
+    @set.members(:with_scores => true).should == [['a',3],['c',4],['b',5.6]]
+    @set.members(:withscores => true).reverse.should == [['b',5.6],['c',4],['a',3]]
 
     @set['b'] = 5
     @set['b'] = 6

data/spec/redis_objects_model_spec.rb

@@ -9,10 +9,12 @@ class Roster
   counter :available_slots, :start => 10
   counter :pitchers, :limit => :max_pitchers
   counter :basic
+  hash_key :contact_information
   lock :resort, :timeout => 2
   value :starting_pitcher, :marshal => true
   list :player_stats, :marshal => true
   set :outfielders, :marshal => true
+  sorted_set :rank
 
   # global class counters
   counter :total_players_online, :global => true
@@ -49,6 +51,7 @@ describe Redis::Objects do
     @roster.starting_pitcher.delete
     @roster.player_stats.clear
     @roster.outfielders.clear
+    @roster.contact_information.clear
     @roster_1.outfielders.clear
     @roster_2.outfielders.clear
     @roster_3.outfielders.clear
@@ -73,21 +76,33 @@ describe Redis::Objects do
     # Roster.redis.should.be.kind_of(Redis)
   end
   
-  it "should support custom key names" do
+  it "should support interpolation of key names" do
     @roster.player_totals.incr
     @roster.redis.get('players/user1/total').should == '1'
     @roster.redis.get('players/#{username}/total').should.be.nil
     @roster.all_player_stats << 'a'
     @roster.redis.lindex('players:all_stats', 0).should == 'a'
     @roster.total_wins << 'a'
-    @roster.redis.smembers('players:1:all_stats').should == ['a']
+    # test for interpolation of key names
     @roster.redis.smembers('players:#{id}:all_stats').should == []
+    @roster.redis.smembers('players:1:all_stats').should == ['a']
     @roster.my_rank = 'a'
     @roster.redis.get('players:my_rank:user1').should == 'a'
     Roster.weird_key = 'tuka'
     Roster.redis.get('players:weird_key:#{raise}').should == 'tuka'
   end
 
+  it "should be able to get/set contact info" do
+    @roster.contact_information['John_Phone'] = '123415352'
+    @roster.contact_information['John_Address'] = '123 LANE'
+    @roster.contact_information['John_Phone'].should == '123415352'
+    @roster.contact_information['John_Address'].should == '123 LANE'
+    @roster.contact_information['asdasd'].should.be.nil
+    @roster.contact_information.size.should == 2
+  end
+
+
+
   it "should create counter accessors" do
     [:available_slots, :pitchers, :basic].each do |m|
        @roster.respond_to?(m).should == true

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 2
-  version: 0.3.2
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Nate Wiger
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-21 00:00:00 -07:00
+date: 2010-08-11 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -25,10 +25,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
-        - 1
+        - 2
         - 0
-        - 3
-        version: 1.0.3
+        - 4
+        version: 2.0.4
   type: :runtime
   version_requirements: *id001
 description: Map Redis types directly to Ruby objects. Works with any class or ORM.
@@ -43,12 +43,15 @@ extra_rdoc_files:
 - Rakefile
 - README.rdoc
 files: 
+- lib/redis/base_object.rb
 - lib/redis/counter.rb
+- lib/redis/hash.rb
 - lib/redis/helpers/core_commands.rb
 - lib/redis/helpers/serialize.rb
 - lib/redis/list.rb
 - lib/redis/lock.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
@@ -90,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       - 0
       version: "0"
 requirements: 
-- redis, v1.0.3 or greater
+- redis, v2.0.4 or greater
 rubyforge_project: redis-objects
 rubygems_version: 1.3.6
 signing_key: