acts_as_revisable 1.1.1

data/lib/acts_as_revisable/acts/revision.rb

@@ -0,0 +1,148 @@
+module WithoutScope
+  module ActsAsRevisable
+    # This module is mixed into the revision classes.
+    # 
+    # ==== Callbacks
+    # 
+    # * +before_restore+ is called on the revision class before it is 
+    #   restored as the current record.
+    # * +after_restore+ is called on the revision class after it is 
+    #   restored as the current record.
+    module Revision
+      def self.included(base) #:nodoc:
+        base.send(:extend, ClassMethods)
+        
+        class << base
+          attr_accessor :revisable_revisable_class, :revisable_cloned_associations
+        end
+        
+        base.instance_eval do
+          set_table_name(revisable_class.table_name)
+          default_scope :conditions => {:revisable_is_current => false}
+                  
+          define_callbacks :before_restore, :after_restore
+          before_create :revision_setup
+          after_create :grab_my_branches
+          
+          named_scope :deleted, :conditions => ["? is not null", :revisable_deleted_at]
+          
+          [:current_revision, revisable_association_name.to_sym].each do |a|
+            belongs_to a, :class_name => revisable_class_name, :foreign_key => :revisable_original_id
+          end
+          
+          [[:ancestors, "<"], [:descendants, ">"]].each do |a|
+            # Jumping through hoops here to try and make sure the
+            # :finder_sql is cross-database compatible. :finder_sql
+            # in a plugin is evil but, I see no other option.
+            has_many a.first, :class_name => revision_class_name, :finder_sql => "select * from #{quoted_table_name} where #{quote_bound_value(:revisable_original_id)} = \#{revisable_original_id} and #{quote_bound_value(:revisable_number)} #{a.last} \#{revisable_number} and #{quote_bound_value(:revisable_is_current)} = #{quote_value(false)} order by #{quote_bound_value(:revisable_number)} #{(a.last.eql?("<") ? "DESC" : "ASC")}"
+          end
+        end
+      end
+      
+      def find_revision(*args)
+        current_revision.find_revision(*args)
+      end
+      
+      # Return the revision prior to this one.
+      def previous_revision
+        self.class.find(:first, :conditions => {:revisable_original_id => revisable_original_id, :revisable_number => revisable_number - 1})
+      end
+      
+      # Return the revision after this one.
+      def next_revision
+        self.class.find(:first, :conditions => {:revisable_original_id => revisable_original_id, :revisable_number => revisable_number + 1})
+      end
+      
+      # Setter for revisable_name just to make external API more pleasant.
+      def revision_name=(val) #:nodoc:
+        self[:revisable_name] = val
+      end
+    
+      # Accessor for revisable_name just to make external API more pleasant.
+      def revision_name #:nodoc:
+        self[:revisable_name]
+      end
+      
+      # Sets some initial values for a new revision.
+      def revision_setup #:nodoc:
+        now = Time.current
+        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] || current_revision.class.name
+      end
+      
+      def grab_my_branches
+        self.class.revisable_class.update_all(["revisable_branched_from_id = ?", self[:id]], ["revisable_branched_from_id = ?", self[:revisable_original_id]])
+      end
+      
+      def from_revisable
+        current_revision.for_revision
+      end
+      
+      def reverting_from
+        from_revisable[:reverting_from]
+      end
+      
+      def reverting_from=(val)
+        from_revisable[:reverting_from] = val
+      end
+
+      def reverting_to
+        from_revisable[:reverting_to]
+      end
+      
+      def reverting_to=(val)
+        from_revisable[:reverting_to] = val
+      end
+
+      module ClassMethods
+        # Returns the +revisable_class_name+ as configured in
+        # +acts_as_revisable+.
+        def revisable_class_name #:nodoc:
+          self.revisable_options.revisable_class_name || self.name.gsub(/Revision/, '')
+        end
+      
+        # Returns the actual +Revisable+ class based on the 
+        # #revisable_class_name.
+        def revisable_class #:nodoc:
+          self.revisable_revisable_class ||= self.revisable_class_name.constantize
+        end
+        
+        # Returns the revision_class which in this case is simply +self+.
+        def revision_class #:nodoc:
+          self
+        end
+        
+        def revision_class_name #:nodoc:
+          self.name
+        end
+        
+        # Returns the name of the association acts_as_revision
+        # creates.
+        def revisable_association_name #:nodoc:
+          revisable_class_name.underscore
+        end
+        
+        # Returns an array of the associations that should be cloned.
+        def revision_cloned_associations #:nodoc:
+          clone_associations = self.revisable_options.clone_associations
+        
+          self.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/base.rb

@@ -0,0 +1,54 @@
+require 'acts_as_revisable/options'
+require 'acts_as_revisable/quoted_columns'
+require 'acts_as_revisable/validations'
+require 'acts_as_revisable/acts/common'
+require 'acts_as_revisable/acts/revision'
+require 'acts_as_revisable/acts/revisable'
+require 'acts_as_revisable/acts/deletable'
+
+module WithoutScope
+  # 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)
+        self.send(:include, Deletable) if self.revisable_options.on_delete == :revise
+      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)
+          class << self
+            attr_accessor :revisable_options
+          end
+          options = args.extract_options!
+          self.revisable_options = Options.new(options, &block)
+          
+          self.send(:include, Common)
+          self.send(:extend, Validations) unless self.revisable_options.no_validation_scoping?
+          self.send(:include, WithoutScope::QuotedColumnConditions)
+        end
+    end
+  end
+end

data/lib/acts_as_revisable/gem_spec_options.rb

@@ -0,0 +1,18 @@
+module WithoutScope #:nodoc:
+  module ActsAsRevisable
+    class GemSpecOptions
+      HASH = {
+        :name => "acts_as_revisable",
+        :version => WithoutScope::ActsAsRevisable::VERSION::STRING,
+        :summary => "acts_as_revisable enables revision tracking, querying, reverting and branching of ActiveRecord models. Inspired by acts_as_versioned.",
+        :email => "rich@withoutscope.com",
+        :homepage => "http://github.com/rich/acts_as_revisable",
+        :has_rdoc => true,
+        :authors => ["Rich Cavanaugh", "Stephen Caudill"],
+        :files => %w( LICENSE README.rdoc Rakefile ) + Dir["{spec,lib,generators,rails}/**/*"],
+        :rdoc_options => ["--main", "README.rdoc"],
+        :extra_rdoc_files => ["README.rdoc", "LICENSE"]
+      }
+    end
+  end
+end

data/lib/acts_as_revisable/options.rb

@@ -0,0 +1,22 @@
+module WithoutScope
+  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,31 @@
+# This module is more about the pretty than anything else. This allows
+# you to use symbols for column names in a conditions hash.
+#
+#   User.find(:all, :conditions => ["? = ?", :name, "sam"])
+# 
+# Would generate:
+# 
+#   select * from users where "users"."name" = 'sam'
+# 
+# This is consistent with Rails and Ruby where symbols are used to
+# represent methods. Only a symbol matching a column name will 
+# trigger this beavior.
+module WithoutScope::QuotedColumnConditions
+  def self.included(base)
+    base.send(:extend, ClassMethods)
+  end
+  
+  module ClassMethods
+    def quote_bound_value(value)
+      if value.is_a?(Symbol) && column_names.member?(value.to_s)
+        # code borrowed from sanitize_sql_hash_for_conditions
+        attr = value.to_s
+        table_name = quoted_table_name
+        
+        return "#{table_name}.#{connection.quote_column_name(attr)}"
+      end
+      
+      super(value)
+    end
+  end
+end

data/lib/acts_as_revisable/validations.rb

@@ -0,0 +1,11 @@
+module WithoutScope
+  module ActsAsRevisable
+    module Validations
+      def validates_uniqueness_of(*args)
+        options = args.extract_options!
+        (options[:scope] ||= []) << :revisable_is_current
+        super(*(args << options))
+      end
+    end
+  end
+end

data/lib/acts_as_revisable/version.rb

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

data/rails/init.rb

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

data/spec/associations_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe WithoutScope::ActsAsRevisable do  
+  after(:each) do
+    cleanup_db
+  end
+    
+  before(:each) do
+    @project = Project.create(:name => "Rich", :notes => "this plugin's author")
+    @project.update_attribute(:name, "one")
+    @project.update_attribute(:name, "two")
+    @project.update_attribute(:name, "three")
+  end
+  
+  it "should have a pretty named association" do
+    lambda { @project.sessions }.should_not raise_error
+  end
+  
+  it "should return all the revisions" do
+    @project.revisions.size.should == 3
+  end
+end

data/spec/branch_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+class Project
+  validates_presence_of :name
+end
+
+describe WithoutScope::ActsAsRevisable, "with branching" do    
+  after(:each) do
+    cleanup_db
+  end
+  
+  before(:each) do
+    @project = Project.create(:name => "Rich", :notes => "a note")
+    @project.update_attribute(:name, "Sam")
+  end
+  
+  it "should allow for branch creation" do
+    @project.should == @project.branch.branch_source
+  end
+  
+  it "should branch without saving" do
+    @project.branch.should be_new_record
+  end
+  
+  it "should branch and save" do
+    @project.branch!.should_not be_new_record
+  end
+  
+  it "should not raise an error for a valid branch" do
+    lambda { @project.branch!(:name => "A New User") }.should_not raise_error
+  end
+  
+  it "should raise an error for invalid records" do
+    lambda { @project.branch!(:name => nil) }.should raise_error
+  end
+  
+  it "should not save an invalid record" do
+    @branch = @project.branch(:name => nil)
+    @branch.save.should be_false
+    @branch.should be_new_record
+  end
+end

data/spec/deletable_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe WithoutScope::ActsAsRevisable::Deletable do    
+  after(:each) do
+    cleanup_db
+  end
+  
+  before(:each) do
+    @person = Person.create(:name => "Rich", :notes => "a note")
+    @person.update_attribute(:name, "Sam")
+  end
+  
+  it "should store a revision on destroy" do
+    lambda{ @person.destroy }.should change(OldPerson, :count).from(1).to(2)
+  end
+end

data/spec/find_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe WithoutScope::ActsAsRevisable do    
+  after(:each) do
+    cleanup_db
+  end
+  
+  describe "with a single revision" do
+    before(:each) do
+      @project1 = Project.create(:name => "Rich", :notes => "a note")
+      @project1.update_attribute(:name, "Sam")
+    end
+  
+    it "should just find the current revision by default" do
+      Project.find(:first).name.should == "Sam"
+    end
+    
+    it "should accept the :with_revisions options" do
+      lambda { Project.find(:all, :with_revisions => true) }.should_not raise_error
+    end
+        
+    it "should find current and revisions with the :with_revisions option" do      
+      Project.find(:all, :with_revisions => true).size.should == 2
+    end
+        
+    it "should find revisions with conditions" do
+      Project.find(:all, :conditions => {:name => "Rich"}, :with_revisions => true).should == [@project1.find_revision(:previous)]
+    end
+
+		it "should find last revision" do
+			@project1.find_revision(:last).should == @project1.find_revision(:previous)
+		end
+  end
+end

data/spec/general_spec.rb

@@ -0,0 +1,115 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe WithoutScope::ActsAsRevisable do  
+  after(:each) do
+    cleanup_db
+  end
+    
+  before(:each) do
+    @project = Project.create(:name => "Rich", :notes => "this plugin's author")
+    @post = Post.create(:name => 'a name')
+  end
+  
+  describe "with auto-detected revision class" do
+    it "should find the revision class" do
+      Post.revision_class.should == PostRevision
+    end
+    
+    it "should find the revisable class" do
+      PostRevision.revisable_class.should == Post
+    end
+    
+    it "should use the revision class" do
+      @post.update_attribute(:name, 'another name')
+      @post.revisions(true).first.class.should == PostRevision
+    end
+  end
+  
+  describe "with auto-generated revision class" do
+    it "should have a revision class" do
+      Foo.revision_class.should == FooRevision
+    end
+  end
+  
+  describe "without revisions" do
+    it "should have a revision_number of zero" do
+      @project.revision_number.should be_zero
+    end
+
+    it "should be the current revision" do
+      @project.revisable_is_current.should be_true
+    end
+    
+    it "should respond to current_revision? positively" do
+      @project.current_revision?.should be_true
+    end
+    
+    it "should not have any revisions in the generic association" do
+      @project.revisions.should be_empty
+    end
+    
+    it "should not have any revisions in the pretty named association" do
+      @project.sessions.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 in the generic association" do
+      @project.revisions.size.should == 1
+    end
+    
+    it "should have a single revision in the pretty named association" do
+      @project.sessions.size.should == 1
+    end
+    
+    it "should have a single revision with a revision_number of zero" do
+      @project.revisions.collect{ |rev| rev.revision_number }.should == [0]
+    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 multiple revisions" do
+    before(:each) do
+      @project.update_attribute(:name, "Stephen")
+      @project.update_attribute(:name, "Michael")
+    end
+    
+    it "should have a revision_number of two" do
+      @project.revision_number.should == 2
+    end
+    
+    it "should have revisions with revision_number values of zero and one" do
+      @project.revisions.collect{ |rev| rev.revision_number }.should == [1,0]
+    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