rich-rich-acts_as_revisable 0.6.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Rich Cavanaugh
+
+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

@@ -0,0 +1,193 @@
+= acts_as_revisable
+
+http://github.com/rich/acts_as_revisable/tree/master
+
+== DESCRIPTION:
+
+acts_as_revisable enables revision tracking, querying, reverting and branching of ActiveRecord models. It does this while providing more Rails-like API than similar plugins. This includes extensions of standard ActiveRecord methods and numerous custom callbacks for the entire AAR life-cycle.
+
+This plugin wouldn't exist without Rick Olsen's acts_as_versioned. AAV has been a critical part of practically every Rails project I've developed. It's only through extensive usage of AAV that the concepts for AAR came about.
+
+== FEATURES:
+
+* Both the revisable and revision models must be explicitly defined.
+  Yes, this is a feature. The less magic needed the better. This allows you to build up your revision models just as you would any other.
+
+* Numerous custom callbacks for both revisable and revision models.
+  * revisable models
+    * before_revise
+    * after_revise
+    * before_revert
+    * after_revert
+    * before_changeset
+    * after_changeset
+    * after_branch_created
+  * revision models
+    * before_restore
+    * after_restore
+  * both revisable and revision models
+    * before_branch
+    * after_branch
+  These work like any other ActiveRecord callbacks. The before_* callbacks can stop the the action. This uses the Callbacks module in ActiveSupport.
+* Works with a single table.
+  * Provides migration generators to add the revisable columns.
+* Grouping several revisable actions into a single revision (changeset).
+* Monitor all or just specified columns to trigger a revision.
+* Clone all or specified associations to the revision model.
+* Uses ActiveRecord's dirty attribute tracking.
+* Several ways to find revisions including:
+  * revision number
+  * relative keywords (:previous, :last)
+  * timestamp
+* Reverting
+* Branching
+* Selectively disable revision tracking
+* Naming revisions  
+
+== SYNOPSIS:
+
+Given a simple model:
+
+  class Project < ActiveRecord::Base
+    # columns: id, name, unimportant, created_at
+  end
+
+Let's make the projects table revisable:
+
+  ruby script/generate revisable_migration Project
+  rake db:migrate
+
+Now Project itself:
+  
+  class Project < ActiveRecord::Base
+    has_one :owner
+    
+    acts_as_revisable do
+      revision_class_name "Session"
+      except :unimportant
+    end
+  end
+
+Create the revision class:
+
+  class Session < ActiveRecord::Base
+    # we can accept the more standard hash syntax
+    acts_as_revision :revisable_class_name => "Project", :clone_associations => :all
+  end
+
+Some example usage:
+
+  @project = Project.create(:name => "Rich", :unimportant => "some text")
+  @project.revision_number        # => 0
+
+  @project.update_attribute(:unimportant, "more text")
+  @project.revision_number        # => 0
+  
+  @project.name = "Stephen"
+  @project.save(:without_revision => true)
+  @project.name                   # => Stephen
+  @project.revision_number        # => 0
+  
+  @project.name = "Sam"
+  @project.save(:revision_name => "Changed name")
+  @project.revision_number        # => 1
+
+Navigating revisions:
+
+  @previous = @project.find_revision(:previous)
+  # or
+  @previous = @project.revisions.first
+  
+  @previous.name                  # => Rich
+  @previous.current_revision.name # => Sam
+  @previous.project.name          # => Sam
+  @previous.revision_name         # => Changed name
+
+Reverting:
+
+  @project.revert_to!(:previous)
+  @project.revision_number        # => 2
+  @project.name                   # => Rich
+  
+  @project.revert_to!(1, :without_revision => true)
+  @project.revision_number        # => 2
+  @project.name                   # => Sam
+
+Branching
+  
+  @branch = @project.branch(:name => "Bruno")
+  @branch.revision_number         # => 0
+  @branch.branch_source.name      # => Sam
+
+Associations have been cloned:
+
+  @project.owner === @previous.owner   # => true
+
+Maybe we don't want to be able to branch from revisions:
+
+  class Session < ActiveRecord::Base
+    # assuming we still have the other code from Session above
+    
+    before_branch do
+      false
+    end
+  end
+  
+  @project.revisions.first.branch # Raises an exception
+  @project.branch                 # works as expected
+  
+If the owner isn't set let's prevent reverting:
+
+  class Project < ActiveRecord::Base
+    # assuming we still have the other code from Project above
+    
+    before_revert :check_owner_befor_reverting
+    def check_owner_befor_reverting
+      false unless self.owner?
+    end
+  end
+  
+== REQUIREMENTS:
+
+This plugin currently depends on Edge Rails, ActiveRecord and ActiveSupport specifically, which will eventually become Rails 2.1.
+
+== INSTALL:
+
+acts_as_revisable uses Rails' new ability to use gems as plugins. Installing AAR is as simple as installing a gem.
+
+You may need to add GitHub as a Gem source:
+
+  sudo gem sources -a http://gems.github.com/
+
+Then it can be installed as usual:
+
+  sudo gem install rich-acts_as_revisable
+
+Once the gem is installed you'll want to activate it in your Rails app by adding the following line to config/environment.rb:
+
+  config.gem "rich-acts_as_revisable", :lib => "acts_as_revisable", :source => "http://gems.github.com"
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008
+
+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/generators/revisable_migration/revisable_migration_generator.rb

@@ -0,0 +1,9 @@
+class RevisableMigrationGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+      revisable_columns = [["revisable_original_id", "integer"], ["revisable_branched_from_id", "integer"], ["revisable_number", "integer"], ["revisable_name", "string"], ["revisable_type", "string"], ["revisable_current_at", "datetime"], ["revisable_revised_at", "datetime"], ["revisable_deleted_at", "datetime"], ["revisable_is_current", "boolean"]]
+      
+      m.migration_template 'migration.rb', 'db/migrate', :migration_file_name => "make_#{class_name.downcase}_revisable", :assigns => {:cols => revisable_columns}
+    end
+  end
+end

data/generators/revisable_migration/templates/migration.rb

@@ -0,0 +1,13 @@
+class Make<%= class_name.underscore.camelize %>Revisable < ActiveRecord::Migration
+  def self.up
+    <% cols.each do |c| -%>
+    add_column :<%= class_name.downcase.pluralize %>, :<%= c.first %>, :<%= c.last %>
+    <% end -%>
+  end
+
+  def self.down
+    <% cols.each do |c| -%>
+    remove_column :<%= class_name.downcase.pluralize %>, :<%= c.first %>
+    <% end -%>
+  end
+end

data/lib/acts_as_revisable.rb

@@ -0,0 +1,14 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'activesupport' unless defined? ActiveSupport
+require 'activerecord' unless defined? ActiveRecord
+
+require 'acts_as_revisable/version.rb'
+require 'acts_as_revisable/acts/scoped_model'
+require 'acts_as_revisable/quoted_columns'
+require 'acts_as_revisable/base'
+
+ActiveRecord::Base.send(:include, FatJam::ActsAsScopedModel)
+ActiveRecord::Base.send(:include, FatJam::QuotedColumnConditions)
+ActiveRecord::Base.send(:include, FatJam::ActsAsRevisable)

data/lib/acts_as_revisable/acts/common.rb

@@ -0,0 +1,84 @@
+module FatJam
+  module ActsAsRevisable
+    module Common
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+
+        class << base
+          alias_method_chain :instantiate, :revisable
+        end
+
+        base.instance_eval do
+          define_callbacks :before_branch, :after_branch      
+          has_many :branches, :class_name => base.class_name, :foreign_key => :revisable_branched_from_id
+          belongs_to :branch_source, :class_name => base.class_name, :foreign_key => :revisable_branched_from_id
+
+        end
+        base.alias_method_chain :branch_source, :open_scope  
+      end
+
+      def branch_source_with_open_scope(*args, &block)
+        self.class.without_model_scope do
+          branch_source_without_open_scope(*args, &block)
+        end
+      end
+
+      def branch(*args)
+        unless run_callbacks(:before_branch) { |r, o| r == false}
+          raise ActiveRecord::RecordNotSaved
+        end
+
+        options = args.extract_options!
+        options[:revisable_branched_from_id] = self.id
+        self.class.column_names.each do |col|
+          next unless self.class.revisable_should_clone_column? col
+          options[col.to_sym] ||= self[col]
+        end
+
+        returning(self.class.revisable_class.create!(options)) do |br|
+          run_callbacks(:after_branch)
+          br.run_callbacks(:after_branch_created)
+        end
+      end
+
+      def original_id
+        self[:revisable_original_id] || self[:id]
+      end
+      
+      module ClassMethods      
+        def revisable_should_clone_column?(col)
+          return false if (REVISABLE_SYSTEM_COLUMNS + REVISABLE_UNREVISABLE_COLUMNS).member? col
+          true
+        end
+
+        def instantiate_with_revisable(record)
+          is_current = columns_hash["revisable_is_current"].type_cast(
+                record["revisable_is_current"])
+
+          if (is_current && self == self.revisable_class) || (is_current && self == self.revision_class)
+            return instantiate_without_revisable(record)
+          end
+
+          object = if is_current
+            self.revisable_class
+          else
+            self.revision_class
+          end.allocate
+
+          object.instance_variable_set("@attributes", record)
+          object.instance_variable_set("@attributes_cache", Hash.new)
+
+          if object.respond_to_without_attributes?(:after_find)
+            object.send(:callback, :after_find)
+          end
+
+          if object.respond_to_without_attributes?(:after_initialize)
+            object.send(:callback, :after_initialize)
+          end
+
+          object      
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_revisable/acts/revisable.rb

@@ -0,0 +1,247 @@
+module FatJam
+  module ActsAsRevisable
+    module Revisable
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+        
+        base.class_inheritable_hash :aa_revisable_current_revisions
+        base.aa_revisable_current_revisions = {}
+        
+        class << base
+          alias_method_chain :find, :revisable
+          alias_method_chain :with_scope, :revisable
+        end
+      
+        base.instance_eval do
+          define_callbacks :before_revise, :after_revise, :before_revert, :after_revert, :before_changeset, :after_changeset, :after_branch_created
+        
+          alias_method_chain :save, :revisable
+          alias_method_chain :save!, :revisable
+        
+          acts_as_scoped_model :find => {:conditions => {:revisable_is_current => true}}
+        
+          has_many :revisions, :class_name => revision_class_name, :foreign_key => :revisable_original_id, :order => "revisable_number DESC", :dependent => :destroy
+          has_many revision_class_name.pluralize.downcase.to_sym, :class_name => revision_class_name, :foreign_key => :revisable_original_id, :order => "revisable_number DESC", :dependent => :destroy
+          
+          before_create :before_revisable_create
+          before_update :before_revisable_update
+          after_update :after_revisable_update
+        end
+      end
+    
+      def before_revisable_create
+        self[:revisable_is_current] = true
+      end
+      
+      def should_revise?
+        return true if @aa_revisable_force_revision == true
+        return false if @aa_revisable_no_revision == true
+        return false unless self.changed?
+        !(self.changed.map(&:downcase) & self.class.revisable_columns).blank?
+      end
+      
+      def before_revisable_update
+        return unless should_revise?
+        return false unless run_callbacks(:before_revise) { |r, o| r == false}
+      
+        @revisable_revision = self.to_revision
+      end
+    
+      def after_revisable_update
+        if @revisable_revision
+          @revisable_revision.save
+          @aa_revisable_was_revised = true
+          revisions.reload
+          run_callbacks(:after_revise)
+        end
+      end
+    
+      def to_revision
+        rev = self.class.revision_class.new(@aa_revisable_new_params)
+      
+        rev.revisable_original_id = self.id
+      
+        self.class.column_names.each do |col|
+          next unless self.class.revisable_should_clone_column? col
+          val = self.send("#{col}_changed?") ? self.send("#{col}_was") : self.send(col)
+          rev.send("#{col}=", val)
+        end
+
+        @aa_revisable_new_params = nil
+      
+        rev
+      end
+    
+      def save_with_revisable!(*args)
+        @aa_revisable_new_params ||= args.extract_options!
+        @aa_revisable_no_revision = true if @aa_revisable_new_params.delete :without_revision
+        save_without_revisable!(*args)
+      end
+    
+      def save_with_revisable(*args)
+        @aa_revisable_new_params ||= args.extract_options!
+        @aa_revisable_no_revision = true if @aa_revisable_new_params.delete :without_revision
+        save_without_revisable(*args)
+      end
+    
+      def find_revision(number)
+        revisions.find_by_revisable_number(number)
+      end
+      
+      def revert_to!(*args)
+        unless run_callbacks(:before_revert) { |r, o| r == false}
+          raise ActiveRecord::RecordNotSaved
+        end
+      
+        options = args.extract_options!
+    
+        rev = case args.first
+        when self.class.revision_class
+          args.first
+        when :first
+          revisions.last
+        when :previous
+          revisions.first
+        when Fixnum
+          revisions.find_by_revisable_number(args.first)
+        when Time
+          revisions.find(:first, :conditions => ["? >= ? and ? <= ?", :revisable_revised_at, args.first, :revisable_current_at, args.first])
+        end
+    
+        unless rev.run_callbacks(:before_restore) { |r, o| r == false}
+          raise ActiveRecord::RecordNotSaved
+        end
+    
+        self.class.column_names.each do |col|
+          next unless self.class.revisable_should_clone_column? col
+          self[col] = rev[col]
+        end
+    
+        @aa_revisable_no_revision = true if options.delete :without_revision
+        @aa_revisable_new_params = options
+
+        returning(@aa_revisable_no_revision ? save! : revise!) do
+          rev.run_callbacks(:after_restore)
+          run_callbacks(:after_revert)
+        end
+      end
+    
+      def revert_to_without_revision!(*args)
+        options = args.extract_options!
+        options.update({:without_revision => true})
+        revert_to!(*(args << options))
+      end
+        
+      def revise!
+        return if in_revision?
+        
+        begin
+          @aa_revisable_force_revision = true
+          in_revision!
+          save!
+        ensure
+          in_revision!(false)
+          @aa_revisable_force_revision = false
+        end
+      end
+      
+      def revised?
+        @aa_revisable_was_revised || false
+      end
+      
+      def in_revision?
+        key = self.read_attribute(self.class.primary_key)
+        aa_revisable_current_revisions[key] || false
+      end
+      
+      def in_revision!(val=true)
+        key = self.read_attribute(self.class.primary_key)
+        aa_revisable_current_revisions[key] = val
+        aa_revisable_current_revisions.delete(key) unless val
+      end
+            
+      def changeset(&block)
+        return unless block_given?
+        
+        return yield(self) if in_revision?
+        
+        unless run_callbacks(:before_changeset) { |r, o| r == false}
+          raise ActiveRecord::RecordNotSaved
+        end
+        
+        begin
+          in_revision!
+        
+          returning(yield(self)) do
+            run_callbacks(:after_changeset)
+          end
+        ensure
+          in_revision!(false)          
+        end
+      end
+      
+      def revision_number
+        revisions.first.revisable_number
+      rescue NoMethodError
+        0
+      end
+      
+      module ClassMethods      
+        def with_scope_with_revisable(*args, &block)
+          options = (args.grep(Hash).first || {})[:find]
+
+          if options && options.delete(:with_revisions)
+            without_model_scope do
+              with_scope_without_revisable(*args, &block)
+            end
+          else
+            with_scope_without_revisable(*args, &block)
+          end
+        end
+      
+        def find_with_revisable(*args)
+          options = args.grep(Hash).first
+        
+          if options && options.delete(:with_revisions)
+            without_model_scope do
+              find_without_revisable(*args)
+            end
+          else
+            find_without_revisable(*args)
+          end
+        end
+      
+        def find_with_revisions(*args)
+          args << {} if args.grep(Hash).blank?
+          args.grep(Hash).first.update({:with_revisions => true})
+          find_with_revisable(*args)
+        end
+      
+        def revision_class_name
+          self.revisable_options.revision_class_name || "#{self.class_name}Revision"
+        end
+      
+        def revision_class
+          @aa_revision_class ||= revision_class_name.constantize
+        end
+        
+        def revisable_class
+          self
+        end
+        
+        def revisable_columns
+          return @aa_revisable_columns unless @aa_revisable_columns.blank?
+          return @aa_revisable_columns ||= [] if self.revisable_options.except == :all
+          return @aa_revisable_columns ||= [self.revisable_options.only].flatten.map(&:to_s).map(&:downcase) unless self.revisable_options.only.blank?
+                    
+          except = [self.revisable_options.except].flatten || []
+          except += REVISABLE_SYSTEM_COLUMNS
+          except += REVISABLE_UNREVISABLE_COLUMNS
+          except.uniq!
+
+          @aa_revisable_columns ||= (column_names - except.map(&:to_s)).flatten.map(&:downcase)
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_revisable/acts/revision.rb

@@ -0,0 +1,78 @@
+require 'acts_as_revisable/clone_associations'
+
+module FatJam
+  module ActsAsRevisable
+    module Revision
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+      
+        base.instance_eval do
+          set_table_name(revisable_class.table_name)
+          acts_as_scoped_model :find => {:conditions => {:revisable_is_current => false}}
+          
+          CloneAssociations.clone_associations(revisable_class, self)
+        
+          define_callbacks :before_restore, :after_restore
+        
+          belongs_to :current_revision, :class_name => revisable_class_name, :foreign_key => :revisable_original_id
+          belongs_to revisable_class_name.downcase.to_sym, :class_name  => revisable_class_name, :foreign_key => :revisable_original_id
+          
+          before_create :revision_setup
+        end
+      end
+    
+      def revision_name=(val)
+        self[:revisable_name] = val
+      end
+    
+      def revision_name
+        self[:revisable_name]
+      end
+    
+      def revision_number
+        self[:revisable_number]
+      end
+      
+      def revision_setup
+        now = Time.now
+        prev = current_revision.revisions.first
+        prev.update_attribute(:revisable_revised_at, now) if prev
+        self[:revisable_current_at] = now + 1.second
+        self[:revisable_is_current] = false
+        self[:revisable_branched_from_id] = current_revision[:revisable_branched_from_id]
+        self[:revisable_type] = current_revision[:type]
+        self[:revisable_number] = (self.class.maximum(:revisable_number, :conditions => {:revisable_original_id => self[:revisable_original_id]}) || 0) + 1
+      end
+            
+      module ClassMethods
+        def revisable_class_name
+          self.revisable_options.revisable_class_name || self.class_name.gsub(/Revision/, '')
+        end
+      
+        def revisable_class
+          @revisable_class ||= revisable_class_name.constantize
+        end
+        
+        def revision_class
+          self
+        end
+        
+        def revision_cloned_associations
+          clone_associations = self.revisable_options.clone_associations
+        
+          @aa_revisable_cloned_associations ||= if clone_associations.blank?
+            []
+          elsif clone_associations.eql? :all
+            revisable_class.reflect_on_all_associations.map(&:name)
+          elsif clone_associations.is_a? [].class
+            clone_associations
+          elsif clone_associations[:only]
+            [clone_associations[:only]].flatten
+          elsif clone_associations[:except]
+            revisable_class.reflect_on_all_associations.map(&:name) - [clone_associations[:except]].flatten
+          end        
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_revisable/acts/scoped_model.rb

@@ -0,0 +1,51 @@
+module FatJam
+  module ActsAsScopedModel
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+    
+    module ClassMethods
+      SCOPED_METHODS = %w(construct_calculation_sql construct_finder_sql update_all delete_all destroy_all).freeze
+      
+      def call_method_with_static_scope(meth, args)
+        return send(meth, *args) unless self.scoped_model_enabled
+        
+        with_scope(self.scoped_model_static_scope) do
+          send(meth, *args)
+        end
+      end
+      
+      SCOPED_METHODS.each do |m|
+        module_eval <<-EVAL
+          def #{m}_with_static_scope(*args)
+            call_method_with_static_scope(:#{m}_without_static_scope, args)
+          end
+        EVAL
+      end
+            
+      def without_model_scope
+        return unless block_given?
+        
+        begin
+          self.scoped_model_enabled = false
+          rv = yield
+        ensure
+          self.scoped_model_enabled = true
+        end
+        
+        rv
+      end
+      
+      def acts_as_scoped_model(*args)
+        class << self
+          attr_accessor :scoped_model_static_scope, :scoped_model_enabled   
+          SCOPED_METHODS.each do |m|   
+            alias_method_chain m.to_sym, :static_scope
+          end
+        end
+        self.scoped_model_enabled = true
+        self.scoped_model_static_scope = args.extract_options!
+      end
+    end
+  end
+end

data/lib/acts_as_revisable/base.rb

@@ -0,0 +1,47 @@
+require 'acts_as_revisable/options'
+require 'acts_as_revisable/acts/common'
+require 'acts_as_revisable/acts/revision'
+require 'acts_as_revisable/acts/revisable'
+
+module FatJam
+  # define the columns used internall by AAR
+  REVISABLE_SYSTEM_COLUMNS = %w(revisable_original_id revisable_branched_from_id revisable_number revisable_name revisable_type revisable_current_at revisable_revised_at revisable_deleted_at revisable_is_current)
+  
+  # define the ActiveRecord magic columns that should not be monitored
+  REVISABLE_UNREVISABLE_COLUMNS = %w(id type created_at updated_at)
+  
+  module ActsAsRevisable
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+    
+    module ClassMethods
+      
+      # This +acts_as+ extension provides for making a model the 
+      # revisable model in an acts_as_revisable pair.
+      def acts_as_revisable(*args, &block)
+        revisable_shared_setup(args, block)
+        self.send(:include, Revisable)
+      end
+      
+      # This +acts_as+ extension provides for making a model the 
+      # revision model in an acts_as_revisable pair.
+      def acts_as_revision(*args, &block)
+        revisable_shared_setup(args, block)
+        self.send(:include, Revision)
+      end
+      
+      private
+        # Performs the setup needed for both kinds of acts_as_revisable
+        # models.
+        def revisable_shared_setup(args, block)
+          self.send(:include, Common)
+          class << self
+            attr_accessor :revisable_options
+          end
+          options = args.extract_options!
+          @revisable_options = Options.new(options, &block)
+        end
+    end
+  end
+end

data/lib/acts_as_revisable/clone_associations.rb

@@ -0,0 +1,28 @@
+module FatJam
+  module ActsAsRevisable
+    module CloneAssociations
+      class << self
+        def clone_associations(from, to)
+          return unless from.descends_from_active_record? && to.descends_from_active_record?
+
+          to.revision_cloned_associations.each do |key|
+            assoc = from.reflect_on_association(key)
+            meth = "clone_#{assoc.macro.to_s}_association"
+            meth = "clone_association" unless respond_to? meth
+            send(meth, assoc, to)
+          end
+        end
+        
+        def clone_association(association, to)
+          options = association.options.clone
+          options[:foreign_key] ||= "revisable_original_id"
+          to.send(association.macro, association.name, options)
+        end
+        
+        def clone_belongs_to_association(association, to)
+          to.send(association.macro, association.name, association.options.clone)
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_revisable/options.rb

@@ -0,0 +1,22 @@
+module FatJam
+  module ActsAsRevisable
+    # This class provides for a flexible method of setting
+    # options and querying them. This is especially useful
+    # for giving users flexibility when using your plugin.
+    class Options
+      def initialize(*options, &block)
+        @options = options.extract_options!
+        instance_eval(&block) if block_given?
+      end
+
+      def method_missing(key, *args)
+        return (@options[key.to_s.gsub(/\?$/, '').to_sym].eql?(true)) if key.to_s.match(/\?$/)
+        if args.blank?
+          @options[key.to_sym]
+        else
+          @options[key.to_sym] = args.size == 1 ? args.first : args
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_revisable/quoted_columns.rb

@@ -0,0 +1,30 @@
+module FatJam::QuotedColumnConditions
+  def self.included(base)
+    base.send(:extend, ClassMethods)
+    
+    class << base
+      alias_method_chain :quote_bound_value, :quoted_column
+    end
+  end
+  
+  module ClassMethods
+    def quote_bound_value_with_quoted_column(value)
+      if value.is_a?(Symbol) && column_names.member?(value.to_s)
+        # code borrowed from sanitize_sql_hash_for_conditions
+        attr = value.to_s
+
+        # Extract table name from qualified attribute names.
+        if attr.include?('.')
+          table_name, attr = attr.split('.', 2)
+          table_name = connection.quote_table_name(table_name)
+        else
+          table_name = quoted_table_name
+        end
+        
+        return "#{table_name}.#{connection.quote_column_name(attr)}"
+      end
+      
+      quote_bound_value_without_quoted_column(value)
+    end
+  end
+end

data/lib/acts_as_revisable/version.rb

@@ -0,0 +1,11 @@
+module FatJam #:nodoc:
+  module ActsAsRevisable
+    module VERSION #:nodoc:
+      MAJOR = 0
+      MINOR = 6
+      TINY  = 0
+
+      STRING = [MAJOR, MINOR, TINY].join('.')
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'acts_as_revisable'

data/spec/aar_options_spec.rb

@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+shared_examples_for "common Options usage" do
+  it "should return a set value" do
+    @options.one.should == 1
+  end
+  
+  it "should return nil for an unset value" do
+    @options.two.should be_nil
+  end
+  
+  it "should return false for unset query option" do
+    @options.should_not be_unset_value
+  end
+  
+  it "should return true for a query option set to true" do
+    @options.should be_yes
+  end
+  
+  it "should return false for a query option set to false" do
+    @options.should_not be_no
+  end
+  
+  it "should return false for a query on a non-boolean value" do
+    @options.should_not be_one
+  end
+  
+  it "should return an array when passed one" do
+    @options.arr.should be_a_kind_of(Array)
+  end
+  
+  it "should not return an array when not passed one" do
+    @options.one.should_not be_a_kind_of(Array)
+  end
+  
+  it "should have the right number of elements in an array" do
+    @options.arr.size.should == 3
+  end
+end
+
+describe FatJam::ActsAsRevisable::Options do
+  describe "with hash options" do
+    before(:each) do
+      @options = FatJam::ActsAsRevisable::Options.new :one => 1, :yes => true, :no => false, :arr => [1,2,3]
+    end
+    
+    it_should_behave_like "common Options usage"
+  end
+  
+  describe "with block options" do
+    before(:each) do
+      @options = FatJam::ActsAsRevisable::Options.new do
+        one 1
+        yes true
+        arr [1,2,3]
+      end
+    end
+    
+    it_should_behave_like "common Options usage"
+  end
+  
+  describe "with both block and hash options" do
+    before(:each) do
+      @options = FatJam::ActsAsRevisable::Options.new(:yes => true, :arr => [1,2,3]) do
+        one 1
+      end
+    end
+    
+    it_should_behave_like "common Options usage"
+    
+    describe "the block should override the hash" do
+      before(:each) do
+        @options = FatJam::ActsAsRevisable::Options.new(:yes => false, :one => 10, :arr => [1,2,3,4,5]) do
+          one 1
+          yes true
+          arr [1,2,3]
+        end
+      end
+      
+      it_should_behave_like "common Options usage"      
+    end
+  end
+end

data/spec/acts_as_revisable_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+class Project < ActiveRecord::Base
+  acts_as_revisable do
+    revision_class_name "Session"
+    except :unimportant
+  end
+end
+
+class Session < ActiveRecord::Base
+  acts_as_revision do
+    revisable_class_name "Project"
+  end
+end
+
+describe FatJam::ActsAsRevisable do
+  before(:all) do
+    setup_db
+  end
+  
+  after(:each) do
+    cleanup_db
+  end
+  
+  after(:all) do
+    teardown_db
+  end
+  
+  before(:each) do
+    @project = Project.create(:name => "Rich", :notes => "this plugin's author")
+  end
+  
+  describe "without revisions" do
+    it "should have a revision_number of zero" do
+      @project.revision_number.should == 0
+    end
+
+    it "should have no revisions" do
+      @project.revisions.should be_empty
+    end
+  end
+  
+  describe "with revisions" do
+    before(:each) do
+      @project.update_attribute(:name, "Stephen")
+    end
+    
+    it "should have a revision_number of one" do
+      @project.revision_number.should == 1
+    end
+    
+    it "should have a single revision" do
+      @project.revisions.size.should == 1
+    end
+    
+    it "should return an instance of the revision class" do
+      @project.revisions.first.should be_an_instance_of(Session)
+    end
+    
+    it "should have the original revision's data" do
+      @project.revisions.first.name.should == "Rich"
+    end    
+  end
+  
+  describe "with excluded columns modified" do
+    before(:each) do
+      @project.update_attribute(:unimportant, "a new value")
+    end
+    
+    it "should maintain the revision_number at zero" do
+      @project.revision_number.should be_zero
+    end
+    
+    it "should not have any revisions" do
+      @project.revisions.should be_empty
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+
+if ENV['EDGE_RAILS_PATH']
+  edge_path = File.expand_path(ENV['EDGE_RAILS_PATH'])
+  require File.join(edge_path, 'activesupport', 'lib', 'active_support')
+  require File.join(edge_path, 'activerecord', 'lib', 'active_record')
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'acts_as_revisable'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+
+def setup_db
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :projects do |t|
+      t.string :name, :unimportant, :revisable_name, :revisable_type
+      t.text :notes
+      t.boolean :revisable_is_current
+      t.integer :revisable_original_id, :revisable_branched_from_id, :revisable_number
+      t.datetime :revisable_current_at, :revisable_revised_at, :revisable_deleted_at
+      t.timestamps
+    end
+  end
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
+def cleanup_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.execute("delete from #{table}")
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: rich-rich-acts_as_revisable
+version: !ruby/object:Gem::Version 
+  version: 0.6.0
+platform: ruby
+authors: 
+- Rich Cavanaugh of FatJam, LLC.
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-03 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: cavanaugh@fatjam.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- LICENSE
+- README
+- generators/revisable_migration/revisable_migration_generator.rb
+- generators/revisable_migration/templates/migration.rb
+- lib/acts_as_revisable.rb
+- lib/acts_as_revisable/acts/common.rb
+- lib/acts_as_revisable/acts/revisable.rb
+- lib/acts_as_revisable/acts/revision.rb
+- lib/acts_as_revisable/acts/scoped_model.rb
+- lib/acts_as_revisable/base.rb
+- lib/acts_as_revisable/options.rb
+- lib/acts_as_revisable/quoted_columns.rb
+- lib/acts_as_revisable/version.rb
+- lib/acts_as_revisable/clone_associations.rb
+- rails/init.rb
+- spec/acts_as_revisable_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/aar_options_spec.rb
+has_rdoc: true
+homepage: http://github.com/rich/acts_as_revisable/tree/master
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: acts_as_revisable enables revision tracking, querying, reverting and branching of ActiveRecord models. Inspired by acts_as_versioned.
+test_files: []
+