HasRemote 0.1.4 → 0.1.5

data/HasRemote.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{HasRemote}
-  s.version = "0.1.4"
+  s.version = "0.1.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Sjoerd Andringa"]
-  s.date = %q{2010-01-25}
+  s.date = %q{2010-02-18}
   s.description = %q{Bind a remote ActiveResource object to your local ActiveRecord objects, delegate attributes and optionally cache remote attributes locally.}
   s.email = %q{sjoerd.andringa@innovationfactory.eu}
   s.extra_rdoc_files = [

data/README.rdoc

@@ -106,7 +106,7 @@ Synchronize all records of one specific model:
  User.synchronize!
 
 The latter automatically requests all remote resources that have been changed (including new and deleted records) since the last successful synchronization for this particular model.
-You may need to override the <tt>changed_remotes_since</tt> class method in your model to match your host's REST API.
+You may need to override the <tt>updated_remotes</tt> class method in your model to match your host's REST API.
 
 See <tt>HasRemote::Synchronizable</tt> for more information.
 
@@ -124,6 +124,9 @@ To specify additional parameters to send with the request that fetches updated r
 
  rake hr:sync PARAMS="since=01-01-2010&limit=25"
 
+(If you've overridden the <tt>updated_remotes</tt> class method on one of your synchronizable models, then note that these parameters are
+passed in as a hash to <tt>updated_remotes</tt> internally.)
+
 === Documentation
 
 To generate RDocs for this plugin, from the has_remote directory run:
@@ -146,4 +149,4 @@ To run the specs of the plugin, from the has_remote directory run:
 Questions, requests and patches can be directed to sjoerd.andringa[AT]innovationfactory[DOT]nl.
 
 
-Copyright (c) 2009 Innovation Factory.
+Copyright (c) 2009-2010 Innovation Factory.

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.1.5

data/generators/has_remote_migration/templates/create_has_remote_synchronizations.erb

@@ -2,7 +2,8 @@ class CreateHasRemoteSynchronizations < ActiveRecord::Migration
   def self.up
     create_table :has_remote_synchronizations do |t|
       t.string :model_name, :null => false
-      t.datetime :latest_change, :null => false
+      t.datetime :last_record_updated_at, :null => false
+      t.integer :last_record_id, :null => false
       t.datetime :created_at
     end
   end

data/lib/has_remote/synchronizable.rb

@@ -36,25 +36,25 @@ module HasRemote
     # time is given. This may include new and optionally deleted (tagged by a 'deleted_at' attribute) resources.
     #
     # This is used by the <tt>synchronize!</tt> class method. By default
-    # it queries '/updated?since=<time>' on your resources URL, where 'time' is
-    # the latest updated_at time of the last processed remote objects.
+    # it queries '/updated?since=<time>&last_record_id=<id>' on your resources URL, where 'time' is
+    # the updated_at value of the last processed remote object and 'last_record_id' is its id.
+    #
+    # *Options*
+    #
+    # The options passed in to <tt>synchronize!</tt> will be passed through to <tt>updated_remotes</tt>.
+    # By default they are used as request parameters for remotely requesting the updated records.
     #
     # You may need to override this method in your model to match your host's REST API or to change
     # the default time, e.g.:
     #
-    #  def self.changed_remotes_since(time = nil)
-    #    time ||= 12.hours.ago
-    #    User::Remote.find :all, :from => :search, :params => {:updated_since => time.strftime('...') }
+    #  def self.updated_remotes(options = nil)
+    #    time = last_synchronization.try(:last_record_updated_at) || 12.hours.ago
+    #    User::Remote.find :all, :from => :search, :params => { :updated_since => time.to_s(:db) }
     #  end
     #
-    # *Arguments*
-    #
-    # [<tt>time</tt>:] The given time that defines since (see above)
-    # [<tt>params</tt>:] Optional hash of additional parameters to send with the request (e.g. {:limit =>  5})
-    #
-    def changed_remotes_since(time = nil, params = {})
-      time ||= 1.week.ago
-      remote_class.find :all, :from => :updated, :params => {:since => time.to_s}.merge(params)
+    def updated_remotes( options = {} )
+      time = last_synchronization.try(:last_record_updated_at) || 1.week.ago
+      remote_class.find :all, :from => :updated, :params => { :since => time.to_s, :last_record_id => last_synchronization.try(:last_record_id) }.merge( options )
     end
 
     # Will update all records that have been created, updated or deleted on the remote host
@@ -62,15 +62,14 @@ module HasRemote
     #
     # *Options*
     #
-    # [<tt>since</tt>:] Optionally override the time as of which updated resources are fetched. Also see <tt>changes_remotes_since</tt>.
-    #
-    # All other options are passed in as parameters to <tt>changes_remotes_since</tt>.
+    # Options are passed through to <tt>updated_remotes</tt> which is called in order to fetch the updated records.
+    # Use this if you want to override its default options.
     #
     def synchronize!(options = {})
       logger.info( "*** Start synchronizing #{table_name} at #{Time.now.to_s :long} ***\n" )
       @sync_count = 0
       begin
-        changed_objects = changed_remotes_since( options.delete(:since) || synchronized_at, options )
+        changed_objects = updated_remotes( options )
         if changed_objects.any?
           # Do everything within transaction to prevent ending up in half-synchronized situation if an exception is raised.
           transaction { sync_all_records_for(changed_objects) }
@@ -80,25 +79,25 @@ module HasRemote
       rescue => e
         logger.warn( " - Synchronization of #{table_name} failed: #{e} \n #{e.backtrace}" )
       else
-        self.synchronized_at = changed_objects.map { |o| time_of_update(o) }.sort.last if changed_objects.any?
+        if changed_objects.any?
+          last_record_updated_at = time_updated(changed_objects.last)
+          last_record_id = changed_objects.last.send(remote_primary_key)
+          HasRemote::Synchronization.create!(:model_name => self.name, :last_record_updated_at => last_record_updated_at, :last_record_id => last_record_id)
+        end
         logger.info( " - Synchronized #{@sync_count} #{table_name}.\n" ) if @sync_count > 0
       ensure
         logger.info( "*** Stopped synchronizing #{table_name} at #{Time.now.to_s :long} ***\n" )
       end
     end
 
-    # Time of the last successful synchronization.
+    # The last successful synchronization for this model.
     #
-    def synchronized_at
-      HasRemote::Synchronization.for(self.name).latest_change
+    def last_synchronization
+      HasRemote::Synchronization.for(self.name).last
     end
 
   private
 
-    def synchronized_at=(time) #:nodoc:
-      HasRemote::Synchronization.create!(:model_name => self.name, :latest_change => time)
-    end
-
     def sync_all_records_for(resources) #:nodoc:
       resources.each { |resource| sync_all_records_for_resource(resource) }
     end
@@ -143,7 +142,7 @@ module HasRemote
       update_and_save_record_for_resource(new(remote_foreign_key => resource.send(remote_primary_key)), resource)
     end
 
-    def time_of_update(resource)
+    def time_updated(resource)
       (resource.respond_to?(:deleted_at) && resource.deleted_at) ? resource.deleted_at : resource.updated_at
     end
 

data/lib/has_remote/synchronization.rb

@@ -1,15 +1,11 @@
 module HasRemote
-  
+
   class Synchronization < ActiveRecord::Base #:nodoc:
     set_table_name 'has_remote_synchronizations'
-    
-    named_scope :for, lambda { |model_name| {:conditions => ["model_name = ?", model_name.to_s.classify] } } do
-      def latest_change
-        self.find(:first, :order => 'latest_change DESC').latest_change rescue nil
-      end
-    end
-    
-    validates_presence_of :model_name, :latest_change
+
+    named_scope :for, lambda { |model_name| {:conditions => ["model_name = ?", model_name.to_s.classify] } }
+
+    validates_presence_of :model_name, :last_record_updated_at, :last_record_id
   end
-  
+
 end

data/lib/has_remote/tasks.rb

@@ -2,7 +2,7 @@ namespace :hr do
 
   desc 'Synchronizes all attributes locally cached by has_remote'
   task :sync => :environment do
-    models = ENV['MODELS'].nil? ? HasRemote.models : extract_models
+    models = ENV['MODELS'] ? extract_models : HasRemote.models
     options = ENV['PARAMS'] ? Rack::Utils.parse_query(ENV['PARAMS']) : {}
     models.each{|model| model.synchronize!(options)}
   end

data/spec/caching_spec.rb

@@ -1,108 +1,112 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 
 context "Given existing remote resources" do
-  
+
   before(:each) do
     User.delete_all
     stub_resource 1, :email => "joeremote@foo.bar"
     stub_resource 2, :email => "jane_remote@foo.bar"
   end
-  
+
   describe "a user" do
-    
+
     it "should return cached attributes" do
       User.should respond_to(:cached_attributes)
       User.cached_attributes.should include(:email)
     end
-    
+
     it "should return changed remotes since yesterday" do
       user_1, user_2 = mock(:user), mock(:user)
       time = 1.day.ago
-      User::Remote.should_receive(:find).with(:all,{:from => :updated, :params=>{:since=>time.to_s}}).once.and_return([user_1, user_2])
-      
-      User.should respond_to(:changed_remotes_since)
-      User.changed_remotes_since(time).should include(user_1, user_2)
+      User::Remote.should_receive(:find).with(:all,{:from => :updated, :params=>{:since=>time.to_s, :last_record_id=>nil}}).once.and_return([user_1, user_2])
+
+      User.should respond_to(:updated_remotes)
+      User.updated_remotes(:since => time.to_s).should include(user_1, user_2)
     end
-    
-    it "should find last synchronization time" do
+
+    it "should find last synchronization" do
       times = []
-      1.upto(3) do |i|
-        times << i.days.ago
-        HasRemote::Synchronization.create(:model_name => 'HasRemoteSpec::User', :latest_change => times.last)
+      3.downto(1) do |i|
+        HasRemote::Synchronization.create(:model_name => 'HasRemoteSpec::User', :last_record_updated_at => i.days.ago, :last_record_id => i)
       end
-      User.should respond_to(:synchronized_at)
-      User.synchronized_at.to_s.should == times.first.to_s
+      User.should respond_to(:last_synchronization)
+      sync = User.last_synchronization
+      sync.last_record_updated_at.to_s.should == 1.day.ago.to_s
+      sync.last_record_id.should == 1
     end
-        
+
     it "should not delegate cached remote attributes" do
       user = User.create! :remote_id => 1
       User::Remote.should_not_receive(:find)
       user.email.should == "joeremote@foo.bar"
     end
-    
+
     it "should update its cached remote attributes on save" do
       user = User.create! :remote_id => 1
       user[:email].should == "joeremote@foo.bar"
       user.update_attributes(:remote_id => 2)
-      user[:email].should == "jane_remote@foo.bar"   
+      user[:email].should == "jane_remote@foo.bar"
     end
 
     it "should not update its cached remote attributes if skip_update_cache is true" do
       user = User.create! :remote_id => 1, :skip_update_cache => true
       user[:email].should == nil
     end
-    
+
   end
 
   describe "synchronization" do
-  
+
     describe "for the User model" do
-    
+
       describe "with updated and deleted remotes" do
-        
+
         before(:each) do
-          @user_1, @user_2, @user_3 = User.create!(:remote_id => 1), User.create!(:remote_id => 2), User.create!(:remote_id => 3)
-        
           @yesterday = DateTime.parse 1.day.ago.to_s
-        
+          @last_id   = 5
+          @user_1, @user_2, @user_3 = User.create!(:remote_id => @last_id), User.create!(:remote_id => 1), User.create!(:remote_id => 2)
+
           resources = [
-            mock(:user, :id => 1, :email => "changed@foo.bar", :updated_at => @yesterday),
-            mock(:user, :id => 2, :email => "altered@foo.bar", :updated_at => 2.days.ago, :deleted_at => nil),
-            mock(:user, :id => 3, :email => "deleted@foo.bar", :updated_at => 2.days.ago, :deleted_at => 2.days.ago),
+            mock(:user, :id => 1, :email => "altered@foo.bar", :updated_at => 2.days.ago, :deleted_at => nil),
+            mock(:user, :id => 2, :email => "deleted@foo.bar", :updated_at => 2.days.ago, :deleted_at => 2.days.ago),
+            mock(:user, :id => 3, :email => "new-deleted@foo.bar", :updated_at => 2.days.ago, :deleted_at => 2.days.ago),
             mock(:user, :id => 4, :email => "new@foo.bar", :updated_at => @yesterday),
-            mock(:user, :id => 5, :email => "new-deleted@foo.bar", :updated_at => 2.days.ago, :deleted_at => 2.days.ago),
+            mock(:user, :id => @last_id, :email => "changed@foo.bar", :updated_at => @yesterday)
           ]
-          User.stub!(:changed_remotes_since).and_return(resources)
-        
+          User.stub!(:updated_remotes).and_return(resources)
+
           lambda { User.synchronize! }.should change(HasRemote::Synchronization, :count).by(1)
         end
-        
-        it "should keep track of the last synchronization" do
-          HasRemote::Synchronization.for("HasRemoteSpec::User").latest_change.should == @yesterday
+
+        it "should keep track of the last synchronized record" do
+          sync = HasRemote::Synchronization.for("HasRemoteSpec::User").last
+
+          sync.last_record_updated_at.should == @yesterday
+          sync.last_record_id.should == @last_id
         end
-    
+
         it "should update changed users" do
           @user_1.reload[:email].should == "changed@foo.bar"
           @user_2.reload[:email].should == "altered@foo.bar"
         end
-      
+
         it "should destroy deleted users" do
           User.exists?(@user_3).should be_false
         end
-      
+
         it "should create added users" do
           User.exists?(:remote_id => 4).should be_true
         end
-        
+
         it "should not create deleted users" do
-          User.exists?(:remote_id => 5).should be_false
+          User.exists?(:remote_id => 3).should be_false
         end
       end
-      
+
       describe "that fails" do
-        
+
         before(:each) do
-          
+
           @failure = lambda {
             user_1, user_2 = User.create!(:remote_id => 1), User.create!(:remote_id => 2)
 
@@ -112,64 +116,64 @@ context "Given existing remote resources" do
               mock(:user, :id => 1, :email => "changed@foo.bar", :updated_at => yesterday),
               mock(:user, :id => 2, :email => "altered@foo.bar", :updated_at => 2.days.ago)
             ]
-            
-            User.stub!(:changed_remotes_since).and_return(resources)
-            
+
+            User.stub!(:updated_remotes).and_return(resources)
+
             resources.last.should_receive(:send).and_raise "All hell breaks loose" # Raise when attr is read from resource 2.
-            
+
             User.synchronize!
           }
         end
-        
+
         it "should do it silently" do
           @failure.should_not raise_error
         end
-      
+
         it "should not create a synchronization record" do
           @failure.should_not change(HasRemote::Synchronization, :count)
         end
-        
+
       end
-    
+
     end
-  
+
     describe "for a single user" do
-    
+
       it "should update the user" do
         user = User.create! :remote_id => 1
         user[:email].should == "joeremote@foo.bar"
-        
+
         stub_resource 1, :email => "changed@foo.bar"
-        
+
         user.update_cached_attributes!
         user[:email].should == "changed@foo.bar"
       end
-    
+
     end
-  
+
   end
-  
+
   describe "synchronizing new cheeses" do
     before do
       resources = [
         mock(:cheese, :id => 1, :name => "Brie", :updated_at => Date.yesterday)
       ]
-      Cheese.stub!(:changed_remotes_since).and_return(resources)
+      Cheese.stub!(:updated_remotes).and_return(resources)
       lambda{ Cheese.synchronize! }.should change(Cheese, :count).from(0).to(1)
     end
-    
+
     after { Cheese.delete_all }
-        
+
     it "should populate the local 'maturity' attribute with its default database value" do
       Cheese.first.maturity.should == 5
     end
-    
+
     it "should populate the local 'smell' attribute with the value set inside of a before_validation callback" do
-      Cheese.first.smell.should == 5 * 10 
+      Cheese.first.smell.should == 5 * 10
     end
-    
+
   end
-  
+
 end
 
 def stub_resource(id, attrs)

data/spec/schema.rb

@@ -4,22 +4,23 @@ ActiveRecord::Schema.define(:version => 0) do
   create_table :books do |t|
     t.integer :custom_remote_id
   end
-  
+
   create_table :users do |t|
     t.integer :remote_id
     t.string  :email
   end
-  
+
   create_table :products do |t|
     t.integer :remote_id
   end
 
   create_table :has_remote_synchronizations do |t|
     t.string   :model_name, :null => false
-    t.datetime :latest_change, :null => false
+    t.datetime :last_record_updated_at, :null => false
+    t.integer  :last_record_id, :null => false
     t.datetime :created_at
   end
-  
+
   create_table :cheeses do |t|
     t.string  :name
     t.integer :maturity, :default => 5

data/spec/synchronization_spec.rb

@@ -1,11 +1,12 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 
 describe HasRemote::Synchronization do
-  
+
   subject { HasRemote::Synchronization.new }
-    
+
   it { should validate_presence_of(:model_name) }
-  it { should validate_presence_of(:latest_change) }
+  it { should validate_presence_of(:last_record_updated_at) }
+  it { should validate_presence_of(:last_record_id) }
   it { should have_named_scope("for('User')") }
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: HasRemote
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors: 
 - Sjoerd Andringa
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-25 00:00:00 +01:00
+date: 2010-02-18 00:00:00 +01:00
 default_executable: 
 dependencies: []