rich-acts_as_revisable 0.6.0 → 0.9.8

data/lib/acts_as_revisable/acts/revision.rb

@@ -2,10 +2,22 @@ require 'acts_as_revisable/clone_associations'
 
 module FatJam
   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)
+      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)
           acts_as_scoped_model :find => {:conditions => {:revisable_is_current => false}}
@@ -13,27 +25,48 @@ module FatJam
           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
+          after_create :grab_my_branches
+          
+          [: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 revision_name=(val)
+      
+      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
     
-      def revision_name
+      # Accessor for revisable_name just to make external API more pleasant.
+      def revision_name #:nodoc:
         self[:revisable_name]
       end
-    
-      def revision_number
-        self[:revisable_number]
-      end
       
-      def revision_setup
+      # Sets some initial values for a new revision.
+      def revision_setup #:nodoc:
         now = Time.now
         prev = current_revision.revisions.first
         prev.update_attribute(:revisable_revised_at, now) if prev
@@ -43,24 +76,64 @@ module FatJam
         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
-            
+      
+      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
-        def revisable_class_name
+        # Returns the +revisable_class_name+ as configured in
+        # +acts_as_revisable+.
+        def revisable_class_name #:nodoc:
           self.revisable_options.revisable_class_name || self.class_name.gsub(/Revision/, '')
         end
       
-        def revisable_class
-          @revisable_class ||= revisable_class_name.constantize
+        # Returns the actual +Revisable+ class based on the 
+        # #revisable_class_name.
+        def revisable_class #:nodoc:
+          self.revisable_revisable_class ||= revisable_class_name.constantize
         end
         
-        def revision_class
+        # Returns the revision_class which in this case is simply +self+.
+        def revision_class #:nodoc:
           self
         end
         
-        def revision_cloned_associations
+        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.downcase
+        end
+        
+        # Returns an array of the associations that should be cloned.
+        def revision_cloned_associations #:nodoc:
           clone_associations = self.revisable_options.clone_associations
         
-          @aa_revisable_cloned_associations ||= if clone_associations.blank?
+          self.revisable_cloned_associations ||= if clone_associations.blank?
             []
           elsif clone_associations.eql? :all
             revisable_class.reflect_on_all_associations.map(&:name)

data/lib/acts_as_revisable/acts/scoped_model.rb

@@ -8,7 +8,7 @@ module FatJam
       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
+        return send(meth, *args) unless self.scoped_model_enabled?
         
         with_scope(self.scoped_model_static_scope) do
           send(meth, *args)
@@ -22,7 +22,7 @@ module FatJam
           end
         EVAL
       end
-            
+
       def without_model_scope
         return unless block_given?
         
@@ -36,14 +36,38 @@ module FatJam
         rv
       end
       
+      def disable_model_scope!
+        self.scoped_model_disable_count += 1
+      end
+      
+      def enable_model_scope!
+        self.scoped_model_disable_count -= 1
+      end
+      
+      def scoped_model_enabled?
+        self.scoped_model_disable_count == 0
+      end
+      
+      def scoped_model_enabled
+        self.scoped_model_enabled?
+      end
+      
+      def scoped_model_enabled=(value)
+        if value == false
+          disable_model_scope!
+        else
+          enable_model_scope!
+        end
+      end
+      
       def acts_as_scoped_model(*args)
         class << self
-          attr_accessor :scoped_model_static_scope, :scoped_model_enabled   
+          attr_accessor :scoped_model_static_scope, :scoped_model_disable_count   
           SCOPED_METHODS.each do |m|   
             alias_method_chain m.to_sym, :static_scope
           end
         end
-        self.scoped_model_enabled = true
+        self.scoped_model_disable_count = 0
         self.scoped_model_static_scope = args.extract_options!
       end
     end

data/lib/acts_as_revisable/base.rb

@@ -2,6 +2,7 @@ require 'acts_as_revisable/options'
 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 FatJam
   # define the columns used internall by AAR
@@ -22,25 +23,27 @@ module FatJam
       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)
+        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)
+          self.revisable_options = Options.new(options, &block)
+          
+          self.send(:include, Common)
         end
     end
   end

data/lib/acts_as_revisable/clone_associations.rb

@@ -1,3 +1,5 @@
+# This module encapsulates the methods used by ActsAsRevisable
+# for cloning associations from one model to another.
 module FatJam
   module ActsAsRevisable
     module CloneAssociations
@@ -22,6 +24,12 @@ module FatJam
         def clone_belongs_to_association(association, to)
           to.send(association.macro, association.name, association.options.clone)
         end
+        
+        def clone_has_many_association(association, to)
+          options = association.options.clone
+          options[:association_foreign_key] ||= "revisable_original_id"
+          to.send(association.macro, association.name, options)
+        end
       end
     end
   end

data/lib/acts_as_revisable/gem_spec_options.rb

@@ -0,0 +1,18 @@
+module FatJam #:nodoc:
+  module ActsAsRevisable
+    class GemSpecOptions
+      HASH = {
+        :name => "fatjam-acts_as_revisable",
+        :version => FatJam::ActsAsRevisable::VERSION::STRING,
+        :summary => "acts_as_revisable enables revision tracking, querying, reverting and branching of ActiveRecord models. Inspired by acts_as_versioned.",
+        :email => "cavanaugh@fatjam.com",
+        :homepage => "http://github.com/fatjam/acts_as_revisable/tree/master",
+        :has_rdoc => true,
+        :authors => ["Rich Cavanaugh of JamLab, LLC.", "Stephen Caudill of JamLab, LLC."],
+        :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/quoted_columns.rb

@@ -1,7 +1,19 @@
+# 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 FatJam::QuotedColumnConditions
   def self.included(base)
     base.send(:extend, ClassMethods)
-    
+
     class << base
       alias_method_chain :quote_bound_value, :quoted_column
     end
@@ -12,14 +24,7 @@ module FatJam::QuotedColumnConditions
       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
+        table_name = quoted_table_name
         
         return "#{table_name}.#{connection.quote_column_name(attr)}"
       end

data/lib/acts_as_revisable/version.rb

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

data/spec/associations_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe FatJam::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 FatJam::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/find_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe FatJam::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 provide find_with_revisions" do
+      lambda { Project.find_with_revisions(:all) }.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 current and revisions with the find_with_revisions method" do
+      Project.find_with_revisions(:all).size.should == 2
+    end
+    
+    it "should find revisions with conditions" do
+      Project.find_with_revisions(:all, :conditions => {:name => "Rich"}).should == [@project1.find_revision(:previous)]
+    end
+  end
+end

data/spec/{acts_as_revisable_spec.rb → general_spec.rb}

@@ -1,43 +1,34 @@
 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
-  
+describe FatJam::ActsAsRevisable do  
   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
+      @project.revision_number.should be_zero
     end
 
-    it "should have no revisions" do
+    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
@@ -49,10 +40,14 @@ describe FatJam::ActsAsRevisable do
       @project.revision_number.should == 1
     end
     
-    it "should have a single revision" do
+    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 return an instance of the revision class" do
       @project.revisions.first.should be_an_instance_of(Session)
     end

data/spec/quoted_columns_spec.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe "the quoted_columns extension" do      
+  after(:each) do
+    cleanup_db
+  end
+  
+  it "should quote symbols matching column names as columns" do
+    Project.send(:quote_bound_value, :name).should == %q{"projects"."name"}
+  end
+  
+  it "should not quote symbols that don't match column names" do
+    Project.send(:quote_bound_value, :whatever).should == "'#{:whatever.to_yaml}'"
+  end
+  
+  it "should not quote strings any differently" do
+    Project.send(:quote_bound_value, "what").should == Project.send(:quote_bound_value_with_quoted_column, "what")
+  end  
+end

data/spec/revert_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe FatJam::ActsAsRevisable, "with reverting" 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 let you revert to previous versions" do
+    @project.revert_to!(:first)
+    @project.name.should == "Rich"
+  end
+  
+  it "should accept the :without_revision hash option" do
+    lambda { @project.revert_to!(:first, :without_revision => true) }.should_not raise_error
+    @project.name.should == "Rich"
+  end
+  
+  it "should support the revert_to_without_revision method" do
+    lambda { @project.revert_to_without_revision(:first).save }.should_not raise_error
+    @project.name.should == "Rich"
+  end
+  
+  it "should support the revert_to_without_revision! method" do
+    lambda { @project.revert_to_without_revision!(:first) }.should_not raise_error
+    @project.name.should == "Rich"
+  end
+  
+  it "should let you revert to previous versions without a new revision" do
+    @project.revert_to!(:first, :without_revision => true)
+    @project.revisions.size.should == 1
+  end
+  
+  it "should support the revert_to method" do
+    lambda{ @project.revert_to(:first) }.should_not raise_error
+    @project.should be_changed
+  end
+end

data/spec/spec_helper.rb

@@ -19,6 +19,15 @@ ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memo
 
 def setup_db
   ActiveRecord::Schema.define(:version => 1) do
+    create_table :people do |t|
+      t.string :name, :revisable_name, :revisable_type
+      t.text :notes
+      t.boolean :revisable_is_current
+      t.integer :revisable_original_id, :revisable_branched_from_id, :revisable_number, :project_id
+      t.datetime :revisable_current_at, :revisable_revised_at, :revisable_deleted_at
+      t.timestamps
+    end
+    
     create_table :projects do |t|
       t.string :name, :unimportant, :revisable_name, :revisable_type
       t.text :notes
@@ -30,14 +39,41 @@ def setup_db
   end
 end
 
-def teardown_db
-  ActiveRecord::Base.connection.tables.each do |table|
-    ActiveRecord::Base.connection.drop_table(table)
-  end
-end
+setup_db
 
 def cleanup_db
   ActiveRecord::Base.connection.tables.each do |table|
     ActiveRecord::Base.connection.execute("delete from #{table}")
   end
+end
+
+class Person < ActiveRecord::Base
+  belongs_to :project
+  
+  acts_as_revisable do
+    revision_class_name "OldPerson"
+  end
+end
+
+class OldPerson < ActiveRecord::Base
+  acts_as_revision do
+    revisable_class_name "Person"
+    clone_associations :all
+  end
+end
+
+class Project < ActiveRecord::Base
+  has_many :people
+  
+  acts_as_revisable do
+    revision_class_name "Session"
+    except :unimportant
+  end
+end
+
+class Session < ActiveRecord::Base
+  acts_as_revision do
+    revisable_class_name "Project"
+    clone_associations :all
+  end
 end