class ActiveRecord::Base

def self.synchronize(instances, keys=[self.primary_key])


posts.first.address # => "1245 Foo Ln" instead of whatever it was
Post.synchronize posts, [:name] # queries on the :name column and not the :id column
<.. out of system changes occur to change the address of author 'Zach' to 1245 Foo Ln ..>
posts = Post.find_by_author("Zach")
# Synchronizing using custom key fields

posts.first.author # => "Zachary" instead of Zach
Post.synchronize posts
<.. out of system changes occur to change author name from Zach to Zachary..>
posts = Post.find_by_author("Zach")
# Synchronizing existing models by matching on the primary key field
== Examples

instances rather sending one query for each instance
This uses one query for all instance updates and then updates existing

ActiveRecord instance but it is intended for use on multiple instances.
from the database. This is like calling reload on an individual
Synchronizes the passed in ActiveRecord instances with data 
def self.synchronize(instances, keys=[self.primary_key])
  return if instances.empty?
  conditions = {}
  order = ""
  
  key_values = keys.map { |key| instances.map(&"#{key}".to_sym) }
  keys.zip(key_values).each { |key, values| conditions[key] = values }
  order = keys.map{ |key| "#{key} ASC" }.join(",")
  
  klass = instances.first.class
  fresh_instances = klass.find( :all, :conditions=>conditions, :order=>order )
  instances.each do |instance|
    matched_instance = fresh_instances.detect do |fresh_instance|
      keys.all?{ |key| fresh_instance.send(key) == instance.send(key) }
    end
    
    if matched_instance
      instance.clear_aggregation_cache
      instance.clear_association_cache
      instance.instance_variable_set '@attributes', matched_instance.attributes
      # Since the instance now accurately reflects the record in
      # the database, ensure that instance.persisted? is true.
      instance.instance_variable_set '@new_record', false
      instance.instance_variable_set '@destroyed', false
    end
  end
end