redis-objects 0.1.0 → 0.2.0

data/README.rdoc

@@ -1,85 +1,192 @@
-= Redis::Objects - Lightweight, atomic object layer around redis-rb
+= Redis::Objects - Map Redis types directly to Ruby objects
 
 This is *not* an ORM.  People that are wrapping ORM's around Redis are missing
 the point.
 
 The killer feature of Redis that it allows you to perform atomic operations
-on _individual_ data structures, like counters, lists, and sets, that you can use
-*with* your existing ActiveRecord/DataMapper/etc models, or in classes that have
-nothing to do with an ORM or even a database. That's where this gem comes in.
+on _individual_ data structures, like counters, lists, and sets. You can then use
+these *with* your existing ActiveRecord/DataMapper/etc models, or in classes that have
+nothing to do with an ORM or even a database.  This gem maps Ezra's +redis+ library
+to Ruby objects to make use seamless.
 
-
-This gem originally arose out of a need for high-concurrency operations for online
-games; for a fun rant on the topic, see
+This gem originally arose out of a need for high-concurrency atomic operations;
+for a fun rant on the topic, see
 {ATOMICITY}[http://github.com/nateware/redis-objects/blob/master/ATOMICITY.rdoc],
 or scroll down to "Atomicity" in this README.
 
-There are two ways to use Redis::Objects, either as an +include+ in a class, or
-by using +new+ with the type of data structure you want to create.
+There are two ways to use Redis::Objects, either as an +include+ in a model class,
+or by using +new+ with the type of data structure you want to create.
 
 == Installation
 
     gem install gemcutter
     gem tumble
     gem install redis-objects
-   
+
+== Example 1: Individual Usage
+
+There is a Ruby object that maps to each Redis type.
+
 === Initialization
 
-    # If on Rails, config/initializers/redis.rb is a good place for this
+You can either set the $redis global variable to your Redis handle:
+
+    $redis = Redis.new(:host => 'localhost', :port => 6379)
+    @value = Redis::Value.new('myvalue')
+
+Or you can pass the Redis handle into the new method:
+
+    redis  = Redis.new(:host => 'localhost', :port => 6379)
+    @value = Redis::Value.new('myvalue', redis)
+
+=== Counters
+
+Create a new counter. The +counter_name+ is the key stored in Redis.
+
+    @counter = Redis::Counter.new('counter_name')
+    @counter.increment
+    @counter.decrement
+    puts @counter.value
+    @counter.increment do |val|
+      raise "Full" if val > MAX_VAL  # rewind counter
+    end
+
+See the section on "Atomicity" for cool uses of atomic counter blocks.
+
+=== Lists
+
+Lists work just like Ruby arrays:
+
+    @list = Redis::List.new('list_name')
+    @list << 'a'
+    @list << 'b'
+    @list.include? 'c'   # false
+    @list.values  # ['a','b']
+    @list << 'c'
+    @list.delete('c')
+    @list[0]
+    @list[0,1]
+    @list[0..1]
+    @list.shift
+    @list.pop
+    @list.clear
+    # etc
+
+=== Sets
+
+Sets work like the Ruby {Set}[http://ruby-doc.org/core/classes/Set.html] class:
+
+    @set = Redis::Set.new('set_name')
+    @set << 'a'
+    @set << 'b'
+    @set << 'a'  # dup ignored
+    @set.member? 'c'   # false
+    @set.members  # ['a','b']
+    @set.each do |member|
+      puts member
+    end
+    @set.clear
+    # etc
+
+You can perform Redis intersections/unions easily:
+
+    @set1 = Redis::Set.new('set1')
+    @set2 = Redis::Set.new('set2')
+    @set3 = Redis::Set.new('set3')
+    members = @set1 & @set2   # intersection
+    members = @set1 | @set2   # union
+    members = @set1 + @set2   # union
+    members = @set1.intersection(@set2, @set3)  # multiple
+    members = @set1.union(@set2, @set3)         # multiple
+
+Or store them in Redis:
+
+    @set1.interstore('intername', @set2, @set3)
+    members = @set1.redis.get('intername')
+    @set1.unionstore('unionname', @set2, @set3)
+    members = @set1.redis.get('unionname')
+
+=== Values
+
+Simple values are easy as well:
+
+    @value = Redis::Value.new('value_name')
+    @value.value = 'a'
+    @value.delete
+
+== Example 2: Class Usage
+
+This method of use makes it easy to integrate Redis types with an existing
+ActiveRecord model, DataMapper resource, or other class.  Redis::Objects
+will work with any class that provides an +id+ method that returns a unique
+value.  Redis::Objects will automatically create keys that are unique to
+each object.
+
+=== Initialization
+
+If on Rails, 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)
 
-== Examples
+=== Model Class
 
-=== Model Class Usage
+Include Redis::Objects in any type of class:
 
     class Team < ActiveRecord::Base
       include Redis::Objects
       
-      counter :drafted_players
-      counter :active_players
-      counter :total_online_players, :global => true
+      counter :hits
+      counter :runs
+      counter :outs
+      counter :inning, :start => 1
       list :on_base
       set :outfielders
-      value :coach
+      value :at_bat
     end
-    
-Familiar Ruby operations Just Work:
 
-    @team = Team.find(1)
+Familiar Ruby array operations Just Work (TM):
+
+    @team = Team.find_by_name('New York Yankees')
     @team.on_base << 'player1'
     @team.on_base << 'player2'
-    puts @team.on_base   # ['player1', 'player2']
+    @team.on_base << 'player3'
+    @team.on_base    # ['player1', 'player2']
     @team.on_base.pop
+    @team.on_base.shift
+    @team.on_base.length  # 1
+    @team.on_base.delete('player3')
 
-With one purposeful exception - counters cannot be set, only incremented/decremented:
-
-    @team.drafted_players.increment  # or incr
-    @team.drafted_players.decrement  # or decr
-    @team.drafted_players = 4   # exception
-    @team.drafted_players += 1  # exception
+Sets work like the Ruby {Set}[http://ruby-doc.org/core/classes/Set.html] class:
+    
+    @team.outfielders << 'outfielder1' << 'outfielder1'
+    @team.outfielders << 'outfielder2'
+    @team.outfielders  # ['outfielder1', 'outfielder2']
+    @team.outfielders.each do |player|
+      puts player
+    end
+    player = @team.outfielders.detect{|of| of == 'outfielder2'}
 
-=== Instance Usage
+Note counters cannot be assigned to, only incremented/decremented:
 
-=== Counters
+    @team.hits.increment  # or incr
+    @team.hits.decrement  # or decr
+    @team.hits.incr(3)    # add 3
+    @team.runs = 4        # exception
 
-    @counter = Redis::Counter.new('counter_name')
-    @counter.increment
-    puts @counter
-    puts @counter.get  # force re-fetch
+For free, you get a +redis+ handle usable in your class:
 
-=== Lists
+    @team.redis.get('somekey')
+    @team.redis.smembers('someset')
 
-    @list = Redis::List.new('list_name')
-    @list << 'a'
-    @list << 'b'
-    puts @list
+You can call any operation supported by {Redis}[http://code.google.com/p/redis/wiki/CommandReference]
 
 == Atomicity
 
 You are probably not handling atomicity correctly in your app.  For a fun rant
-on the topic, see {ATOMICITY}[ATOMICITY.doc]
+on the topic, see
+{ATOMICITY}[http://github.com/nateware/redis-objects/blob/master/ATOMICITY.rdoc].
 
 Atomic counters are a good way to handle concurrency:
 

data/lib/redis/counter.rb

@@ -8,12 +8,11 @@ class Redis
   #
   class Counter
     attr_reader :key, :options, :redis
-    def initialize(key, options={})
+    def initialize(key, redis=$redis, options={})
       @key = key
+      @redis = redis
       @options = options
-      @redis = options[:redis] || $redis || Redis::Objects.redis
       @options[:start] ||= 0
-      @options[:type]  ||= @options[:start] == 0 ? :increment : :decrement
       @redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
     end
 

data/lib/redis/list.rb

@@ -4,92 +4,119 @@ class Redis
   # behave as much like Ruby arrays as possible.
   #
   class List
+    require 'enumerator'
+    include Enumerable
+
     attr_reader :key, :options, :redis
-    def initialize(key, options={})
+    def initialize(key, redis=$redis, options={})
       @key = key
+      @redis = redis
       @options = options
-      @redis   = options[:redis] || $redis || Redis::Objects.redis
-      @options[:start] ||= 0
-      @options[:type]  ||= @options[:start] == 0 ? :increment : :decrement
-      @redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
     end
-
+    
+    # Works like push.  Can chain together: list << 'a' << 'b'
     def <<(value)
       push(value)
+      self  # for << 'a' << 'b'
     end
-    
+
+    # Add a member to the end of the list. Redis: RPUSH
     def push(value)
       redis.rpush(key, value)
-      @values << value
     end
 
+    # Remove a member from the end of the list. Redis: RPOP
     def pop
       redis.rpop(key)
-      @values.pop
     end
 
+    # Add a member to the start of the list. Redis: LPUSH
     def unshift(value)
       redis.lpush(key, value)
-      @values.unshift value
     end
 
+    # Remove a member from the start of the list. Redis: LPOP
     def shift
       redis.lpop(key)
     end
 
+    # Return all values in the list. Redis: LRANGE(0,-1)
     def values
-      @values ||= get
+      range(0, -1)
     end
+    alias_method :get, :values
 
-    def value=(val)
-      redis.set(key, val)
-      @values = val
-    end
-    
-    def get
-      @values = range(0, -1)
-    end
-    
-    def [](index)
-      case index
-      when Range
+    # Same functionality as Ruby arrays.  If a single number is given, return
+    # just the element at that index using Redis: LINDEX. Otherwise, return
+    # a range of values using Redis: LRANGE.
+    def [](index, length=nil)
+      if index.is_a? Range
         range(index.first, index.last)
+      elsif length
+        range(index, length)
       else
-        range(index, index)
+        at(index)
       end
     end
     
+    # 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.
+    # Redis: LREM
     def delete(name, count=0)
-      redis.lrem(name, count)
+      redis.lrem(key, count, name)  # weird api
+      get
+    end
+
+    # Iterate through each member of the set.  Redis::Objects mixes in Enumerable,
+    # so you can also use familiar methods like +collect+, +detect+, and so forth.
+    def each(&block)
+      values.each(&block)
     end
 
+    # Return a range of values from +start_index+ to +end_index+.  Can also use
+    # the familiar list[start,end] Ruby syntax. Redis: LRANGE
     def range(start_index, end_index)
       redis.lrange(key, start_index, end_index)
     end
- 
+
+    # Return the value at the given index. Can also use familiar list[index] syntax.
+    # Redis: LINDEX
     def at(index)
-      redis.lrange(key, index, index)
+      redis.lindex(key, index)
+    end
+
+    # Return the first element in the list. Redis: LINDEX(0)
+    def first
+      at(0)
     end
 
+    # Return the last element in the list. Redis: LINDEX(-1)
     def last
-      redis.lrange(key, -1, -1)
+      at(-1)
     end
 
+    # Clear the list entirely. Redis: DEL
     def clear
       redis.del(key)
     end
 
+    # Return the length of the list. Aliased as size. Redis: LLEN
     def length
-      redis.length
+      redis.llen(key)
     end
     alias_method :size, :length
-    
+   
+    # Returns true if there are no elements in the list. Redis: LLEN == 0
     def empty?
-      values.empty?
+      length == 0
     end
-    
+ 
     def ==(x)
       values == x
     end
+    
+    def to_s
+      values.join(', ')
+    end
   end
 end

data/lib/redis/lock.rb

@@ -10,11 +10,11 @@ class Redis
     class LockTimeout < StandardError; end #:nodoc:
 
     attr_reader :key, :options, :redis
-    def initialize(key, options={})
+    def initialize(key, redis=$redis, options={})
       @key = key
+      @redis = redis
       @options = options
       @options[:timeout] ||= 5
-      @redis = options[:redis] || $redis || Redis::Objects.redis
       @redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
     end
 

data/lib/redis/objects/counters.rb

@@ -24,7 +24,7 @@ class Redis
           @counters[name] = options
           class_eval <<-EndMethods
             def #{name}
-              @#{name} ||= Redis::Counter.new(field_key(:#{name}), self.class.counters[:#{name}].merge(:redis => redis))
+              @#{name} ||= Redis::Counter.new(field_key(:#{name}), redis, self.class.counters[:#{name}])
             end
           EndMethods
         end

data/lib/redis/objects/lists.rb

@@ -20,7 +20,7 @@ class Redis
           @lists[name] = options
           class_eval <<-EndMethods
             def #{name}
-              @#{name} ||= Redis::List.new(field_key(:#{name}), self.class.lists[:#{name}].merge(:redis => redis))
+              @#{name} ||= Redis::List.new(field_key(:#{name}), redis, self.class.lists[:#{name}])
             end
           EndMethods
         end

data/lib/redis/objects/locks.rb

@@ -22,7 +22,7 @@ class Redis
           @locks[name] = options
           class_eval <<-EndMethods
             def #{name}_lock(&block)
-              @#{name}_lock ||= Redis::Lock.new(field_key(:#{name}_lock), self.class.locks[:#{name}].merge(:redis => redis))
+              @#{name}_lock ||= Redis::Lock.new(field_key(:#{name}_lock), redis, self.class.locks[:#{name}])
             end
           EndMethods
         end

data/lib/redis/objects/sets.rb

@@ -4,6 +4,31 @@ require 'redis/set'
 class Redis
   module Objects
     module Sets
+      def self.included(klass)
+        klass.instance_variable_set('@sets', {})
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+
+      # Class methods that appear in your class when you include Redis::Objects.
+      module ClassMethods
+        attr_reader :sets
+
+        # Define a new list.  It will function like a regular instance
+        # method, so it can be used alongside ActiveRecord, DataMapper, etc.
+        def set(name, options={})
+          @sets[name] = options
+          class_eval <<-EndMethods
+            def #{name}
+              @#{name} ||= Redis::Set.new(field_key(:#{name}), redis, self.class.sets[:#{name}])
+            end
+          EndMethods
+        end
+      end
+
+      # Instance methods that appear in your class when you include Redis::Objects.
+      module InstanceMethods
+      end
     end
   end
 end

data/lib/redis/objects/values.rb

@@ -20,7 +20,7 @@ class Redis
           @values[name] = options
           class_eval <<-EndMethods
             def #{name}
-              @#{name} ||= Redis::Value.new(field_key(:#{name}), self.class.values[:#{name}].merge(:redis => redis))
+              @#{name} ||= Redis::Value.new(field_key(:#{name}), redis, self.class.values[:#{name}])
             end
             def #{name}=(value)
               #{name}.value = value

data/lib/redis/set.rb

@@ -3,5 +3,131 @@ class Redis
   # Class representing a set.
   #
   class Set
+    require 'enumerator'
+    include Enumerable
+
+    attr_reader :key, :options, :redis
+    
+    # Create a new Set.
+    def initialize(key, redis=$redis, options={})
+      @key = key
+      @redis = redis
+      @options = options
+    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)
+      redis.sadd(key, value)
+    end
+
+    # Return all members in the set.  Redis: SMEMBERS
+    def members
+      redis.smembers(key)
+    end
+    alias_method :get, :members
+
+    # Returns true if the specified value is in the set.  Redis: SISMEMBER
+    def member?(value)
+      redis.sismember(key, value)
+    end
+    alias_method :include?, :member?
+
+    # Delete the value from the set.  Redis: SREM
+    def delete(name)
+      redis.srem(key, name)
+      get
+    end
+
+    # Wipe the set entirely.  Redis: DEL
+    def clear
+      redis.del(key)
+    end
+
+    # Iterate through each member of the set.  Redis::Objects mixes in Enumerable,
+    # so you can also use familiar methods like +collect+, +detect+, and so forth.
+    def each(&block)
+      members.each(&block)
+    end
+
+    # Return the intersection with another set.  Can pass it either another set
+    # object or set name.  Also available as & which is a bit cleaner:
+    #
+    #    members_in_both = set1 & set2
+    #
+    # If you want to specify multiple sets, you must use +intersection+:
+    #
+    #    members_in_all = set1.intersection(set2, set3, set4)
+    #    members_in_all = set1.inter(set2, set3, set4)  # alias
+    #
+    # Redis: SINTER
+    def intersection(*sets)
+      redis.sinter(key, *keys_from_objects(sets))
+    end
+    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)
+      redis.sinterstore(name, key, *keys_from_objects(sets))
+    end
+
+    # Return the union with another set.  Can pass it either another set
+    # object or set name. Also available as | and + which are a bit cleaner:
+    #
+    #    members_in_either = set1 | set2
+    #    members_in_either = set1 + set2
+    #
+    # If you want to specify multiple sets, you must use +union+:
+    #
+    #    members_in_all = set1.union(set2, set3, set4)
+    #
+    # Redis: SUNION
+    def union(*sets)
+      redis.sunion(key, *keys_from_objects(sets))
+    end
+    alias_method :|, :union
+    alias_method :+, :union
+
+    # Calculate the union and store it in Redis as +name+. Returns the number
+    # of elements in the stored union. Redis: SINTERSTORE
+    def unionstore(name, *sets)
+      redis.sunionstore(name, key, *keys_from_objects(sets))
+    end
+
+    # The number of members in the set. Aliased as size. Redis: SCARD
+    def length
+      redis.scard(key)
+    end
+    alias_method :size, :length
+
+    # Returns true if the set has no members. Redis: SCARD == 0
+    def empty?
+      length == 0
+    end
+
+    def ==(x)
+      members == x
+    end
+    
+    def to_s
+      members.join(', ')
+    end
+    
+    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::Set) ? set.key : set}
+    end
+    
   end
 end

data/lib/redis/value.rb

@@ -4,10 +4,10 @@ class Redis
   #
   class Value
     attr_reader :key, :options, :redis
-    def initialize(key, options={})
+    def initialize(key, redis=$redis, options={})
       @key = key
+      @redis = redis
       @options = options
-      @redis   = options[:redis] || $redis || Redis::Objects.redis
       @redis.setnx(key, @options[:default]) if @options[:default]
     end
 

data/spec/redis_objects_instance_spec.rb

@@ -0,0 +1,18 @@
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Redis::List do
+
+
+end
+
+describe Redis::Set do
+
+
+end
+
+describe Redis::Value do
+
+
+end
+

data/spec/redis_objects_model_spec.rb

@@ -1,6 +1,9 @@
 
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
+UNIONSTORE_KEY = 'test:unionstore'
+INTERSTORE_KEY = 'test:interstore'
+
 class Roster
   include Redis::Objects
   counter :available_slots, :start => 10
@@ -10,6 +13,7 @@ class Roster
   lock :resort, :timeout => 2
   value :starting_pitcher
   list :player_stats
+  set :outfielders
 
   def initialize(id=1) @id = id end
   def id; @id; end
@@ -20,6 +24,10 @@ describe Redis::Objects do
   before :all do
     @roster  = Roster.new
     @roster2 = Roster.new
+    
+    @roster_1 = Roster.new(1)
+    @roster_2 = Roster.new(2)
+    @roster_3 = Roster.new(3)
   end
   
   before :each do
@@ -29,6 +37,12 @@ describe Redis::Objects do
     @roster.resort_lock.clear
     @roster.starting_pitcher.delete
     @roster.player_stats.clear
+    @roster.outfielders.clear
+    @roster_1.outfielders.clear
+    @roster_2.outfielders.clear
+    @roster_3.outfielders.clear
+    @roster.redis.del(UNIONSTORE_KEY)
+    @roster.redis.del(INTERSTORE_KEY)
   end
 
   it "should provide a connection method" do
@@ -254,6 +268,137 @@ describe Redis::Objects do
     @roster.player_stats.should be_empty
     @roster.player_stats << 'a'
     @roster.player_stats.should == ['a']
+    @roster.player_stats.get.should == ['a']
+    @roster.player_stats.unshift 'b'
+    @roster.player_stats.to_s.should == 'b, a'
+    @roster.player_stats.should == ['b','a']
+    @roster.player_stats.get.should == ['b','a']
+    @roster.player_stats.push 'c'
+    @roster.player_stats.should == ['b','a','c']
+    @roster.player_stats.get.should == ['b','a','c']
+    @roster.player_stats.first.should == 'b'
+    @roster.player_stats.last.should == 'c'
+    @roster.player_stats << 'd'
+    @roster.player_stats.should == ['b','a','c','d']
+    @roster.player_stats[1].should == 'a'
+    @roster.player_stats[0].should == 'b'
+    @roster.player_stats[2].should == 'c'
+    @roster.player_stats[3].should == 'd'
+    @roster.player_stats.include?('c').should be_true
+    @roster.player_stats.include?('no').should be_false
+    @roster.player_stats.pop
+    @roster.player_stats[0].should == @roster.player_stats.at(0)
+    @roster.player_stats[1].should == @roster.player_stats.at(1)
+    @roster.player_stats[2].should == @roster.player_stats.at(2)
+    @roster.player_stats.should == ['b','a','c']
+    @roster.player_stats.get.should == ['b','a','c']
+    @roster.player_stats.shift
+    @roster.player_stats.should == ['a','c']
+    @roster.player_stats.get.should == ['a','c']
+    @roster.player_stats << 'e' << 'f' << 'e'
+    @roster.player_stats.should == ['a','c','e','f','e']
+    @roster.player_stats.get.should == ['a','c','e','f','e']
+    @roster.player_stats.delete('e')
+    @roster.player_stats.should == ['a','c','f']
+    @roster.player_stats.get.should == ['a','c','f']
+    @roster.player_stats << 'j'
+    @roster.player_stats.should == ['a','c','f','j']
+    @roster.player_stats[0..2].should == ['a','c','f']
+    @roster.player_stats[1, 3].should == ['c','f','j']
+    @roster.player_stats.length.should == 4
+    @roster.player_stats.size.should == 4
+    @roster.player_stats.should == ['a','c','f','j']
+    @roster.player_stats.get.should == ['a','c','f','j']
+
+    i = -1
+    @roster.player_stats.each do |st|
+      st.should == @roster.player_stats[i += 1]
+    end
+    @roster.player_stats.should == ['a','c','f','j']
+    @roster.player_stats.get.should == ['a','c','f','j']
+
+    @roster.player_stats.each_with_index do |st,i|
+      st.should == @roster.player_stats[i]
+    end
+    @roster.player_stats.should == ['a','c','f','j']
+    @roster.player_stats.get.should == ['a','c','f','j']
+
+    coll = @roster.player_stats.collect{|st| st}
+    coll.should == ['a','c','f','j']
+    @roster.player_stats.should == ['a','c','f','j']
+    @roster.player_stats.get.should == ['a','c','f','j']
+
+    @roster.player_stats << 'a'
+    coll = @roster.player_stats.select{|st| st == 'a'}
+    coll.should == ['a','a']
+    @roster.player_stats.should == ['a','c','f','j','a']
+    @roster.player_stats.get.should == ['a','c','f','j','a']
+  end
+
+  it "should handle sets of simple values" do
+    @roster.outfielders.should be_empty
+    @roster.outfielders << 'a' << 'a' << 'a'
+    @roster.outfielders.should == ['a']
+    @roster.outfielders.get.should == ['a']
+    @roster.outfielders << 'b' << 'b'
+    @roster.outfielders.to_s.should == 'a, b'
+    @roster.outfielders.should == ['a','b']
+    @roster.outfielders.members.should == ['a','b']
+    @roster.outfielders.get.should == ['a','b']
+    @roster.outfielders << 'c'
+    @roster.outfielders.sort.should == ['a','b','c']
+    @roster.outfielders.get.sort.should == ['a','b','c']
+    @roster.outfielders.delete('c')
+    @roster.outfielders.should == ['a','b']
+    @roster.outfielders.get.sort.should == ['a','b']
+    @roster.outfielders.length.should == 2
+    @roster.outfielders.size.should == 2
+    
+    i = 0
+    @roster.outfielders.each do |st|
+      i += 1
+    end
+    i.should == @roster.outfielders.length
+
+    coll = @roster.outfielders.collect{|st| st}
+    coll.should == ['a','b']
+    @roster.outfielders.should == ['a','b']
+    @roster.outfielders.get.should == ['a','b']
+
+    @roster.outfielders << 'c'
+    @roster.outfielders.member?('c').should be_true
+    @roster.outfielders.include?('c').should be_true
+    @roster.outfielders.member?('no').should be_false
+    coll = @roster.outfielders.select{|st| st == 'c'}
+    coll.should == ['c']
+    @roster.outfielders.sort.should == ['a','b','c']
+  end
+  
+  it "should handle set intersections and unions" do
+    @roster_1.outfielders << 'a' << 'b' << 'c' << 'd' << 'e'
+    @roster_2.outfielders << 'c' << 'd' << 'e' << 'f' << 'g'
+    @roster_3.outfielders << 'a' << 'd' << 'g' << 'l' << 'm'
+    @roster_1.outfielders.sort.should == %w(a b c d e)
+    @roster_2.outfielders.sort.should == %w(c d e f g)
+    @roster_3.outfielders.sort.should == %w(a d g l m)
+    (@roster_1.outfielders & @roster_2.outfielders).sort.should == ['c','d','e']
+    @roster_1.outfielders.intersection(@roster_2.outfielders).sort.should == ['c','d','e']
+    @roster_1.outfielders.intersection(@roster_2.outfielders, @roster_3.outfielders).sort.should == ['d']
+    @roster_1.outfielders.intersect(@roster_2.outfielders).sort.should == ['c','d','e']
+    @roster_1.outfielders.inter(@roster_2.outfielders, @roster_3.outfielders).sort.should == ['d']
+    @roster_1.outfielders.interstore(INTERSTORE_KEY, @roster_2.outfielders).should == 3
+    @roster_1.redis.smembers(INTERSTORE_KEY).sort.should == ['c','d','e']
+    @roster_1.outfielders.interstore(INTERSTORE_KEY, @roster_2.outfielders, @roster_3.outfielders).should == 1
+    @roster_1.redis.smembers(INTERSTORE_KEY).sort.should == ['d']
+
+    (@roster_1.outfielders | @roster_2.outfielders).sort.should == ['a','b','c','d','e','f','g']
+    (@roster_1.outfielders + @roster_2.outfielders).sort.should == ['a','b','c','d','e','f','g']
+    @roster_1.outfielders.union(@roster_2.outfielders).sort.should == ['a','b','c','d','e','f','g']
+    @roster_1.outfielders.union(@roster_2.outfielders, @roster_3.outfielders).sort.should == ['a','b','c','d','e','f','g','l','m']
+    @roster_1.outfielders.unionstore(UNIONSTORE_KEY, @roster_2.outfielders).should == 7
+    @roster_1.redis.smembers(UNIONSTORE_KEY).sort.should == ['a','b','c','d','e','f','g']
+    @roster_1.outfielders.unionstore(UNIONSTORE_KEY, @roster_2.outfielders, @roster_3.outfielders).should == 9
+    @roster_1.redis.smembers(UNIONSTORE_KEY).sort.should == ['a','b','c','d','e','f','g','l','m']
   end
 
   it "should provide a lock method that accepts a block" do
@@ -265,7 +410,7 @@ describe Redis::Objects do
     a.should be_true
   end
   
-  xit "should raise an exception if the timeout is exceeded" do
+  it "should raise an exception if the timeout is exceeded" do
     @roster.redis.set(@roster.resort_lock.key, 1)
     error = nil
     begin

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: redis-objects
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Nate Wiger
@@ -9,11 +9,20 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-24 00:00:00 -08:00
+date: 2009-11-26 00:00:00 -08:00
 default_executable: 
-dependencies: []
-
-description: Redis::Objects is a lightweight library that lets you use Redis primitives as Ruby objects from any class or ORM
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.1"
+    version: 
+description: Map Redis types directly to Ruby objects. Works with any class or ORM.
 email: nate@wiger.org
 executables: []
 
@@ -36,6 +45,7 @@ files:
 - lib/redis/objects.rb
 - lib/redis/set.rb
 - lib/redis/value.rb
+- spec/redis_objects_instance_spec.rb
 - spec/redis_objects_model_spec.rb
 - spec/spec_helper.rb
 - ATOMICITY.rdoc
@@ -62,12 +72,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version 
       version: "0"
   version: 
-requirements: []
-
+requirements: 
+- redis, v0.1 or greater
 rubyforge_project: redis-objects
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: Lightweight map of Redis types to Ruby objects
+summary: Maps Redis types to Ruby objects
 test_files: []