acts_as_revisionable 1.0.6 → 1.1.0

data/README.rdoc

@@ -2,7 +2,7 @@
 
 This gem can handle automatically keeping revisions of a model each time it is updated. It is intended to allow you to keep a history of changes that can be reviewed or restored. This implementation has the advantages that it can track associations with a parent record and that it takes less space in the database to store the revisions.
 
-To make any ActiveRecord model revisionable, simply declare acts_as_revisionable in the class definition. Revisions are only added when a record is updated, so newly created records don't have revisions. This is intentional to reduce the number of revisions that need to be kept. In many applications, the majority of records are created once and never edited and adding the revision on create ends up at least doubling your storage needs. The attributes of the original record are serialized and compressed for in the revision record to minimize the amount of disk space used. Finally, you can limit the number of associations that are kept at any one time by supplying a :limit option to the acts_as_revisionable statement:
+To make any ActiveRecord model revisionable, simply declare +acts_as_revisionable+ in the class definition. Revisions are only added when a record is updated, so newly created records don't have revisions. This is intentional to reduce the number of revisions that need to be kept. In many applications, the majority of records are created once and never edited and adding the revision on create ends up at least doubling your storage needs. The attributes of the original record are serialized and compressed for in the revision record to minimize the amount of disk space used. Finally, you can limit the number of associations that are kept at any one time by supplying a <tt>:limit</tt> option to the +acts_as_revisionable+ statement:
 
   acts_as_revisionable :limit => 25
 
@@ -14,7 +14,7 @@ Revisions are accessible on a record via a has_many :revision_records associatio
 
 == Associations
 
-You can specify associations that you'd like to include in each revision by providing a list of them with the :associations key to the acts_as_revisionable options hash. You can either provide a symbol with the association name or, if you'd like to include sub-associations, a hash with the association name as the key and the value as a list of sub-associations to include. These are are valid :associations values:
+You can specify associations that you'd like to include in each revision by providing a list of them with the <tt>:associations</tt> key to the acts_as_revisionable options hash. You can either provide a symbol with the association name or, if you'd like to include sub-associations, a hash with the association name as the key and the value as a list of sub-associations to include. These are are valid :associations values:
 
   :associations => :comments  # include has_many :comments in the revision
   :associations => [:comments, :tags]  # include both :comments and :tags
@@ -24,7 +24,7 @@ You can only revision has_many, has_one, and has_and_belongs_to_many association
 
 == Storing Revisions
 
-Normally, revisions are only created when an update is done inside of a store_revision block. You can make this behavior automatic on update by specifying :on_update => true in the acts_as_revisionable call. This can be handy if you have a simple records without associations. If you do have associations in your model, you should not use this feature because you may end up revisioning associations in an indeterminate state. In this case, surround all your update statements with a store_revision block:
+Normally, revisions are only created when an update is done inside of a store_revision block. You can make this behavior automatic on update by specifying <tt>:on_update => true</tt> in the +acts_as_revisionable+ call. This can be handy if you have a simple records without associations. If you do have associations in your model, you should not use this feature because you may end up revisioning associations in an indeterminate state. In this case, surround all your update statements with a store_revision block:
 
   store_revision do
     model.update_has_many_records(params[:has_many])
@@ -49,8 +49,16 @@ To create the table structure for ActsAsRevisionable::RevisionRecord, simply add
 
   ActsAsRevisionable::RevisionRecord.create_table
 
+Note that the table definition changed from version 1.0.x to 1.1.x. If you originally created the table with version 1.0.x, you'll need to add another migration containing:
+
+  ActsAsRevisionable::RevisionRecord.update_version_1_table
+
 == Destroying
 
-By default, the revision history of a record is destroyed along with the record, you could be at risk of losing your revision history. However, this gem was developed as a companion to the acts_as_trashable[http://github.com/bdurand/acts_as_trashable] gem. With this gem, you can store destroyed records for a set period along with all dependent associations. Both gems use similar code and interfaces. It is recommended that you always use acts_as_trashable along side of acts_as_revisionable.
+By default, the revision history of a record is destroyed along with the record. If you'd like to keep the history and be able to restore deleted records, then you can specify <tt>:dependent => :keep, :on_destroy => true</tt> in options of the +acts_as_revisionable+ call. This will keep the revision records and also automatically wrap all destroy calls in a +store_revision+ block. It is highly recommended that you turn on these options.
+
+Destroyed records can be restored by restoring the last revision.
 
-Alternatively, you can specify the :dependent => :keep in options of the acts_as_revisionable call to keep all the revisions after a record is destroyed.
+  record = Model.find(100)
+  record.destroy
+  restored = Model.restore_last_revision!(100)

data/RELEASES.txt

@@ -0,0 +1,7 @@
+1.1.0
+
+- Add support for compound_primary_keys gem
+- Incorporate acts_as_trashable functionality
+- More helper functions for finding revisions from the model
+- Remove support for ActiveRecord < 2.3.5
+- Users of earlier versions will need to upgrade the table with a migration

data/Rakefile

@@ -1,6 +1,6 @@
 require 'rubygems'
 require 'rake'
-require 'rake/rdoctask'
+require 'rdoc/task'
 
 desc 'Default: run unit tests.'
 task :default => :test
@@ -33,9 +33,10 @@ begin
     gem.email = "brian@embellishedvisions.com"
     gem.homepage = "http://github.com/bdurand/acts_as_revisionable"
     gem.authors = ["Brian Durand"]
-    gem.rdoc_options = ["--charset=UTF-8", "--main", "README.rdoc"]
+    gem.rdoc_options = ["--charset=UTF-8", "--main", "README.rdoc", "MIT-LICENSE"]
     
-    gem.add_dependency('activerecord', '>= 2.2')
+    gem.add_dependency('activerecord', '>= 2.3.5')
+    gem.add_development_dependency('composite_primary_keys')
     gem.add_development_dependency('sqlite3')
     gem.add_development_dependency('rspec', '>= 2.0.0')
     gem.add_development_dependency('jeweler')

data/VERSION

@@ -1 +1 @@
-1.0.6
+1.1.0

data/acts_as_revisionable.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{acts_as_revisionable}
-  s.version = "1.0.6"
+  s.version = "1.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brian Durand"]
-  s.date = %q{2011-02-08}
+  s.date = %q{2011-06-23}
   s.description = %q{ActiveRecord extension that provides revision support so that history can be tracked and changes can be reverted. Emphasis for this plugin versus similar ones is including associations, saving on storage, and extensibility of the model.}
   s.email = %q{brian@embellishedvisions.com}
   s.extra_rdoc_files = [
@@ -18,44 +18,42 @@ Gem::Specification.new do |s|
   s.files = [
     "MIT-LICENSE",
     "README.rdoc",
+    "RELEASES.txt",
     "Rakefile",
     "VERSION",
     "acts_as_revisionable.gemspec",
     "lib/acts_as_revisionable.rb",
     "lib/acts_as_revisionable/revision_record.rb",
     "spec/acts_as_revisionable_spec.rb",
-    "spec/full_spec.rb",
     "spec/revision_record_spec.rb",
-    "spec/spec_helper.rb"
+    "spec/spec_helper.rb",
+    "spec/version_1_1_upgrade_spec.rb"
   ]
   s.homepage = %q{http://github.com/bdurand/acts_as_revisionable}
-  s.rdoc_options = ["--charset=UTF-8", "--main", "README.rdoc"]
+  s.rdoc_options = ["--charset=UTF-8", "--main", "README.rdoc", "MIT-LICENSE"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.4.1}
+  s.rubygems_version = %q{1.5.2}
   s.summary = %q{ActiveRecord extension that provides revision support so that history can be tracked and changes can be reverted.}
-  s.test_files = [
-    "spec/acts_as_revisionable_spec.rb",
-    "spec/full_spec.rb",
-    "spec/revision_record_spec.rb",
-    "spec/spec_helper.rb"
-  ]
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activerecord>, [">= 2.2"])
+      s.add_runtime_dependency(%q<activerecord>, [">= 2.3.5"])
+      s.add_development_dependency(%q<composite_primary_keys>, [">= 0"])
       s.add_development_dependency(%q<sqlite3>, [">= 0"])
       s.add_development_dependency(%q<rspec>, [">= 2.0.0"])
       s.add_development_dependency(%q<jeweler>, [">= 0"])
     else
-      s.add_dependency(%q<activerecord>, [">= 2.2"])
+      s.add_dependency(%q<activerecord>, [">= 2.3.5"])
+      s.add_dependency(%q<composite_primary_keys>, [">= 0"])
       s.add_dependency(%q<sqlite3>, [">= 0"])
       s.add_dependency(%q<rspec>, [">= 2.0.0"])
       s.add_dependency(%q<jeweler>, [">= 0"])
     end
   else
-    s.add_dependency(%q<activerecord>, [">= 2.2"])
+    s.add_dependency(%q<activerecord>, [">= 2.3.5"])
+    s.add_dependency(%q<composite_primary_keys>, [">= 0"])
     s.add_dependency(%q<sqlite3>, [">= 0"])
     s.add_dependency(%q<rspec>, [">= 2.0.0"])
     s.add_dependency(%q<jeweler>, [">= 0"])

data/lib/acts_as_revisionable.rb

@@ -1,11 +1,11 @@
 require 'active_record'
-require 'active_support/all'
+require 'active_support'
 
 module ActsAsRevisionable
   
   autoload :RevisionRecord, File.expand_path('../acts_as_revisionable/revision_record', __FILE__)
   
-  def self.included (base)
+  def self.included(base)
     base.extend(ActsMethods)
   end
   
@@ -15,40 +15,77 @@ module ActsAsRevisionable
     # kept for at least a certain amount of time (i.e. 2.weeks). Associations to be revisioned can be specified with
     # the :associations option as an array of association names. To specify associations of associations, use a hash
     # for that association with the association name as the key and the value as an array of sub associations.
-    # For instance, this declaration will revision :tags, :comments, as well as the :ratings association on :comments:
+    # For instance, this declaration will revision <tt>:tags</tt>, <tt>:comments</tt>, as well as the
+    # <tt>:ratings</tt> association on <tt>:comments</tt>:
     #
     #   :associations => [:tags, {:comments => [:ratings]}]
     #
-    # You can also pass an options of :on_update => true to automatically enable revisioning on every update.
+    # You can also pass an options of <tt>:on_update => true</tt> to automatically enable revisioning on every update.
     # Otherwise you will need to perform your updates in a store_revision block. The reason for this is so that
     # revisions for complex models with associations can be better controlled.
     #
+    # You can keep a revisions of deleted records by passing <tt>:dependent => :keep</tt>. When a record is destroyed,
+    # an additional revision will be created and marked as trash. Trash records can be deleted by calling the
+    # <tt>empty_trash</tt> method. You can set <tt>:on_destroy => true</tt> to automatically create the trash revision
+    # whenever a record is destroyed. It is recommended that you turn both of these features on.
+    #
     # A has_many :revision_records will also be added to the model for accessing the revisions.
-    def acts_as_revisionable (options = {})
+    def acts_as_revisionable(options = {})
       write_inheritable_attribute(:acts_as_revisionable_options, options)
       class_inheritable_reader(:acts_as_revisionable_options)
       extend ClassMethods
       include InstanceMethods
       has_many_options = {:as => :revisionable, :order => 'revision DESC', :class_name => "ActsAsRevisionable::RevisionRecord"}
-      has_many_options[:dependent] = :destroy unless options[:dependent] == :keep 
+      has_many_options[:dependent] = :destroy unless options[:dependent] == :keep
       has_many :revision_records, has_many_options
       alias_method_chain :update, :revision if options[:on_update]
+      alias_method_chain :destroy, :revision if options[:on_destroy]
     end
   end
   
   module ClassMethods
-    # Load a revision for a record with a particular id. If this revision has association it
-    # will not delete associated records added since the revision was added if you save it.
+    # Get a revision for a specified id.
+    def revision(id, revision_number)
+      RevisionRecord.find_revision(self, id, revision_number)
+    end
+    
+    # Get the last revision for a specified id.
+    def last_revision(id)
+      RevisionRecord.last_revision(self, id)
+    end
+    
+    # Load a revision for a record with a particular id. Associations added since the revision
+    # was created will still be in the restored record.
     # If you want to save a revision with associations properly, use restore_revision!
-    def restore_revision (id, revision)
-      revision = RevisionRecord.find_revision(self, id, revision)
-      return revision.restore if revision
+    def restore_revision(id, revision_number)
+      revision_record = revision(id, revision_number)
+      return revision_record.restore if revision_record
     end
 
     # Load a revision for a record with a particular id and save it to the database. You should
     # always use this method to save a revision if it has associations.
-    def restore_revision! (id, revision)
-      record = restore_revision(id, revision)
+    def restore_revision!(id, revision_number)
+      record = restore_revision(id, revision_number)
+      if record
+        record.store_revision do
+          save_restorable_associations(record, revisionable_associations)
+        end
+      end
+      return record
+    end
+    
+    # Load the last revision for a record with the specified id. Associations added since the revision
+    # was created will still be in the restored record.
+    # If you want to save a revision with associations properly, use restore_last_revision!
+    def restore_last_revision(id)
+      revision_record = last_revision(id)
+      return revision_record.restore if revision_record
+    end
+
+    # Load the last revision for a record with the specified id and save it to the database. You should
+    # always use this method to save a revision if it has associations.
+    def restore_last_revision!(id)
+      record = restore_last_revision(id)
       if record
         record.store_revision do
           save_restorable_associations(record, revisionable_associations)
@@ -58,7 +95,7 @@ module ActsAsRevisionable
     end
     
     # Returns a hash structure used to identify the revisioned associations.
-    def revisionable_associations (options = acts_as_revisionable_options[:associations])
+    def revisionable_associations(options = acts_as_revisionable_options[:associations])
       return nil unless options
       options = [options] unless options.kind_of?(Array)
       associations = {}
@@ -74,9 +111,14 @@ module ActsAsRevisionable
       return associations
     end
     
+    # Delete all revision records for deleted items that are older than the specified maximum age in seconds.
+    def empty_trash(max_age)
+      RevisionRecord.empty_trash(self, max_age)
+    end
+    
     private
     
-    def save_restorable_associations (record, associations)
+    def save_restorable_associations(record, associations)
       record.class.transaction do
         if associations.kind_of?(Hash)
           associations.each_pair do |association, sub_associations|
@@ -91,7 +133,7 @@ module ActsAsRevisionable
               end
             else
               if reflection == :has_many
-                existing = associated_records.find(:all)
+                existing = associated_records.all
                 existing.each do |existing_association|
                   associated_records.delete(existing_association) unless associated_records.include?(existing_association)
                 end
@@ -112,42 +154,64 @@ module ActsAsRevisionable
   module InstanceMethods
     # Restore a revision of the record and return it. The record is not saved to the database. If there
     # is a problem restoring values, errors will be added to the record.
-    def restore_revision (revision)
-      self.class.restore_revision(self.id, revision)
+    def restore_revision(revision_number)
+      self.class.restore_revision(self.id, revision_number)
     end
     
     # Restore a revision of the record and save it along with restored associations.
-    def restore_revision! (revision)
-      self.class.restore_revision!(self.id, revision)
+    def restore_revision!(revision_number)
+      self.class.restore_revision!(self.id, revision_number)
+    end
+    
+    # Get a specified revision record
+    def revision(revision_number)
+      self.class.revision(id, revision_number)
+    end
+    
+    # Get the last revision record
+    def last_revision
+      self.class.last_revision(id)
     end
     
     # Call this method to implement revisioning. The object changes should happen inside the block.
     def store_revision
-      if new_record? or @revisions_disabled
+      if new_record? || @revisions_disabled
         return yield
       else
         retval = nil
         revision = nil
         begin
           RevisionRecord.transaction do
-            read_only = self.class.find(self.id, :readonly => true) rescue nil
-            if read_only
-              revision = read_only.create_revision!
-              truncate_revisions!
+            begin
+              read_only = self.class.first(:conditions => {self.class.primary_key => self.id}, :readonly => true)
+              if read_only
+                revision = read_only.create_revision!
+                truncate_revisions!
+              end
+            rescue => e
+              puts e
+              logger.warn(e) if logger
             end
             
             disable_revisioning do
               retval = yield
             end
             
-            raise 'rollback_revision' unless errors.empty?
+            raise ActiveRecord::Rollback unless errors.empty?
+            
+            revision.trash! if destroyed?
           end
         rescue => e
           # In case the database doesn't support transactions
           if revision
-            revision.destroy rescue nil
+            begin
+              revision.destroy
+            rescue => e
+              puts e
+              logger.warn(e) if logger
+            end
           end
-          raise e unless e.message == 'rollback_revision'
+          raise e
         end
         return retval
       end
@@ -161,7 +225,7 @@ module ActsAsRevisionable
     end
     
     # Truncate the number of revisions kept for this record. Available options are :limit and :minimum_age.
-    def truncate_revisions! (options = nil)
+    def truncate_revisions!(options = nil)
       options = {:limit => acts_as_revisionable_options[:limit], :minimum_age => acts_as_revisionable_options[:minimum_age]} unless options
       RevisionRecord.truncate_revisions(self.class, self.id, options)
     end
@@ -179,9 +243,16 @@ module ActsAsRevisionable
       return retval
     end
     
+    # Destroy the record while recording the revision.
+    def destroy_with_revision
+      store_revision do
+        destroy_without_revision
+      end
+    end
+    
     private
     
-    # This is the update call that overrides the default update method.
+    # Update the record while recording the revision.
     def update_with_revision
       store_revision do
         update_without_revision

data/lib/acts_as_revisionable/revision_record.rb

@@ -3,21 +3,26 @@ require 'yaml'
 
 module ActsAsRevisionable
   class RevisionRecord < ActiveRecord::Base
-  
+
     before_create :set_revision_number
     attr_reader :data_encoding
-    
+
     set_table_name :revision_records
-  
+
     class << self
       # Find a specific revision record.
-      def find_revision (klass, id, revision)
+      def find_revision(klass, id, revision)
         find(:first, :conditions => {:revisionable_type => klass.base_class.to_s, :revisionable_id => id, :revision => revision})
       end
+      
+      # Find the last revision record for a class.
+      def last_revision(klass, id, revision = nil)
+        find(:first, :conditions => {:revisionable_type => klass.base_class.to_s, :revisionable_id => id}, :order => "revision DESC")
+      end
 
       # Truncate the revisions for a record. Available options are :limit and :max_age.
-      def truncate_revisions (revisionable_type, revisionable_id, options)
-        return unless options[:limit] or options[:minimum_age]
+      def truncate_revisions(revisionable_type, revisionable_id, options)
+        return unless options[:limit] || options[:minimum_age]
 
         conditions = ['revisionable_type = ? AND revisionable_id = ?', revisionable_type.base_class.to_s, revisionable_id]
         if options[:minimum_age]
@@ -30,23 +35,48 @@ module ActsAsRevisionable
           delete_all(['revisionable_type = ? AND revisionable_id = ? AND revision <= ?', revisionable_type.base_class.to_s, revisionable_id, start_deleting_revision.revision])
         end
       end
-      
+
+      # Empty the trash by deleting records older than the specified maximum age in seconds.
+      # The +revisionable_type+ argument specifies the class to delete revision records for.
+      def empty_trash(revisionable_type, max_age)
+        sql = "revisionable_id IN (SELECT revisionable_id from #{table_name} WHERE created_at <= ? AND revisionable_type = ? AND trash = ?) AND revisionable_type = ?"
+        args = [max_age.ago, revisionable_type.name, true, revisionable_type.name]
+        delete_all([sql] + args)
+      end
+
+      # Create the table to store revision records.
       def create_table
         connection.create_table :revision_records do |t|
           t.string :revisionable_type, :null => false, :limit => 100
           t.integer :revisionable_id, :null => false
           t.integer :revision, :null => false
-          t.binary :data, :limit => (connection.adapter_name == "MySQL" ? 5.megabytes : nil)
+          t.binary :data, :limit => (connection.adapter_name.match(/mysql/i) ? 5.megabytes : nil)
           t.timestamp :created_at, :null => false
+          t.boolean :trash, :default => false
+          t.string :label, :limit => 255, :null => true
         end
+        
+        connection.add_index :revision_records, :revisionable_id, :name => "revision_record_id"
+        connection.add_index :revision_records, [:revisionable_type, :created_at, :trash], :name => "revisionable_type_and_created_at"
+      end
+      
+      # Update a version 1.0.x table to the latest version. This method only needs to be called
+      # from a migration if you originally created the table with a version 1.0.x version of the gem.
+      def update_version_1_table
+        # Added in version 1.1.0
+        connection.add_column(:revision_records, :trash, :boolean, :default => false)
+        connection.add_column(:revision_records, :label, :string, :limit => 255, :null => true)
+        connection.add_index :revision_records, :revisionable_id, :name => "revision_record_id"
+        connection.add_index :revision_records, [:revisionable_type, :created_at, :trash], :name => "revisionable_type_and_created_at"
 
-        connection.add_index :revision_records, [:revisionable_type, :revisionable_id, :revision], :name => "revisionable", :unique => true
+        # Removed in 1.1.0
+        connection.remove_index(:revision_records, :name => "revisionable")
       end
     end
-    
+
     # Create a revision record based on a record passed in. The attributes of the original record will
     # be serialized. If it uses the acts_as_revisionable behavior, associations will be revisioned as well.
-    def initialize (record, encoding = :ruby)
+    def initialize(record, encoding = :ruby)
       super({})
       @data_encoding = encoding
       self.revisionable_type = record.class.base_class.name
@@ -54,19 +84,19 @@ module ActsAsRevisionable
       associations = record.class.revisionable_associations if record.class.respond_to?(:revisionable_associations)
       self.data = Zlib::Deflate.deflate(serialize_hash(serialize_attributes(record, associations)))
     end
-  
+
     # Returns the attributes that are saved in the revision.
     def revision_attributes
       return nil unless self.data
       uncompressed = Zlib::Inflate.inflate(self.data)
       deserialize_hash(uncompressed)
     end
-  
+
     # Restore the revision to the original record. If any errors are encountered restoring attributes, they
     # will be added to the errors object of the restored record.
     def restore
       restore_class = self.revisionable_type.constantize
-    
+
       # Check if we have a type field, if yes, assume single table inheritance and restore the actual class instead of the stored base class
       sti_type = self.revision_attributes[restore_class.inheritance_column]
       if sti_type
@@ -80,32 +110,21 @@ module ActsAsRevisionable
           # Seems our assumption was wrong and we have no STI
         end
       end
-    
-      attrs, association_attrs = attributes_and_associations(restore_class, self.revision_attributes)
-    
+
       record = restore_class.new
-      attrs.each_pair do |key, value|
-        begin
-          record.send("#{key}=", value)
-        rescue
-          record.errors.add(key.to_sym, "could not be restored to #{value.inspect}")
-        end
-      end
-    
-      association_attrs.each_pair do |association, attribute_values|
-        restore_association(record, association, attribute_values)
-      end
-      
-      record.instance_variable_set(:@new_record, nil) if record.instance_variable_defined?(:@new_record)
-      # ActiveRecord 3.0.2 and 3.0.3 used @persisted instead of @new_record
-      record.instance_variable_set(:@persisted, true) if record.instance_variable_defined?(:@persisted)
-    
+      restore_record(record, revision_attributes)
       return record
     end
     
+    # Mark this revision as being trash. When trash records are restored, all
+    # their revision history is restored as well.
+    def trash!
+      update_attribute(:trash, true)
+    end
+
     private
-  
-    def serialize_hash (hash)
+
+    def serialize_hash(hash)
       encoding = data_encoding.blank? ? :ruby : data_encoding
       case encoding.to_sym
       when :yaml
@@ -116,8 +135,8 @@ module ActsAsRevisionable
         return Marshal.dump(hash)
       end
     end
-  
-    def deserialize_hash (data)
+
+    def deserialize_hash(data)
       if data.starts_with?('---')
         return YAML.load(data)
       elsif data.starts_with?('<?xml')
@@ -126,17 +145,17 @@ module ActsAsRevisionable
         return Marshal.load(data)
       end
     end
-  
+
     def set_revision_number
       last_revision = self.class.maximum(:revision, :conditions => {:revisionable_type => self.revisionable_type, :revisionable_id => self.revisionable_id}) || 0
       self.revision = last_revision + 1
     end
 
-    def serialize_attributes (record, revisionable_associations, already_serialized = {})
+    def serialize_attributes(record, revisionable_associations, already_serialized = {})
       return if already_serialized["#{record.class}.#{record.id}"]
       attrs = record.attributes.dup
       already_serialized["#{record.class}.#{record.id}"] = true
-    
+
       if revisionable_associations.kind_of?(Hash)
         record.class.reflections.values.each do |association|
           if revisionable_associations[association.name]
@@ -151,19 +170,19 @@ module ActsAsRevisionable
                 attrs[assoc_name] = nil
               end
             elsif association.macro == :has_and_belongs_to_many
-              attrs[assoc_name] = record.send("#{association.name.to_s.singularize}_ids".to_sym)
+              attrs[assoc_name] = record.send("#{association.name.to_s.singularize}_ids")
             end
           end
         end
       end
-    
+
       return attrs
     end
-  
-    def attributes_and_associations (klass, hash)
+
+    def attributes_and_associations(klass, hash)
       attrs = {}
       association_attrs = {}
-    
+
       if hash
         hash.each_pair do |key, value|
           if klass.reflections.include?(key.to_sym)
@@ -173,32 +192,29 @@ module ActsAsRevisionable
           end
         end
       end
-    
+
       return [attrs, association_attrs]
     end
-  
-    def restore_association (record, association, association_attributes)
+
+    def restore_association(record, association, association_attributes)
       association = association.to_sym
       reflection = record.class.reflections[association]
       associated_record = nil
-      exists = false
-    
+
       begin
         if reflection.macro == :has_many
           if association_attributes.kind_of?(Array)
-            record.send("#{association}=".to_sym, [])
+            record.send("#{association}=", [])
             association_attributes.each do |attrs|
               restore_association(record, association, attrs)
             end
           else
             associated_record = record.send(association).build
-            associated_record.id = association_attributes['id']
-            exists = associated_record.class.find(associated_record.id) rescue nil
+            restore_record(associated_record, association_attributes)
           end
         elsif reflection.macro == :has_one
           associated_record = reflection.klass.new
-          associated_record.id = association_attributes['id']
-          exists = associated_record.class.find(associated_record.id) rescue nil
+          restore_record(associated_record, association_attributes)
           record.send("#{association}=", associated_record)
         elsif reflection.macro == :has_and_belongs_to_many
           record.send("#{association.to_s.singularize}_ids=", association_attributes)
@@ -206,27 +222,41 @@ module ActsAsRevisionable
       rescue => e
         record.errors.add(association, "could not be restored from the revision: #{e.message}")
       end
-    
-      return unless associated_record
-    
-      attrs, association_attrs = attributes_and_associations(associated_record.class, association_attributes)
+      
+      if associated_record && !associated_record.errors.empty?
+        record.errors.add(association, 'could not be restored from the revision')
+      end
+    end
+
+    # Restore a record and all its associations.
+    def restore_record(record, attributes)
+      primary_key = record.class.primary_key
+      primary_key = [primary_key] unless primary_key.is_a?(Array)
+      primary_key.each do |key|
+        record.send("#{key.to_s}=", attributes[key.to_s])
+      end
+
+      attrs, association_attrs = attributes_and_associations(record.class, attributes)
       attrs.each_pair do |key, value|
         begin
-          associated_record.send("#{key}=", value)
+          record.send("#{key}=", value)
         rescue
-          associated_record.errors.add(key.to_sym, "could not be restored to #{value.inspect}")
-          record.errors.add(association, "could not be restored from the revision") unless record.errors[association]
+          record.errors.add(key.to_sym, "could not be restored to #{value.inspect}")
         end
       end
-    
+
       association_attrs.each_pair do |key, values|
-        restore_association(associated_record, key, values)
+        restore_association(record, key, values) if values
       end
       
+      # Check if the record already exists in the database and restore its state.
+      # This must be done last because otherwise associations on an existing record
+      # can be deleted when a revision is restored to memory.
+      exists = record.class.find(record.send(record.class.primary_key)) rescue nil
       if exists
-        associated_record.instance_variable_set(:@new_record, nil) if associated_record.instance_variable_defined?(:@new_record)
+        record.instance_variable_set(:@new_record, nil) if record.instance_variable_defined?(:@new_record)
         # ActiveRecord 3.0.2 and 3.0.3 used @persisted instead of @new_record
-        associated_record.instance_variable_set(:@persisted, true) if associated_record.instance_variable_defined?(:@persisted)
+        record.instance_variable_set(:@persisted, true) if record.instance_variable_defined?(:@persisted)
       end
     end
   end