acts_as_revisionable 1.0.3

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Brian Durand
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,56 @@
+= Acts As Revisionable
+
+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:
+
+  acts_as_revisionable :limit => 25
+
+You can insure that revisions are kept for a minimum length of time by specifying :minimum_age:
+
+  acts_as_revisionable :limit => 15, :minimum_age => 2.weeks
+
+Revisions are accessible on a record via a has_many :revision_records association. The revision records are sorted in reverse order. The revisions will be destroyed along with the parent record.
+
+== 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:
+
+  :associations => :comments  # include has_many :comments in the revision
+  :associations => [:comments, :tags]  # include both :comments and :tags
+  :associations => [{:comments => :ratings}, :tags]  # include both :comments and :tags as well as has_many :ratings on the comments
+
+You can only revision has_many, has_one, and has_and_belongs_to_many associations. You cannot revision belongs_to.
+
+== 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:
+
+  store_revision do
+    model.update_has_many_records(params[:has_many])
+		model.save!
+	end
+	
+The revision will only be saved if the block successfully updates the record to the database.
+
+== Restoring Revisions
+
+You can restore revisions into an object in memory by calling restore_revision with the revision number. This will return a new object with all the attributes and associations restored from the revision record. The object will not have been saved yet to the database. If any errors were encountered restoring an attribute or association, an error will be added to the record errors. This should make it easy to reuse the model's edit interface for restoring the revision. You can also call restore_revision! to restore the record and save it and all it's associations.
+
+If you are revisioning associations, you should always call restore_revision! instead of simply restoring the revision and calling save. Otherwise associations added since the revision will not be removed. This is a limitation on how active record handles removing revisions.
+
+== Serialization
+
+By default revisions are serialized using Ruby's Marshal class. This is the most reliable mechanism, but the least portable. As an alternative, you can specify <tt>:encoding => :yaml</tt> in the acts_as_revisionable options. This will store the data as YAML. There are some issues with the Ruby 1.8 YAML parser where some values are not deserialized properly, so only use this option if you really need the portability. You can also specify <tt>:encoding => :xml</tt> to store the revisions as XML. This should work fine unless the record contains binary data.
+
+== Setup
+
+To create the table structure for ActsAsRevisionable::RevisionRecord, simply add a migration to your project that calls
+
+  ActsAsRevisionable::RevisionRecord.create_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.
+
+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.

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'rake'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+begin
+  require 'spec/rake/spectask'
+  desc 'Test the gem.'
+  Spec::Rake::SpecTask.new(:test) do |t|
+    t.spec_files = FileList.new('spec/**/*_spec.rb')
+  end
+rescue LoadError
+  tast :test do
+    STDERR.puts "You must have rspec >= 1.3.0 to run the tests"
+  end
+end
+
+desc 'Generate documentation for the gem.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.options << '--title' << 'Acts As Revisionable' << '--line-numbers' << '--inline-source' << '--main' << 'README.rdoc'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "acts_as_revisionable"
+    gem.summary = %Q{ActiveRecord extension that provides revision support so that history can be tracked and changes can be reverted.}
+    gem.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.)
+    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.add_dependency('activerecord', '>= 2.2')
+    gem.add_development_dependency('sqlite3')
+    gem.add_development_dependency('rspec', '>= 1.3.0')
+    gem.add_development_dependency('jeweler')
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.3

data/acts_as_revisionable.gemspec

@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{acts_as_revisionable}
+  s.version = "1.0.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Brian Durand"]
+  s.date = %q{2010-06-22}
+  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 = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README.rdoc",
+     "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"
+  ]
+  s.homepage = %q{http://github.com/bdurand/acts_as_revisionable}
+  s.rdoc_options = ["--charset=UTF-8", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  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
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    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_development_dependency(%q<sqlite3>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 1.3.0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 2.2"])
+      s.add_dependency(%q<sqlite3>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 1.3.0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 2.2"])
+    s.add_dependency(%q<sqlite3>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 1.3.0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+  end
+end
+

data/lib/acts_as_revisionable/revision_record.rb

@@ -0,0 +1,227 @@
+require 'zlib'
+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)
+        find(:first, :conditions => {:revisionable_type => klass.base_class.to_s, :revisionable_id => id, :revision => revision})
+      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]
+
+        conditions = ['revisionable_type = ? AND revisionable_id = ?', revisionable_type.base_class.to_s, revisionable_id]
+        if options[:minimum_age]
+          conditions.first << ' AND created_at <= ?'
+          conditions << options[:minimum_age].ago
+        end
+
+        start_deleting_revision = find(:first, :conditions => conditions, :order => 'revision DESC', :offset => options[:limit])
+        if start_deleting_revision
+          delete_all(['revisionable_type = ? AND revisionable_id = ? AND revision <= ?', revisionable_type.base_class.to_s, revisionable_id, start_deleting_revision.revision])
+        end
+      end
+      
+      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 => 5.megabytes
+          t.timestamp :created_at, :null => false
+        end
+
+        connection.add_index :revision_records, [:revisionable_type, :revisionable_id, :revision], :name => "revisionable", :unique => true
+      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)
+      super({})
+      @data_encoding = encoding
+      self.revisionable_type = record.class.base_class.name
+      self.revisionable_id = record.id
+      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
+        begin
+          unless restore_class.store_full_sti_class
+            sti_type = (/^::/ =~ type_name) ? type_name : "#{restore_class.parent.name}::#{type_name}"
+          end
+          restore_class = sti_type.constantize
+        rescue NameError
+          raise
+          # 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)
+    
+      return record
+    end
+    
+    private
+  
+    def serialize_hash (hash)
+      encoding = data_encoding.blank? ? :ruby : data_encoding
+      case encoding.to_sym
+      when :yaml
+        return YAML.dump(hash)
+      when :xml
+        return hash.to_xml(:root => 'revision')
+      else
+        return Marshal.dump(hash)
+      end
+    end
+  
+    def deserialize_hash (data)
+      if data.starts_with?('---')
+        return YAML.load(data)
+      elsif data.starts_with?('<?xml')
+        return Hash.from_xml(data)['revision']
+      else
+        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 = {})
+      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]
+            assoc_name = association.name.to_s
+            if association.macro == :has_many
+              attrs[assoc_name] = record.send(association.name).collect{|r| serialize_attributes(r, revisionable_associations[association.name], already_serialized)}
+            elsif association.macro == :has_one
+              associated = record.send(association.name)
+              unless associated.nil?
+                attrs[assoc_name] = serialize_attributes(associated, revisionable_associations[association.name], already_serialized)
+              else
+                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)
+            end
+          end
+        end
+      end
+    
+      return attrs
+    end
+  
+    def attributes_and_associations (klass, hash)
+      attrs = {}
+      association_attrs = {}
+    
+      if hash
+        hash.each_pair do |key, value|
+          if klass.reflections.include?(key.to_sym)
+            association_attrs[key] = value
+          else
+            attrs[key] = value
+          end
+        end
+      end
+    
+      return [attrs, association_attrs]
+    end
+  
+    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, [])
+            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
+          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
+          record.send("#{association}=", associated_record)
+        elsif reflection.macro == :has_and_belongs_to_many
+          record.send("#{association.to_s.singularize}_ids=", association_attributes)
+        end
+      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)
+      attrs.each_pair do |key, value|
+        begin
+          associated_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]
+        end
+      end
+    
+      association_attrs.each_pair do |key, values|
+        restore_association(associated_record, key, values)
+      end
+    
+      associated_record.instance_variable_set(:@new_record, nil) if exists
+    end
+  end
+end

data/lib/acts_as_revisionable.rb

@@ -0,0 +1,193 @@
+require 'active_record'
+require 'active_support/all'
+
+module ActsAsRevisionable
+  
+  autoload :RevisionRecord, File.expand_path('../acts_as_revisionable/revision_record', __FILE__)
+  
+  def self.included (base)
+    base.extend(ActsMethods)
+  end
+  
+  module ActsMethods
+    # Calling acts_as_revisionable will inject the revisionable behavior into the class. Specifying a :limit option
+    # will limit the number of revisions that are kept per record. Specifying :minimum_age will ensure that revisions are
+    # 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:
+    #
+    #   :associations => [:tags, {:comments => [:ratings]}]
+    #
+    # You can also pass an options of :on_update => true 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.
+    #
+    # A has_many :revision_records will also be added to the model for accessing the revisions.
+    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 :revision_records, has_many_options
+      alias_method_chain :update, :revision if options[:on_update]
+    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.
+    # 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
+    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)
+      if record
+        record.store_revision do
+          save_restorable_associations(record, revisionable_associations)
+        end
+      end
+      return record
+    end
+    
+    # Returns a hash structure used to identify the revisioned associations.
+    def revisionable_associations (options = acts_as_revisionable_options[:associations])
+      return nil unless options
+      options = [options] unless options.kind_of?(Array)
+      associations = {}
+      options.each do |association|
+        if association.kind_of?(Symbol)
+          associations[association] = true
+        elsif association.kind_of?(Hash)
+          association.each_pair do |key, value|
+            associations[key] = revisionable_associations(value)
+          end
+        end
+      end
+      return associations
+    end
+    
+    private
+    
+    def save_restorable_associations (record, associations)
+      record.class.transaction do
+        if associations.kind_of?(Hash)
+          associations.each_pair do |association, sub_associations|
+            associated_records = record.send(association)
+            reflection = record.class.reflections[association].macro
+            
+            if reflection == :has_and_belongs_to_many
+              associated_records = associated_records.collect{|r| r}
+              record.send(association, true).clear
+              associated_records.each do |assoc_record|
+                record.send(association) << assoc_record
+              end
+            else
+              if reflection == :has_many
+                existing = associated_records.find(:all)
+                existing.each do |existing_association|
+                  associated_records.delete(existing_association) unless associated_records.include?(existing_association)
+                end
+              end
+            
+              associated_records = [associated_records] unless associated_records.kind_of?(Array)
+              associated_records.each do |associated_record|
+                save_restorable_associations(associated_record, sub_associations) if associated_record
+              end
+            end
+          end
+        end
+        record.save! unless record.new_record?
+      end
+    end
+  end
+  
+  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)
+    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)
+    end
+    
+    # Call this method to implement revisioning. The object changes should happen inside the block.
+    def store_revision
+      if new_record? or @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!
+            end
+            
+            disable_revisioning do
+              retval = yield
+            end
+            
+            raise 'rollback_revision' unless errors.empty?
+          end
+        rescue => e
+          # In case the database doesn't support transactions
+          if revision
+            revision.destroy rescue nil
+          end
+          raise e unless e.message == 'rollback_revision'
+        end
+        return retval
+      end
+    end
+    
+    # Create a revision record based on this record and save it to the database.
+    def create_revision!
+      revision = RevisionRecord.new(self, acts_as_revisionable_options[:encoding])
+      revision.save!
+      return revision
+    end
+    
+    # Truncate the number of revisions kept for this record. Available options are :limit and :minimum_age.
+    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
+    
+    # Disable the revisioning behavior inside of a block passed to the method.
+    def disable_revisioning
+      save_val = @revisions_disabled
+      retval = nil
+      begin
+        @revisions_disabled = true
+        retval = yield if block_given?
+      ensure
+        @revisions_disabled = save_val
+      end
+      return retval
+    end
+    
+    private
+    
+    # This is the update call that overrides the default update method.
+    def update_with_revision
+      store_revision do
+        update_without_revision
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, ActsAsRevisionable)