redis-objects 0.2.0 → 0.2.1

data/README.rdoc

@@ -47,6 +47,9 @@ Create a new counter. The +counter_name+ is the key stored in Redis.
     @counter.increment
     @counter.decrement
     puts @counter.value
+
+This gem provides a clean way to do atomic blocks as well:
+
     @counter.increment do |val|
       raise "Full" if val > MAX_VAL  # rewind counter
     end
@@ -72,6 +75,14 @@ Lists work just like Ruby arrays:
     @list.clear
     # etc
 
+Complex data types are no problem:
+
+    @list << {:name => "Nate", :city => "San Diego"}
+    @list << {:name => "Peter", :city => "Oceanside"}
+    @list.each do |el|
+      puts "#{el[:name]} lives in #{el[:city]}"
+    end
+
 === Sets
 
 Sets work like the Ruby {Set}[http://ruby-doc.org/core/classes/Set.html] class:
@@ -106,6 +117,16 @@ Or store them in Redis:
     @set1.unionstore('unionname', @set2, @set3)
     members = @set1.redis.get('unionname')
 
+And use complex data types too:
+
+    @set1 << {:name => "Nate", :city => "San Diego"}
+    @set1 << {:name => "Peter", :city => "Oceanside"}
+    @set2 << {:name => "Nate", :city => "San Diego"}
+    @set2 << {:name => "Jeff", :city => "Del Mar"}
+
+    @set1 & @set2  # Nate
+    @set1 | @set2  # all 3 people
+
 === Values
 
 Simple values are easy as well:
@@ -114,10 +135,16 @@ Simple values are easy as well:
     @value.value = 'a'
     @value.delete
 
+Of course complex data is no problem:
+
+    @account = Account.create!(params[:account])
+    @newest  = Redis::Value.new('newest_account')
+    @newest.value = @account
+
 == 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
+Using Redis::Objects this way makes it trivial 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.
@@ -158,7 +185,7 @@ Familiar Ruby array operations Just Work (TM):
     @team.on_base.length  # 1
     @team.on_base.delete('player3')
 
-Sets work like the Ruby {Set}[http://ruby-doc.org/core/classes/Set.html] class:
+Sets operations work too:
     
     @team.outfielders << 'outfielder1' << 'outfielder1'
     @team.outfielders << 'outfielder2'
@@ -168,7 +195,7 @@ Sets work like the Ruby {Set}[http://ruby-doc.org/core/classes/Set.html] class:
     end
     player = @team.outfielders.detect{|of| of == 'outfielder2'}
 
-Note counters cannot be assigned to, only incremented/decremented:
+Counters can be atomically incremented/decremented (but not assigned):
 
     @team.hits.increment  # or incr
     @team.hits.decrement  # or decr

data/lib/redis/counter.rb

@@ -22,38 +22,31 @@ class Redis
     # disconnecting all players).
     def reset(to=options[:start])
       redis.set(key, to.to_i)
-      @value = to.to_i
     end
 
-    # Re-gets the current value of the counter.  Normally just calling the
+    # Returns the current value of the counter.  Normally just calling the
     # counter will lazily fetch the value, and only update it if increment
     # or decrement is called.  This forces a network call to redis-server
     # to get the current value.
-    def get
-      @value = redis.get(key).to_i
+    def value
+      redis.get(key).to_i
     end
+    alias_method :get, :value
 
     # Delete a counter.  Usage discouraged.  Consider +reset+ instead.
     def delete
       redis.del(key)
-      @value = nil
     end
     alias_method :del, :delete
 
-    # Returns the (possibly cached) value of the counter.  Use +get+ to
-    # force a re-get from the Redis server.
-    def value
-      @value ||= get
-    end
-
     # Increment the counter atomically and return the new value.  If passed
     # a block, that block will be evaluated with the new value of the counter
     # as an argument. If the block returns nil or throws an exception, the
     # counter will automatically be decremented to its previous value.  This
     # method is aliased as incr() for brevity.
     def increment(by=1, &block)
-      @value = redis.incr(key, by).to_i
-      block_given? ? rewindable_block(:decrement, @value, &block) : @value
+      val = redis.incr(key, by).to_i
+      block_given? ? rewindable_block(:decrement, val, &block) : val
     end
     alias_method :incr, :increment
 
@@ -63,8 +56,8 @@ class Redis
     # counter will automatically be incremented to its previous value.  This
     # method is aliased as incr() for brevity.
     def decrement(by=1, &block)
-      @value = redis.decr(key, by).to_i
-      block_given? ? rewindable_block(:increment, @value, &block) : @value
+      val = redis.decr(key, by).to_i
+      block_given? ? rewindable_block(:increment, val, &block) : val
     end
     alias_method :decr, :decrement
 

data/lib/redis/list.rb

@@ -6,6 +6,8 @@ class Redis
   class List
     require 'enumerator'
     include Enumerable
+    require 'redis/serialize'
+    include Redis::Serialize
 
     attr_reader :key, :options, :redis
     def initialize(key, redis=$redis, options={})
@@ -22,27 +24,27 @@ class Redis
 
     # Add a member to the end of the list. Redis: RPUSH
     def push(value)
-      redis.rpush(key, value)
+      redis.rpush(key, to_redis(value))
     end
 
     # Remove a member from the end of the list. Redis: RPOP
     def pop
-      redis.rpop(key)
+      from_redis redis.rpop(key)
     end
 
     # Add a member to the start of the list. Redis: LPUSH
     def unshift(value)
-      redis.lpush(key, value)
+      redis.lpush(key, to_redis(value))
     end
 
     # Remove a member from the start of the list. Redis: LPOP
     def shift
-      redis.lpop(key)
+      from_redis redis.lpop(key)
     end
 
     # Return all values in the list. Redis: LRANGE(0,-1)
     def values
-      range(0, -1)
+      from_redis range(0, -1)
     end
     alias_method :get, :values
 
@@ -64,7 +66,6 @@ class Redis
     # Redis: LREM
     def delete(name, count=0)
       redis.lrem(key, count, name)  # weird api
-      get
     end
 
     # Iterate through each member of the set.  Redis::Objects mixes in Enumerable,
@@ -76,13 +77,13 @@ class Redis
     # 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)
+      from_redis 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.lindex(key, index)
+      from_redis redis.lindex(key, index)
     end
 
     # Return the first element in the list. Redis: LINDEX(0)

data/lib/redis/objects.rb

@@ -58,10 +58,6 @@ class Redis
         klass.send :include, InstanceMethods
         klass.extend ClassMethods
         
-        # Adapted from Redis::Model for marshaling complex data
-        require 'redis/data_types'
-        klass.send :include, Redis::DataTypes
-        
         # Pull in each object type
         klass.send :include, Redis::Objects::Counters
         klass.send :include, Redis::Objects::Values

data/lib/redis/serialize.rb

@@ -0,0 +1,23 @@
+class Redis
+  module Serialize
+    include Marshal
+
+    def to_redis(value)
+      case value
+      when String, Fixnum, Bignum, Float
+        value
+      else
+        dump(value)
+      end
+    end
+    
+    def from_redis(value)
+      case value
+      when Array
+        value.collect{|v| from_redis(v)}
+      else
+        restore(value) rescue value
+      end
+    end
+  end
+end

data/lib/redis/set.rb

@@ -5,6 +5,8 @@ class Redis
   class Set
     require 'enumerator'
     include Enumerable
+    require 'redis/serialize'
+    include Redis::Serialize
 
     attr_reader :key, :options, :redis
     
@@ -24,25 +26,24 @@ class Redis
     # Add the specified value to the set only if it does not exist already.
     # Redis: SADD
     def add(value)
-      redis.sadd(key, value)
+      redis.sadd(key, to_redis(value))
     end
 
     # Return all members in the set.  Redis: SMEMBERS
     def members
-      redis.smembers(key)
+      from_redis 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)
+      redis.sismember(key, to_redis(value))
     end
     alias_method :include?, :member?
 
     # Delete the value from the set.  Redis: SREM
-    def delete(name)
-      redis.srem(key, name)
-      get
+    def delete(value)
+      redis.srem(key, value)
     end
 
     # Wipe the set entirely.  Redis: DEL
@@ -68,7 +69,7 @@ class Redis
     #
     # Redis: SINTER
     def intersection(*sets)
-      redis.sinter(key, *keys_from_objects(sets))
+      from_redis redis.sinter(key, *keys_from_objects(sets))
     end
     alias_method :intersect, :intersection
     alias_method :inter, :intersection
@@ -92,7 +93,7 @@ class Redis
     #
     # Redis: SUNION
     def union(*sets)
-      redis.sunion(key, *keys_from_objects(sets))
+      from_redis redis.sunion(key, *keys_from_objects(sets))
     end
     alias_method :|, :union
     alias_method :+, :union

data/lib/redis/value.rb

@@ -3,6 +3,9 @@ class Redis
   # Class representing a simple value.  You can use standard Ruby operations on it.
   #
   class Value
+    require 'redis/serialize'
+    include Redis::Serialize
+
     attr_reader :key, :options, :redis
     def initialize(key, redis=$redis, options={})
       @key = key
@@ -11,22 +14,17 @@ class Redis
       @redis.setnx(key, @options[:default]) if @options[:default]
     end
 
-    def value
-      @value ||= get
-    end
-
     def value=(val)
-      redis.set(key, val)
-      @value = val
+      redis.set(key, to_redis(val))
     end
     
-    def get
-      @value = redis.get(key)
+    def value
+      from_redis redis.get(key)
     end
-    
+    alias_method :get, :value
+
     def delete
       redis.del(key)
-      @value = nil
     end
     alias_method :del, :delete
 

data/spec/redis_objects_instance_spec.rb

@@ -1,18 +1,270 @@
 
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
+require 'redis/counter'
+require 'redis/list'
+require 'redis/set'
+require 'redis/value'
+
+describe Redis::Value do
+  before :all do
+    @value = Redis::Value.new('spec/value')
+  end
+
+  before :each do
+    @value.delete
+  end
+
+  it "should handle simple values" do
+    @value.should == nil
+    @value.value = 'Trevor Hoffman'
+    @value.should == 'Trevor Hoffman'
+    @value.get.should == 'Trevor Hoffman'
+    @value.del.should be_true
+    @value.should be_nil
+  end
+
+  it "should handle complex marshaled values" do
+    @value.should == nil
+    @value.value = {:json => 'data'}
+    @value.should == {:json => 'data'}
+    @value.get.should == {:json => 'data'}
+    @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.should be_nil
+  end
+
+  after :all do
+    @value.delete
+  end
+end
+
+
 describe Redis::List do
+  before :all do
+    @list = Redis::List.new('spec/list')
+  end
+
+  before :each do
+    @list.clear
+  end
+
+  it "should handle lists of simple values" do
+    @list.should be_empty
+    @list << 'a'
+    @list.should == ['a']
+    @list.get.should == ['a']
+    @list.unshift 'b'
+    @list.to_s.should == 'b, a'
+    @list.should == ['b','a']
+    @list.get.should == ['b','a']
+    @list.push 'c'
+    @list.should == ['b','a','c']
+    @list.get.should == ['b','a','c']
+    @list.first.should == 'b'
+    @list.last.should == 'c'
+    @list << 'd'
+    @list.should == ['b','a','c','d']
+    @list[1].should == 'a'
+    @list[0].should == 'b'
+    @list[2].should == 'c'
+    @list[3].should == 'd'
+    @list.include?('c').should be_true
+    @list.include?('no').should be_false
+    @list.pop.should == 'd'
+    @list[0].should == @list.at(0)
+    @list[1].should == @list.at(1)
+    @list[2].should == @list.at(2)
+    @list.should == ['b','a','c']
+    @list.get.should == ['b','a','c']
+    @list.shift.should == 'b'
+    @list.should == ['a','c']
+    @list.get.should == ['a','c']
+    @list << 'e' << 'f' << 'e'
+    @list.should == ['a','c','e','f','e']
+    @list.get.should == ['a','c','e','f','e']
+    @list.delete('e').should == 2
+    @list.should == ['a','c','f']
+    @list.get.should == ['a','c','f']
+    @list << 'j'
+    @list.should == ['a','c','f','j']
+    @list[0..2].should == ['a','c','f']
+    @list[1, 3].should == ['c','f','j']
+    @list.length.should == 4
+    @list.size.should == 4
+    @list.should == ['a','c','f','j']
+    @list.get.should == ['a','c','f','j']
 
+    i = -1
+    @list.each do |st|
+      st.should == @list[i += 1]
+    end
+    @list.should == ['a','c','f','j']
+    @list.get.should == ['a','c','f','j']
 
+    @list.each_with_index do |st,i|
+      st.should == @list[i]
+    end
+    @list.should == ['a','c','f','j']
+    @list.get.should == ['a','c','f','j']
+
+    coll = @list.collect{|st| st}
+    coll.should == ['a','c','f','j']
+    @list.should == ['a','c','f','j']
+    @list.get.should == ['a','c','f','j']
+
+    @list << 'a'
+    coll = @list.select{|st| st == 'a'}
+    coll.should == ['a','a']
+    @list.should == ['a','c','f','j','a']
+    @list.get.should == ['a','c','f','j','a']
+  end
+
+  it "should handle lists of complex data types" do
+    @list << {:json => 'data'}
+    @list << {:json2 => 'data2'}
+    @list.first.should == {:json => 'data'}
+    @list.last.should == {:json2 => 'data2'}
+    @list << [1,2,3,[4,5]]
+    @list.last.should == [1,2,3,[4,5]]
+    @list.shift.should == {:json => 'data'}
+  end
+
+  after :all do
+    @list.clear
+  end
 end
 
 describe Redis::Set do
+  before :all do
+    @set = Redis::Set.new('spec/set')
+    @set_1 = Redis::Set.new('spec/set_1')
+    @set_2 = Redis::Set.new('spec/set_2')
+    @set_3 = Redis::Set.new('spec/set_3')
+  end
 
+  before :each do
+    @set.clear
+    @set_1.clear
+    @set_2.clear
+    @set_3.clear
+  end
 
-end
+  it "should handle sets of simple values" do
+    @set.should be_empty
+    @set << 'a' << 'a' << 'a'
+    @set.should == ['a']
+    @set.get.should == ['a']
+    @set << 'b' << 'b'
+    @set.to_s.should == 'a, b'
+    @set.should == ['a','b']
+    @set.members.should == ['a','b']
+    @set.get.should == ['a','b']
+    @set << 'c'
+    @set.sort.should == ['a','b','c']
+    @set.get.sort.should == ['a','b','c']
+    @set.delete('c')
+    @set.should == ['a','b']
+    @set.get.sort.should == ['a','b']
+    @set.length.should == 2
+    @set.size.should == 2
+    
+    i = 0
+    @set.each do |st|
+      i += 1
+    end
+    i.should == @set.length
 
-describe Redis::Value do
+    coll = @set.collect{|st| st}
+    coll.should == ['a','b']
+    @set.should == ['a','b']
+    @set.get.should == ['a','b']
 
+    @set << 'c'
+    @set.member?('c').should be_true
+    @set.include?('c').should be_true
+    @set.member?('no').should be_false
+    coll = @set.select{|st| st == 'c'}
+    coll.should == ['c']
+    @set.sort.should == ['a','b','c']
+  end
+  
+  it "should handle set intersections and unions" do
+    @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']
+  end
+
+  after :all do
+    @set.clear
+    @set_1.clear
+    @set_2.clear
+    @set_3.clear
+  end
 end
 
+describe Redis::Counter do
+  before :all do
+    @counter  = Redis::Counter.new('spec/counter')
+    @counter2 = Redis::Counter.new('spec/counter')
+  end
+
+  before :each do
+    @counter.reset
+  end
+
+  it "should support increment/decrement of counters" do
+    @counter.key.should == 'spec/counter'
+    @counter.incr(10)
+    @counter.should == 10
+    
+    # math proxy ops
+    (@counter == 10).should be_true
+    (@counter <= 10).should be_true
+    (@counter < 11).should be_true
+    (@counter > 9).should be_true
+    (@counter >= 10).should be_true
+    "#{@counter}".should == "10"
+
+    @counter.increment.should == 11
+    @counter.increment.should == 12
+    @counter2.increment.should == 13
+    @counter2.increment(2).should == 15
+    @counter.decrement.should == 14
+    @counter2.decrement.should == 13
+    @counter.decrement.should == 12
+    @counter2.decrement(4).should == 8
+    @counter.should == 8
+    @counter.reset.should be_true
+    @counter.should == 0
+    @counter.reset(15).should be_true
+    @counter.should == 15
+  end
+
+  after :all do
+    @counter.delete
+  end
+end

data/spec/redis_objects_model_spec.rb

@@ -1,8 +1,8 @@
 
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-UNIONSTORE_KEY = 'test:unionstore'
-INTERSTORE_KEY = 'test:interstore'
+require 'redis/objects'
+Redis::Objects.redis = $redis
 
 class Roster
   include Redis::Objects
@@ -76,11 +76,10 @@ describe Redis::Objects do
     @roster2.available_slots.decrement.should == 13
     @roster.available_slots.decrement.should == 12
     @roster2.available_slots.decrement(4).should == 8
-    @roster.available_slots.should == 12
-    @roster.available_slots.get.should == 8
-    @roster.available_slots.reset.should == 10
+    @roster.available_slots.should == 8
+    @roster.available_slots.reset.should be_true
     @roster.available_slots.should == 10
-    @roster.available_slots.reset(15).should == 15
+    @roster.available_slots.reset(15).should be_true
     @roster.available_slots.should == 15
     @roster.pitchers.increment.should == 1
     @roster.basic.increment.should == 1
@@ -260,7 +259,16 @@ describe Redis::Objects do
     @roster.starting_pitcher = 'Trevor Hoffman'
     @roster.starting_pitcher.should == 'Trevor Hoffman'
     @roster.starting_pitcher.get.should == 'Trevor Hoffman'
-    @roster.starting_pitcher.del
+    @roster.starting_pitcher.del.should be_true
+    @roster.starting_pitcher.should be_nil
+  end
+
+  it "should handle complex marshaled values" do
+    @roster.starting_pitcher.should == nil
+    @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.should be_nil
   end
 
@@ -286,19 +294,19 @@ describe Redis::Objects do
     @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.pop.should == 'd'
     @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.shift.should == 'b'
     @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.delete('e').should == 2
     @roster.player_stats.should == ['a','c','f']
     @roster.player_stats.get.should == ['a','c','f']
     @roster.player_stats << 'j'
@@ -401,6 +409,26 @@ describe Redis::Objects do
     @roster_1.redis.smembers(UNIONSTORE_KEY).sort.should == ['a','b','c','d','e','f','g','l','m']
   end
 
+  it "should handle lists of complex data types" do
+    @roster.player_stats << {:json => 'data'}
+    @roster.player_stats << {:json2 => 'data2'}
+    @roster.player_stats.first.should == {:json => 'data'}
+    @roster.player_stats.last.should == {:json2 => 'data2'}
+    @roster.player_stats << [1,2,3,[4,5]]
+    @roster.player_stats.last.should == [1,2,3,[4,5]]
+    @roster.player_stats.shift.should == {:json => 'data'}
+  end
+  
+  it "should handle sets of complex data types" do
+    @roster.outfielders << {:a => 1} << {:b => 2}
+    @roster.outfielders.member?({:b => 2})
+    @roster.outfielders.members.should == [{:b => 2}, {:a => 1}]
+    @roster_1.outfielders << {:a => 1} << {:b => 2}
+    @roster_2.outfielders << {:b => 2} << {:c => 3}
+    (@roster_1.outfielders & @roster_2.outfielders).should == [{:b => 2}]
+    (@roster_1.outfielders | @roster_2.outfielders).should == [{:b=>2}, {:c=>3}, {:a=>1}]
+  end
+
   it "should provide a lock method that accepts a block" do
     @roster.resort_lock.key.should == 'roster:1:resort_lock'
     a = false

data/spec/spec_helper.rb

@@ -1,5 +1,7 @@
 $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
 require 'redis'
-require 'redis/objects'
 
-Redis::Objects.redis = Redis.new(:host => ENV['REDIS_HOST'], :port => ENV['REDIS_PORT'])
+$redis = Redis.new(:host => ENV['REDIS_HOST'], :port => ENV['REDIS_PORT'])
+
+UNIONSTORE_KEY = 'test:unionstore'
+INTERSTORE_KEY = 'test:interstore'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: redis-objects
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Nate Wiger
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-26 00:00:00 -08:00
+date: 2009-11-27 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -33,7 +33,6 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - lib/redis/counter.rb
-- lib/redis/data_types.rb
 - lib/redis/list.rb
 - lib/redis/lock.rb
 - lib/redis/objects/core.rb
@@ -43,6 +42,7 @@ files:
 - lib/redis/objects/sets.rb
 - lib/redis/objects/values.rb
 - lib/redis/objects.rb
+- lib/redis/serialize.rb
 - lib/redis/set.rb
 - lib/redis/value.rb
 - spec/redis_objects_instance_spec.rb

data/lib/redis/data_types.rb

@@ -1,84 +0,0 @@
-class Redis
-  module DataTypes
-    TYPES = %w(String Integer Float EpochTime DateTime Json Yaml IPAddress FilePath Uri Slug)
-    def self.included(klass)
-      TYPES.each do |data_type|
-        if Object.const_defined?(data_type)
-          klass = Object.const_get(data_type)
-        else
-          klass = Object.const_set(data_type, Class.new)
-        end
-        if const_defined?(data_type) 
-          klass.extend const_get(data_type)
-        end
-      end
-    end
-
-    module String
-      def to_redis; to_s; end
-    end
-
-    module Integer
-      def from_redis(value); value && value.to_i end
-    end
-
-    module Float
-      def from_redis(value); value && value.to_f end
-    end
-
-    module EpochTime
-      def to_redis(value)
-        value.is_a?(DateTime) ? value.to_time.to_i : value.to_i
-      end
-    
-      def from_redis(value) Time.at(value.to_i) end
-    end
-
-    module DateTime
-      def to_redis(value); value.strftime('%FT%T%z')                        end
-      def from_redis(value); value && ::DateTime.strptime(value, '%FT%T%z') end
-    end
-
-    module Json
-      def to_redis(value); Yajl::Encoder.encode(value)          end
-      def from_redis(value); value && Yajl::Parser.parse(value) end
-    end
-  
-    module Yaml
-      def to_redis(value); Yaml.dump(value)    end
-      def from_redis(value); Yaml.load(value)  end
-    end
-  
-    module IPAddress      
-      def from_redis(value)
-        return nil if value.nil?
-        if value.is_a?(String)
-          IPAddr.new(value.empty? ? '0.0.0.0' : value)
-        else
-          raise "+value+ must be nil or a String"
-        end
-      end
-    end
-  
-    module FilePath
-      require 'pathname'
-      def from_redis(value)
-        value.blank? ? nil : Pathname.new(value)
-      end
-    end
-  
-    module Uri
-      require 'addressable/uri'
-      def from_redis(value)
-        Addressable::URI.parse(value)
-      end
-    end
-  
-    module Slug
-      require 'addressable/uri'
-      def to_redis(value)
-        Addressable::URI.parse(value).display_uri
-      end
-    end
-  end
-end