kkorach-acts_as_revisable 0.9.7

data/lib/acts_as_revisable/acts/revision.rb

@@ -0,0 +1,151 @@
+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) #: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}}
+          
+          CloneAssociations.clone_associations(revisable_class, self)
+        
+          define_callbacks :before_restore, :after_restore
+          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 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.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
+      
+      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.class_name.gsub(/Revision/, '')
+        end
+      
+        # Returns the actual +Revisable+ class based on the 
+        # #revisable_class_name.
+        def revisable_class #:nodoc:
+          self.revisable_revisable_class ||= 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.downcase
+        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/acts/scoped_model.rb

@@ -0,0 +1,75 @@
+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 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_disable_count   
+          SCOPED_METHODS.each do |m|   
+            alias_method_chain m.to_sym, :static_scope
+          end
+        end
+        self.scoped_model_disable_count = 0
+        self.scoped_model_static_scope = args.extract_options!
+      end
+    end
+  end
+end

data/lib/acts_as_revisable/base.rb

@@ -0,0 +1,66 @@
+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
+  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
+      
+      # This +acts_as+ extension provides for making a Single Table Inheritance model the 
+      # revisable model in an acts_as_revisable pair.
+      def acts_as_revisable_sti(*args, &block)
+        revisable_shared_setup(args, block)
+        self.send(:extend, Common::ClassMethods)
+        self.send(:extend, Revisable::ClassMethods)
+      end
+      
+      # This +acts_as+ extension provides for making a Single Table Inheritance model the 
+      # revision model in an acts_as_revisable pair.  
+      def acts_as_revision_sti(*args, &block)
+        revisable_shared_setup(args, block)
+        self.send(:extend, Common::ClassMethods)
+        self.send(:extend, Revision::ClassMethods)
+      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)
+        end
+    end
+  end
+end

data/lib/acts_as_revisable/clone_associations.rb

@@ -0,0 +1,36 @@
+# This module encapsulates the methods used by ActsAsRevisable
+# for cloning associations from one model to another.
+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
+        
+        def clone_has_many_association(association, to)
+          options = association.options.clone
+          options[:foreign_key] ||= "revisable_original_id"
+          to.send(association.macro, association.name, options)
+        end
+      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/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,35 @@
+# 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
+  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
+        table_name = quoted_table_name
+        
+        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 = 9
+      TINY  = 7
+
+      STRING = [MAJOR, MINOR, TINY].join('.')
+    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/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 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