tractor 0.4.9 → 0.5.0

data/VERSION

@@ -1 +1 @@
-0.4.8
+0.5.0

data/lib/tractor/model/base.rb

@@ -1,7 +1,6 @@
 require 'base64'
 
 module Tractor
-  
   class MissingIdError < StandardError; end
   class DuplicateKeyError < StandardError; end
   class MissingIndexError < StandardError; end
@@ -40,7 +39,7 @@ module Tractor
     end
     
     def count
-      ids.size
+      Tractor.redis.scard(key)
     end
     
     def all
@@ -77,7 +76,32 @@ module Tractor
   end
   
   module Model
+    module Dirty
+      def self.key
+        "Tractor::Model::Dirty:all"
+      end
+      
+      def mark
+        Tractor.redis.sadd Dirty.key, "#{self.class},#{id}"
+      end
+      
+      def self.all
+        Tractor.redis.smembers(Dirty.key).each do |k|
+          klass, id = k.split(',')
+          data = {:id => id, :klass => klass, :data => eval(klass).find_by_id(id).send(:attribute_store)}
+          begin
+            yield data
+            Tractor.redis.srem(Dirty.key, k)
+          rescue Exception => e
+            # Something went wrong, this should be handled on the callers end, but this prevents us from 
+            # removing the dirty record from our list while continuing to process other dirty items.
+          end
+        end
+      end
+    end
+    
     class Base
+      include Dirty
       def initialize(attributes={})
         @attribute_store = {}
         @association_store = {}
@@ -93,6 +117,8 @@ module Tractor
         Tractor.redis.sadd "#{self.class}:all", self.id
         add_to_indices
         add_to_associations
+        mark
+        self.class.run_callbacks(:after_save, self)
         
         return self
       end
@@ -102,6 +128,7 @@ module Tractor
         remove_from_associations
         Tractor.redis.srem("#{self.class}:all", self.id)
         Tractor.redis.del "#{self.class}:#{self.id}"
+        self.class.run_callbacks(:after_destroy, self)
       end
       
       def update(attributes = {})
@@ -147,12 +174,31 @@ module Tractor
       end
       
       class << self
-        attr_reader :attributes, :associations, :indices
+        attr_reader :attributes, :associations, :indices, :callbacks
+        
+        def after_create(name)
+          callbacks[:after_create] << name
+        end
+        
+        def after_destroy(name)
+          callbacks[:after_destroy] << name
+        end
+        
+        def after_save(name)
+          callbacks[:after_save] << name
+        end
+        
+        def run_callbacks(type, obj)
+          callbacks[type].each do |cb|
+            obj.send(cb)
+          end
+        end
         
         def create(attributes={})
           raise DuplicateKeyError, "Duplicate value for #{self} 'id'" if Tractor.redis.sismember("#{self}:all", attributes[:id])
           m = new(attributes)
           m.save
+          run_callbacks(:after_create, m)
           m
         end
         
@@ -215,7 +261,7 @@ module Tractor
         end
         
         def count
-          ids.size
+          Tractor.redis.scard("#{self}:all")
         end
         
         def all
@@ -259,6 +305,10 @@ module Tractor
         def indices
           @indices ||= []
         end
+        
+        def callbacks
+          @callbacks ||= Hash.new {|h, k| h[k] = [] }
+        end
       end
       
       private 

data/performance/dirty.rb

@@ -0,0 +1,59 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'tractor'
+require 'faker'
+
+Tractor.connectdb
+Tractor.flushdb
+
+class Person < Tractor::Model::Base
+  attribute :id
+  attribute :first_name, :index => true
+  attribute :last_name, :index => true
+  attribute :awesome, :type => :boolean, :index => true
+  attribute :company_id, :index => true
+end
+
+class Company < Tractor::Model::Base
+  association :people, Person
+  
+  attribute :id
+  attribute :name
+end
+
+10.times do |i|
+  Company.create(:id => i+1, :name => Faker::Company.name)
+end
+
+puts "Companies created successfully"
+
+10.times do |i|
+  Person.create(
+    :id => i+1,
+    :first_name => Faker::Name.first_name,
+    :last_name => Faker::Name.last_name, 
+    :awesome => rand(2)==0,
+    :company_id => rand(Company.count)+1)
+end
+
+puts "Employees created successfully"
+
+puts "# of dirty objects: #{Tractor.redis.scard("Tractor::Model::Dirty:all")}"
+
+20.times do
+  obj = Tractor.redis.spop("Tractor::Model::Dirty:all")
+  puts "Background syncinng dirty object: #{obj}"
+end
+
+puts "# of dirty objects: #{Tractor.redis.scard("Tractor::Model::Dirty:all")}"
+
+puts "updating company with id 1"
+
+c = Company.find_by_id(1)
+puts "Company name: #{c.name}"
+c.name = "Jelly Copter Inc."
+c.save
+puts "New Company name: #{c.name}"
+
+puts "# of dirty objects: #{Tractor.redis.scard("Tractor::Model::Dirty:all")}"

data/performance/test.rb

@@ -27,6 +27,8 @@ end
   Company.create(:id => i+1, :name => Faker::Company.name)
 end
 
+puts "Companies created successfully"
+
 10000.times do |i|
   Person.create(
     :id => i+1,

data/spec/model/base_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe Tractor::Model::Base do
+describe Tractor do
   attr_reader :redis
   before do
     module Tractor
@@ -11,426 +11,529 @@ describe Tractor::Model::Base do
           attribute :wins_loses
           attribute :game_id
         end
-    
+  
         class Game < Tractor::Model::Base
           attribute :id
           attribute :board
           attribute :flying_object
           attribute :score, :type => :integer, :index => true
-      
+    
           association :players, Tractor::Model::Player
         end
       end
     end
   end
-  
+
   after do
     Tractor.redis.flushdb
   end
   
-  describe ".attribute" do
-    it "inserts the values into the attributes class instance variable" do
-      Tractor::Model::Game.attributes.should include(:board)
-    end
-    
-    it "allows you to specify what type the value should be when it comes out of the tractor" do
-      Tractor::Model::Game.attributes[:score][:type].should == :integer
-    end
+  describe Tractor::Model::Base do
+    describe ".attribute" do
+      it "inserts the values into the attributes class instance variable" do
+        Tractor::Model::Game.attributes.should include(:board)
+      end
     
-    it "creates a set method for each attribute" do
-      game = Tractor::Model::Game.new(:board => "fancy")
-      game.send(:attribute_store)[:board].should == "fancy"
-    end
+      it "allows you to specify what type the value should be when it comes out of the tractor" do
+        Tractor::Model::Game.attributes[:score][:type].should == :integer
+      end
     
-    it "creates a get method for each attribute" do
-      game = Tractor::Model::Game.new(:board => "schmancy")
-      game.board.should == "schmancy"
-    end
+      it "creates a set method for each attribute" do
+        game = Tractor::Model::Game.new(:board => "fancy")
+        game.send(:attribute_store)[:board].should == "fancy"
+      end
     
-    describe "when attribute is a boolean" do
-      it "returns a boolean" do
-        expensive_sammich = Sammich.new(:expensive => true)
-        expensive_sammich.expensive.should == true
-        expensive_sammich.expensive.should be_a(TrueClass)
+      it "creates a get method for each attribute" do
+        game = Tractor::Model::Game.new(:board => "schmancy")
+        game.board.should == "schmancy"
       end
-    end
     
-    describe "when attribute is a integer" do
-      it "returns an integer" do
-        game = Tractor::Model::Game.new(:score => 1222)
-        game.score.should == 1222
-        game.score.should be_a(Fixnum)
+      describe "when attribute is a boolean" do
+        it "returns a boolean" do
+          expensive_sammich = Sammich.new(:expensive => true)
+          expensive_sammich.expensive.should == true
+          expensive_sammich.expensive.should be_a(TrueClass)
+        end
       end
-    end
     
-    describe "when attribute is an index" do
-      before do
-        class Zombo < Tractor::Model::Base
-          attribute :anything, :index => true
+      describe "when attribute is a integer" do
+        it "returns an integer" do
+          game = Tractor::Model::Game.new(:score => 1222)
+          game.score.should == 1222
+          game.score.should be_a(Fixnum)
         end
       end
+    
+      describe "when attribute is an index" do
+        before do
+          class Zombo < Tractor::Model::Base
+            attribute :anything, :index => true
+          end
+        end
       
-      it "returns creates an index for the attribute" do
-        Zombo.indices.should == [:anything]
+        it "returns creates an index for the attribute" do
+          Zombo.indices.should == [:anything]
+        end
       end
     end
-  end
     
-  describe "#association" do
-    attr_reader :game, :player1, :player2
+    describe "#association" do
+      attr_reader :game, :player1, :player2
     
-    before do
-      @game     = Tractor::Model::Game.new({ :id => 'g1' })
-      Tractor::Model::Game.create({ :id => 'g2' })
-      @player1  = Tractor::Model::Player.new({ :id => 'p1', :name => "delicious", :game_id => "g1" })
-      @player2  = Tractor::Model::Player.new({ :id => 'p2', :name => "gross", :game_id => "g2" })
+      before do
+        @game     = Tractor::Model::Game.new({ :id => 'g1' })
+        Tractor::Model::Game.create({ :id => 'g2' })
+        @player1  = Tractor::Model::Player.new({ :id => 'p1', :name => "delicious", :game_id => "g1" })
+        @player2  = Tractor::Model::Player.new({ :id => 'p2', :name => "gross", :game_id => "g2" })
       
-      game.save
-      player1.save
-      player2.save
-    end
+        game.save
+        player1.save
+        player2.save
+      end
     
-    it "adds a method with the given name to the instance" do # "Monkey:a1a:SET_NAME"
-      game.players.should be_a(Tractor::Association)
-    end
+      it "adds a method with the given name to the instance" do # "Monkey:a1a:SET_NAME"
+        game.players.should be_a(Tractor::Association)
+      end
     
-    it "adds a push method for the set on an instance of the class" do
-      game.players.push player2
-      redis.smembers('Tractor::Model::Game:g1:players').should == ['p1', 'p2']
-    end
+      it "adds a push method for the set on an instance of the class" do
+        game.players.push player2
+        redis.smembers('Tractor::Model::Game:g1:players').should == ['p1', 'p2']
+      end
     
-    it "adds an ids method for the set that returns all ids in it" do
-      game.players.ids.should == [player1.id]
-    end
+      it "adds an ids method for the set that returns all ids in it" do
+        game.players.ids.should == [player1.id]
+      end
     
-    it "adds a count method for the set that returns the size of the association" do
-      game.players.count.should == 1
-    end
+      it "adds a count method for the set that returns the size of the association" do
+        game.players.count.should == 1
+      end
     
-    it "automatically adds items to association when they are created" do
-      bocci_ball = Tractor::Model::Game.create({ :id => "bocci_ball" })
-      Tractor::Model::Player.create({ :id => "tobias", :name => "deciduous", :game_id => "bocci_ball" })
-      bocci_ball.players.ids.should == ["tobias"]
-    end
+      it "automatically adds items to association when they are created" do
+        bocci_ball = Tractor::Model::Game.create({ :id => "bocci_ball" })
+        Tractor::Model::Player.create({ :id => "tobias", :name => "deciduous", :game_id => "bocci_ball" })
+        bocci_ball.players.ids.should == ["tobias"]
+      end
     
-    it "adds an all method for the association to return the items in it" do
-      player1_from_game = game.players.all[0]
-      player1_from_game.name.should == player1.name
-      player1_from_game.id.should == player1.id
-    end
+      it "adds an all method for the association to return the items in it" do
+        player1_from_game = game.players.all[0]
+        player1_from_game.name.should == player1.name
+        player1_from_game.id.should == player1.id
+      end
     
-    it "requires the object being added to have been saved to the database before adding it to the association"
-  end
+      it "requires the object being added to have been saved to the database before adding it to the association"
+    end
   
-  describe ".indices" do
-    it "returns all indices on a class" do
-      Sammich.indices.should == [:product, :weight]
+    describe ".indices" do
+      it "returns all indices on a class" do
+        Sammich.indices.should == [:product, :weight]
+      end
     end
-  end
   
-  describe "index" do
-    it "removes newline characters from index key"
-  end
+    describe "index" do
+      it "removes newline characters from index key"
+    end
     
-  describe ".attributes" do
-    attr_reader :sorted_attributes
+    describe ".attributes" do
+      attr_reader :sorted_attributes
     
-    before do
-      @sorted_attributes = Tractor::Model::Game.attributes.keys.sort{|x,y| x.to_s <=> y.to_s}  
-    end
+      before do
+        @sorted_attributes = Tractor::Model::Game.attributes.keys.sort{|x,y| x.to_s <=> y.to_s}  
+      end
   
-    it "returns all attributes that have been added to this class" do
-      sorted_attributes.size.should == 4
-      sorted_attributes.should == [:board, :flying_object, :id, :score]
-    end
+      it "returns all attributes that have been added to this class" do
+        sorted_attributes.size.should == 4
+        sorted_attributes.should == [:board, :flying_object, :id, :score]
+      end
     
-    it "allows different attributes to be specified for different child classes" do
-      Tractor::Model::Game.attributes.size.should == 4
-      Tractor::Model::Player.attributes.size.should == 4
+      it "allows different attributes to be specified for different child classes" do
+        Tractor::Model::Game.attributes.size.should == 4
+        Tractor::Model::Player.attributes.size.should == 4
       
-      Tractor::Model::Game.attributes.keys.should_not include(:name)
-      Tractor::Model::Player.attributes.keys.should_not include(:flying_object)
+        Tractor::Model::Game.attributes.keys.should_not include(:name)
+        Tractor::Model::Player.attributes.keys.should_not include(:flying_object)
+      end
     end
-  end
   
-  describe "#save" do
-    it "raises if id is nil or empty" do
-      game = Tractor::Model::Game.new
-      game.id = nil
-      lambda { game.save }.should raise_error(Tractor::MissingIdError, "Probably wanna set an id")
-      game.id = ''
-      lambda { game.save }.should raise_error(Tractor::MissingIdError, "Probably wanna set an id")
-    end
+    describe "#save" do
+      it "raises if id is nil or empty" do
+        game = Tractor::Model::Game.new
+        game.id = nil
+        lambda { game.save }.should raise_error(Tractor::MissingIdError, "Probably wanna set an id")
+        game.id = ''
+        lambda { game.save }.should raise_error(Tractor::MissingIdError, "Probably wanna set an id")
+      end
     
-    it "should write attributes to redis" do
-      game = Tractor::Model::Game.new({:id => '1', :board => "large", :flying_object => "disc"})
-      game.save
+      it "should write attributes to redis" do
+        game = Tractor::Model::Game.new({:id => '1', :board => "large", :flying_object => "disc"})
+        game.save
       
-      redis_game_attributes = Tractor.redis.mapped_hmget("Tractor::Model::Game:1", "id", "board", "flying_object")
-      redis_game_attributes["id"].should == "1"
-      redis_game_attributes["board"].should == "large"
-      redis_game_attributes["flying_object"].should == "disc"
-    end
+        redis_game_attributes = Tractor.redis.mapped_hmget("Tractor::Model::Game:1", "id", "board", "flying_object")
+        redis_game_attributes["id"].should == "1"
+        redis_game_attributes["board"].should == "large"
+        redis_game_attributes["flying_object"].should == "disc"
+      end
     
-    it "appends the new object to the Game set" do
-      Tractor::Model::Game.all.size.should == 0
-      game = Tractor::Model::Game.new({ :id => '1', :board => "small" })
-      game.save
+      it "appends the new object to the Game set" do
+        Tractor::Model::Game.all.size.should == 0
+        game = Tractor::Model::Game.new({ :id => '1', :board => "small" })
+        game.save
       
-      Tractor::Model::Game.all.size.should == 1
-    end
-  end
+        Tractor::Model::Game.all.size.should == 1
+      end
     
-  describe ".all" do
-    it "every object that is created for this class will be in this set" do
-      MonkeyClient.all.size.should == 0
-      MonkeyClient.create({ :id => 'a1a', :evil => true, :birthday => "Dec 3" })
-      MonkeyClient.create({ :id => 'b1b', :evil => false, :birthday => "Dec 4" })
-      MonkeyClient.all.size.should == 2
+      it "puts the record in the dirty set to be persisted to the databse the next time it polls" do
+        Tractor::Model::Game.all.size.should == 0
+        game = Tractor::Model::Game.new({ :id => '1', :board => "small" })
+        game.save
+      
+        Tractor.redis.smembers("Tractor::Model::Dirty:all").should include("Tractor::Model::Game,1")
+      end
     end
     
-    it "each class only tracks their own" do
-      MonkeyClient.all.size.should == 0
-      BananaClient.all.size.should == 0
+    describe ".all" do
+      it "every object that is created for this class will be in this set" do
+        MonkeyClient.all.size.should == 0
+        MonkeyClient.create({ :id => 'a1a', :evil => true, :birthday => "Dec 3" })
+        MonkeyClient.create({ :id => 'b1b', :evil => false, :birthday => "Dec 4" })
+        MonkeyClient.all.size.should == 2
+      end
+    
+      it "each class only tracks their own" do
+        MonkeyClient.all.size.should == 0
+        BananaClient.all.size.should == 0
       
-      MonkeyClient.create({ :id => 'a1a', :evil => true, :birthday => "Dec 3" })
-      BananaClient.create({ :id => 'a1a', :name => "delicious" })
+        MonkeyClient.create({ :id => 'a1a', :evil => true, :birthday => "Dec 3" })
+        BananaClient.create({ :id => 'a1a', :name => "delicious" })
       
-      MonkeyClient.all.size.should == 1
-      BananaClient.all.size.should == 1
+        MonkeyClient.all.size.should == 1
+        BananaClient.all.size.should == 1
+      end
+    
+      it "returns the entire instance of a given object" do
+        MonkeyClient.create({ :id => 'a1a', :evil => true, :birthday => "Dec 3" })
+        MonkeyClient.all[0].birthday.should == "Dec 3"
+      end
     end
+  
+    describe ".ids" do
+      before do
+        Sammich.create({ :id => 's1', :weight => "medium", :product => "Turkey Avocado" })
+        Sammich.create({ :id => 's2', :weight => "medium", :product => "Reuben Sammich" })
+      end
     
-    it "returns the entire instance of a given object" do
-      MonkeyClient.create({ :id => 'a1a', :evil => true, :birthday => "Dec 3" })
-      MonkeyClient.all[0].birthday.should == "Dec 3"
+      it "returns all the ids for a given class" do
+        Sammich.ids.should == ['s1', 's2']
+      end
     end
-  end
   
-  describe ".ids" do
-    before do
-      Sammich.create({ :id => 's1', :weight => "medium", :product => "Turkey Avocado" })
-      Sammich.create({ :id => 's2', :weight => "medium", :product => "Reuben Sammich" })
+    describe ".count" do
+      before do
+        Sammich.create({ :id => 's1', :weight => "medium", :product => "Turkey Avocado" })
+        Sammich.create({ :id => 's2', :weight => "medium", :product => "Reuben Sammich" })
+      end
+    
+      it "returns the count of all items of a given class" do
+        Sammich.count.should == 2
+      end
     end
     
-    it "returns all the ids for a given class" do
-      Sammich.ids.should == ['s1', 's2']
+    describe "after_create" do
+      before do
+        class Callbackinator
+          after_create :reverse_name
+          
+          def reverse_name
+            self.name = self.name.reverse
+            self.save
+          end
+        end
+      end
+      
+      it "adds a method to be called after an instance is created" do
+        obj = Callbackinator.create(:name => "asdf", :id => 1)
+        obj.name.should == "fdsa"
+      end
     end
-  end
-  
-  describe ".count" do
-    before do
-      Sammich.create({ :id => 's1', :weight => "medium", :product => "Turkey Avocado" })
-      Sammich.create({ :id => 's2', :weight => "medium", :product => "Reuben Sammich" })
+    
+    describe "after_save" do
+      before do
+        class Callbackinator
+          after_save :duplicate_name
+          
+          def duplicate_name
+            self.name = self.name*2
+          end
+        end
+      end
+      
+      it "adds a method to be called after an instance is created" do
+        obj = Callbackinator.new(:name => "asdf", :id => 1)
+        obj.save
+        obj.name.should == "asdfasdf"
+      end
     end
     
-    it "returns the count of all items of a given class" do
-      Sammich.count.should == 2
+    describe "after_destroy" do
+      before do
+        class Callbackinator
+          after_destroy :put_something_in_redis
+          
+          def put_something_in_redis
+            Tractor.redis["something_in_redis"] = "thanks!"
+          end
+        end
+      end
+      
+      it "adds a method to be called after an instance is destroyed" do
+        obj = Callbackinator.create(:name => "asdf", :id => 1)
+        Tractor.redis["something_in_redis"].should be_nil
+        obj.destroy
+        Tractor.redis["something_in_redis"].should == "thanks!"
+      end
     end
-  end
   
-  describe "#create" do
-    it "allows you to specify which attributes should be unique"
+    describe ".create" do
+      it "allows you to specify which attributes should be unique"
 
-    it "raises exception if the id exists" do
-      MonkeyClient.create({ :id => 'a1a', :evil => true, :birthday => "Dec 3" })
-      lambda do
-        MonkeyClient.create({ :id => 'a1a', :evil => false, :birthday => "Jan 4" })
-      end.should raise_error(Tractor::DuplicateKeyError, "Duplicate value for MonkeyClient 'id'")
-    end
+      it "raises exception if the id exists" do
+        MonkeyClient.create({ :id => 'a1a', :evil => true, :birthday => "Dec 3" })
+        lambda do
+          MonkeyClient.create({ :id => 'a1a', :evil => false, :birthday => "Jan 4" })
+        end.should raise_error(Tractor::DuplicateKeyError, "Duplicate value for MonkeyClient 'id'")
+      end
     
-    it "should write attributes to redis" do
-      sammich = Sammich.create({ :id => '1', :product => "Veggie Sammich" })
-      redis_sammich = Tractor.redis.mapped_hmget("Sammich:1", "id", "product")
-      redis_sammich["id"].should == "1"
-      redis_sammich["product"].should == "Veggie Sammich"
-    end
+      it "should write attributes to redis" do
+        sammich = Sammich.create({ :id => '1', :product => "Veggie Sammich" })
+        redis_sammich = Tractor.redis.mapped_hmget("Sammich:1", "id", "product")
+        redis_sammich["id"].should == "1"
+        redis_sammich["product"].should == "Veggie Sammich"
+      end
     
-    it "populates all the indices that are specified on the class" do
-      Sammich.create({ :id => '1', :weight => "heavy", :product => "Ham Sammich" })
-      Sammich.create({ :id => '2', :weight => "heavy", :product => "Tuna Sammich" })
+      it "populates all the indices that are specified on the class" do
+        Sammich.create({ :id => '1', :weight => "heavy", :product => "Ham Sammich" })
+        Sammich.create({ :id => '2', :weight => "heavy", :product => "Tuna Sammich" })
   
-      redis.smembers("Sammich:product:SGFtIFNhbW1pY2g=").should include('1')
-      redis.smembers("Sammich:product:VHVuYSBTYW1taWNo").should include('2')
-      redis.smembers("Sammich:weight:aGVhdnk=").should == ['1', '2']
-    end
+        redis.smembers("Sammich:product:SGFtIFNhbW1pY2g=").should include('1')
+        redis.smembers("Sammich:product:VHVuYSBTYW1taWNo").should include('2')
+        redis.smembers("Sammich:weight:aGVhdnk=").should == ['1', '2']
+      end
     
-    it "returns the instance that has been created" do
-      sammich = Sammich.create({ :id => '1', :weight => "heavy", :product => "Tuna Melt" })
-      sammich.weight.should == "heavy"
+      it "returns the instance that has been created" do
+        sammich = Sammich.create({ :id => '1', :weight => "heavy", :product => "Tuna Melt" })
+        sammich.weight.should == "heavy"
+      end
     end
-  end
   
-  describe ".exists?" do
-    it "returns true if the object with the given id exists" do
-      MonkeyClient.create({ :id => 'a1a', :evil => true, :birthday => "Dec 3" })
-      MonkeyClient.exists?('a1a').should be_true
-    end
+    describe ".exists?" do
+      it "returns true if the object with the given id exists" do
+        MonkeyClient.create({ :id => 'a1a', :evil => true, :birthday => "Dec 3" })
+        MonkeyClient.exists?('a1a').should be_true
+      end
     
-    it "returns false if the object with the given id does not exist" do
-      MonkeyClient.exists?('a1a').should be_false
+      it "returns false if the object with the given id does not exist" do
+        MonkeyClient.exists?('a1a').should be_false
+      end
     end
-  end
   
-  describe ".find_by_id" do
-    it "takes an id and returns the object from redis" do
-      sammich = Sammich.create({ :id => '1', :product => "Cold Cut Trio" })
+    describe ".find_by_id" do
+      it "takes an id and returns the object from redis" do
+        sammich = Sammich.create({ :id => '1', :product => "Cold Cut Trio" })
       
-      redis_sammich = Sammich.find_by_id('1')
-      redis_sammich.product.should == "Cold Cut Trio"
-    end
+        redis_sammich = Sammich.find_by_id('1')
+        redis_sammich.product.should == "Cold Cut Trio"
+      end
     
-    it "returns nil if the keys do not exist in redis" do
-      Sammich.find_by_id('1').should be_nil
+      it "returns nil if the keys do not exist in redis" do
+        Sammich.find_by_id('1').should be_nil
+      end
     end
-  end
   
-  describe "#update" do
-    attr_reader :sammich
+    describe "#update" do
+      attr_reader :sammich
     
-    before do
-      @sammich = Sammich.create({ :id => '1', :weight => "medium", :product => "Turkey Avocado" })
-    end
+      before do
+        @sammich = Sammich.create({ :id => '1', :weight => "medium", :product => "Turkey Avocado" })
+      end
         
-    it "updates the item from redis" do
-      @sammich.update( {:weight => "heavy"} )
-      @sammich.weight.should == "heavy"
-    end
+      it "updates the item from redis" do
+        @sammich.update( {:weight => "heavy"} )
+        @sammich.weight.should == "heavy"
+      end
     
-    it "does not update the id" do
-      @sammich.update( {:id => "111111"} )
-      @sammich.id.should == "1"
-    end
+      it "does not update the id" do
+        @sammich.update( {:id => "111111"} )
+        @sammich.id.should == "1"
+      end
     
-    it "only changes attributes passed in" do
-      @sammich.update( {:weight => "light"} )
-      @sammich.id.should == "1"
-      @sammich.weight.should == "light"
-      @sammich.product.should == "Turkey Avocado"
-    end
+      it "only changes attributes passed in" do
+        @sammich.update( {:weight => "light"} )
+        @sammich.id.should == "1"
+        @sammich.weight.should == "light"
+        @sammich.product.should == "Turkey Avocado"
+      end
     
-    it "updates all the indices associated with this object" do
-      Sammich.find( {:weight => "light"} ).should be_empty
-      Sammich.find( {:weight => "medium"} ).should_not be_empty
-      sammich.update( {:weight => "light"} )
-      Sammich.find( {:weight => "light"} ).should_not be_empty
-      Sammich.find( {:weight => "medium"} ).should be_empty
-    end
+      it "updates all the indices associated with this object" do
+        Sammich.find( {:weight => "light"} ).should be_empty
+        Sammich.find( {:weight => "medium"} ).should_not be_empty
+        sammich.update( {:weight => "light"} )
+        Sammich.find( {:weight => "light"} ).should_not be_empty
+        Sammich.find( {:weight => "medium"} ).should be_empty
+      end
     
-    it "raises if object has not been saved yet"
-  end
+      it "raises if object has not been saved yet"
+    end
   
-  describe "#destroy" do
-    attr_reader :cheese, :balogna
+    describe "#destroy" do
+      attr_reader :cheese, :balogna
     
-    before do
-      @cheese = Sammich.create({ :id => '1', :weight => "medium", :product => "Cheese Sammich" })
-      @balogna = Sammich.create({ :id => '2', :weight => "medium", :product => "Balogna Sammich" })
-    end
+      before do
+        @cheese = Sammich.create({ :id => '1', :weight => "medium", :product => "Cheese Sammich" })
+        @balogna = Sammich.create({ :id => '2', :weight => "medium", :product => "Balogna Sammich" })
+      end
     
-    it "removes the item from redis" do
-      @cheese.destroy
-      Sammich.find_by_id(cheese.id).should be_nil
-    end
+      it "removes the item from redis" do
+        @cheese.destroy
+        Sammich.find_by_id(cheese.id).should be_nil
+      end
     
-    it "removes the id from the all index" do
-      Sammich.all.map{|t| t.id }.should == ["1", "2"]
-      cheese.destroy
-      Sammich.all.map{|t| t.id }.should == ["2"]
-    end
+      it "removes the id from the all index" do
+        Sammich.all.map{|t| t.id }.should == ["1", "2"]
+        cheese.destroy
+        Sammich.all.map{|t| t.id }.should == ["2"]
+      end
     
-    it "removes the id from all of it's other indices" do
-      Sammich.find({ :weight => "medium" }).size.should == 2
-      cheese.destroy
-      Sammich.find({ :weight => "medium" }).size.should == 1
-    end
+      it "removes the id from all of it's other indices" do
+        Sammich.find({ :weight => "medium" }).size.should == 2
+        cheese.destroy
+        Sammich.find({ :weight => "medium" }).size.should == 1
+      end
     
-    it "removes the id from all of the associations that it may be in" do
-      bocci_ball = Tractor::Model::Game.create({ :id => "bocci_ball" })
-      tobias = Tractor::Model::Player.create({ :id => "tobias", :name => "deciduous", :game_id => "bocci_ball" })
-      bocci_ball.players.ids.should == ["tobias"]
-      tobias.destroy
+      it "removes the id from all of the associations that it may be in" do
+        bocci_ball = Tractor::Model::Game.create({ :id => "bocci_ball" })
+        tobias = Tractor::Model::Player.create({ :id => "tobias", :name => "deciduous", :game_id => "bocci_ball" })
+        bocci_ball.players.ids.should == ["tobias"]
+        tobias.destroy
       
-      bocci_ball.players.ids.should == []
+        bocci_ball.players.ids.should == []
+      end
     end
-  end
   
-  describe ".find" do
-    attr_reader :cheese, :balogna
+    describe ".find" do
+      attr_reader :cheese, :balogna
     
-    before do
-      @cheese   = Sammich.create({ :id => '1', :weight => "medium", :product => "Cheese Sammich" })
-      @balogna  = Sammich.create({ :id => '2', :weight => "medium", :product => "Balogna Sammich" })
-      @meat   = Sammich.create({ :id => '3', :weight => "heavy", :product => "Meat & More Sammich" })
-    end
+      before do
+        @cheese   = Sammich.create({ :id => '1', :weight => "medium", :product => "Cheese Sammich" })
+        @balogna  = Sammich.create({ :id => '2', :weight => "medium", :product => "Balogna Sammich" })
+        @meat   = Sammich.create({ :id => '3', :weight => "heavy", :product => "Meat & More Sammich" })
+      end
     
-    context "when searching on 1 attribute" do
-      it "returns all matching products" do
-        redis_cheese, redis_balogna = Sammich.find( {:weight => "medium" } )
+      context "when searching on 1 attribute" do
+        it "returns all matching products" do
+          redis_cheese, redis_balogna = Sammich.find( {:weight => "medium" } )
         
-        redis_cheese.id.should == cheese.id
-        redis_cheese.product.should == cheese.product
-        redis_balogna.id.should == balogna.id
-        redis_balogna.product.should == balogna.product
+          redis_cheese.id.should == cheese.id
+          redis_cheese.product.should == cheese.product
+          redis_balogna.id.should == balogna.id
+          redis_balogna.product.should == balogna.product
+        end
       end
-    end
     
-    context "when searching on multiple attribute" do
-      it "returns the intersection of all matching objects" do
-        sammiches = Sammich.find( {:weight => "medium", :product => "Cheese Sammich" } )
-        sammiches.size.should == 1
-        sammiches[0].id.should == "1"
-        sammiches[0].product.should == "Cheese Sammich"
+      context "when searching on multiple attribute" do
+        it "returns the intersection of all matching objects" do
+          sammiches = Sammich.find( {:weight => "medium", :product => "Cheese Sammich" } )
+          sammiches.size.should == 1
+          sammiches[0].id.should == "1"
+          sammiches[0].product.should == "Cheese Sammich"
+        end
       end
-    end
     
-    it "returns empty array if no options are given" do
-      Sammich.find({}).should == []
-    end
+      it "returns empty array if no options are given" do
+        Sammich.find({}).should == []
+      end
     
-    it "returns empty array if nothing matches the given options" do
-      Sammich.find( {:weight => "light" } ).should == []
-    end
+      it "returns empty array if nothing matches the given options" do
+        Sammich.find( {:weight => "light" } ).should == []
+      end
     
-    it "returns all matching objects if multiple values are given for an attribute" do
-      Sammich.find( {:weight => ["medium", "heavy"]} ).map(&:id).sort.should == ['1','2','3']
+      it "returns all matching objects if multiple values are given for an attribute" do
+        Sammich.find( {:weight => ["medium", "heavy"]} ).map(&:id).sort.should == ['1','2','3']
+      end
     end
-  end
   
-  describe ".find_by_attribute" do
-    it "raises if index does not exist for given key" do
-      lambda do
-        Sammich.find_by_attribute(:expensive, true)
-      end.should raise_error(Tractor::MissingIndexError, "No index on 'expensive'")
-    end
+    describe ".find_by_attribute" do
+      it "raises if index does not exist for given key" do
+        lambda do
+          Sammich.find_by_attribute(:expensive, true)
+        end.should raise_error(Tractor::MissingIndexError, "No index on 'expensive'")
+      end
     
-    it "takes an index name and value and finds all matching objects" do
-      meat_supreme = Sammich.create({ :id => '1', :weight => "heavy", :product => "Meat Supreme" })
-      bacon_with_bacon = Sammich.create({ :id => '2', :weight => "heavy", :product => "Bacon with extra Bacon" })
+      it "takes an index name and value and finds all matching objects" do
+        meat_supreme = Sammich.create({ :id => '1', :weight => "heavy", :product => "Meat Supreme" })
+        bacon_with_bacon = Sammich.create({ :id => '2', :weight => "heavy", :product => "Bacon with extra Bacon" })
     
-      redis_meat_supreme, redis_bacon_with_bacon = Sammich.find_by_attribute(:weight, "heavy")
-      redis_meat_supreme.id.should == meat_supreme.id
-      redis_meat_supreme.weight.should == meat_supreme.weight
-      redis_meat_supreme.product.should == meat_supreme.product
+        redis_meat_supreme, redis_bacon_with_bacon = Sammich.find_by_attribute(:weight, "heavy")
+        redis_meat_supreme.id.should == meat_supreme.id
+        redis_meat_supreme.weight.should == meat_supreme.weight
+        redis_meat_supreme.product.should == meat_supreme.product
       
-      redis_bacon_with_bacon.id.should == bacon_with_bacon.id
-      redis_bacon_with_bacon.weight.should == bacon_with_bacon.weight
-      redis_bacon_with_bacon.product.should == bacon_with_bacon.product
-    end
+        redis_bacon_with_bacon.id.should == bacon_with_bacon.id
+        redis_bacon_with_bacon.weight.should == bacon_with_bacon.weight
+        redis_bacon_with_bacon.product.should == bacon_with_bacon.product
+      end
     
-    it "returns nil if nothing matches" do
-      Sammich.find_by_attribute(:weight, "heavy").should == []
+      it "returns nil if nothing matches" do
+        Sammich.find_by_attribute(:weight, "heavy").should == []
+      end
+    end
+  
+    describe ".to_h" do
+      it "returns the attributes for a mapped object in a hash" do
+        chicken = Sammich.create({ :id => '1', :weight => "heavy", :product => "Chicken" })
+      
+        chicken = Sammich.find_by_id('1')
+        hashed_attributes = chicken.to_h
+        hashed_attributes[:id].should == "1"
+        hashed_attributes[:weight].should == "heavy"
+        hashed_attributes[:product].should == "Chicken"
+      end
     end
   end
   
-  describe ".to_h" do
-    it "returns the attributes for a mapped object in a hash" do
-      chicken = Sammich.create({ :id => '1', :weight => "heavy", :product => "Chicken" })
+  describe Tractor::Model::Dirty do
+    describe ".objectify" do
+      before do
+        chicken = Sammich.create({ :id => '1', :weight => "heavy", :product => "Chicken" })
+        lettuce = Sammich.create({ :id => '2', :weight => "light", :product => "Lettuce" })
+        Tractor.redis.scard("Tractor::Model::Dirty:all").should == 2
+      end
       
-      chicken = Sammich.find_by_id('1')
-      hashed_attributes = chicken.to_h
-      hashed_attributes[:id].should == "1"
-      hashed_attributes[:weight].should == "heavy"
-      hashed_attributes[:product].should == "Chicken"
+      it "iterates over all dirty records and returns important information and removes the record" do        
+        result = Tractor::Model::Dirty.all do |obj|
+          if obj[:id] == '1'
+            obj[:id].should == '1'
+            obj[:klass].should == 'Sammich'
+            obj[:data][:weight].should == 'heavy'
+          else
+            obj[:id].should == '2'
+            obj[:klass].should == 'Sammich' 
+            obj[:data][:weight].should == 'light'
+          end
+        end
+        
+        Tractor.redis.scard("Tractor::Model::Dirty:all").should == 0
+      end
+      it "does not remove the record from the dirty list if something goes wrong" do
+        result = Tractor::Model::Dirty.all do |obj|
+          if obj[:id] == '1'
+            raise 'wuh-oh'
+          else
+            # persist to the database or something else cool
+          end
+        end
+        
+        Tractor.redis.smembers("Tractor::Model::Dirty:all").should == ['Sammich,1']
+        Tractor.redis.scard("Tractor::Model::Dirty:all").should == 1
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -13,6 +13,11 @@ Spec::Runner.configure do |config|
   end
 end
 
+class Callbackinator < Tractor::Model::Base
+  attribute :id
+  attribute :name
+end
+
 class Sammich < Tractor::Model::Base
   attribute :id
   attribute :product

data/tractor.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{tractor}
-  s.version = "0.4.9"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Shane Wolf"]
-  s.date = %q{2011-01-06}
+  s.date = %q{2011-01-07}
   s.description = %q{Very simple object mappings for ruby objects}
   s.email = %q{shanewolf@gmail.com}
   s.extra_rdoc_files = [
@@ -25,6 +25,7 @@ Gem::Specification.new do |s|
     "lib/tractor.rb",
     "lib/tractor/model/base.rb",
     "lib/tractor/model/mapper.rb",
+    "performance/dirty.rb",
     "performance/test.rb",
     "spec/model/base_spec.rb",
     "spec/model/mapper_spec.rb",

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: tractor
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 11
   prerelease: false
   segments: 
   - 0
-  - 4
-  - 9
-  version: 0.4.9
+  - 5
+  - 0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Shane Wolf
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-06 00:00:00 -08:00
+date: 2011-01-07 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -52,6 +52,7 @@ files:
 - lib/tractor.rb
 - lib/tractor/model/base.rb
 - lib/tractor/model/mapper.rb
+- performance/dirty.rb
 - performance/test.rb
 - spec/model/base_spec.rb
 - spec/model/mapper_spec.rb