rich-acts_as_revisable 0.6.0 → 0.9.8

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008 Rich Cavanaugh
+Copyright (c) 2008 JamLab, LLC.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/{README → README.rdoc}

@@ -1,6 +1,6 @@
 = acts_as_revisable
 
-http://github.com/rich/acts_as_revisable/tree/master
+http://github.com/fatjam/acts_as_revisable/tree/master
 
 == DESCRIPTION:
 
@@ -37,7 +37,7 @@ This plugin wouldn't exist without Rick Olsen's acts_as_versioned. AAV has been
 * Uses ActiveRecord's dirty attribute tracking.
 * Several ways to find revisions including:
   * revision number
-  * relative keywords (:previous, :last)
+  * relative keywords (:first, :previous and :last)
   * timestamp
 * Reverting
 * Branching
@@ -85,40 +85,75 @@ Some example usage:
   
   @project.name = "Stephen"
   @project.save(:without_revision => true)
-  @project.name                   # => Stephen
+  @project.name                   # => "Stephen"
   @project.revision_number        # => 0
   
   @project.name = "Sam"
   @project.save(:revision_name => "Changed name")
   @project.revision_number        # => 1
-
+  
+  @project.updated_attribute(:name, "Third")
+  @project.revision_number        # => 2
+  
 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
-
+  @previous.name                  # => "Sam"
+  @previous.current_revision.name # => "Third"
+  @previous.project.name          # => "Third"
+  @previous.revision_name         # => "Changed name"
+  
+  @previous.previous.name         # => "Rich"
+  
+  # Forcing the creation of a new revision.
+  @project.updated_attribute("Rogelio")
+  @project.revision_number        # => 3
+  
+  @newest = @project.find_revision(:previous)
+  @newest.ancestors.map(&:name)   # => ["Third", "Rich"]
+  
+  @oldest = @project.find_revision(:first)
+  @oldest.descendants.map(&:name) # => ["Sam", "Third"]
+  
 Reverting:
 
   @project.revert_to!(:previous)
   @project.revision_number        # => 2
-  @project.name                   # => Rich
+  @project.name                   # => "Rich"
   
   @project.revert_to!(1, :without_revision => true)
   @project.revision_number        # => 2
-  @project.name                   # => Sam
+  @project.name                   # => "Sam"
 
-Branching
+Branching:
   
   @branch = @project.branch(:name => "Bruno")
   @branch.revision_number         # => 0
-  @branch.branch_source.name      # => Sam
+  @branch.branch_source.name      # => "Sam"
 
+Changesets:
+  
+  @project.revision_number        # => 2
+  
+  @project.changeset! do 
+    @project.name = "Josh"
+    
+    # save would normally trigger a revision
+    @project.save
+    
+    # update_attribute triggers a save triggering a revision (normally)
+    @project.updated_attribute(:name, "Chris")
+    
+    # revise! normally forces a revision to be created
+    @project.revise!
+  end
+  
+  # our revision number has only incremented by one
+  @project.revision_number        # => 3
+  
 Associations have been cloned:
 
   @project.owner === @previous.owner   # => true
@@ -146,32 +181,26 @@ If the owner isn't set let's prevent 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:
+acts_as_revisable uses Rails' new ability to use gems as plugins. Installing AAR is as simple as installing a gem:
 
-  sudo gem install rich-acts_as_revisable
+  sudo gem install fatjam-acts_as_revisable --source=http://gems.github.com
 
 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"
+  config.gem "fatjam-acts_as_revisable", :lib => "acts_as_revisable", :source => "http://gems.github.com"
 
 == LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2008
+Copyright (c) 2008 JamLab, LLC.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -0,0 +1,44 @@
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'fileutils'
+require 'lib/acts_as_revisable/version'
+require 'lib/acts_as_revisable/gem_spec_options'
+
+Rake::RDocTask.new do |rdoc|
+  files = ['README.rdoc','LICENSE','lib/**/*.rb','doc/**/*.rdoc','spec/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = 'README.rdoc'
+  rdoc.title = 'acts_as_revisable RDoc'
+  rdoc.rdoc_dir = 'doc'
+  rdoc.options << '--line-numbers' << '--inline-source'
+end
+
+spec = Gem::Specification.new do |s|
+  FatJam::ActsAsRevisable::GemSpecOptions::HASH.each do |key, value|
+    s.send("#{key.to_s}=",value)
+  end
+end
+
+Rake::GemPackageTask.new(spec) do |package|
+  package.gem_spec = spec
+end
+
+desc "Generate the static gemspec required for github."
+task :generate_gemspec do
+  options = FatJam::ActsAsRevisable::GemSpecOptions::HASH.clone
+  options[:name] = "acts_as_revisable"
+  
+  spec = ["Gem::Specification.new do |s|"]
+  options.each do |key, value|
+    spec << "  s.#{key.to_s} = #{value.inspect}"
+  end
+  spec << "end"
+  
+  open("acts_as_revisable.gemspec", "w").write(spec.join("\n"))
+end
+
+desc "Install acts_as_revisable"
+task :install => :repackage do
+    options = FatJam::ActsAsRevisable::GemSpecOptions::HASH.clone
+    sh %{sudo gem install pkg/#{options[:name]}-#{spec.version} --no-rdoc --no-ri}
+end

data/lib/acts_as_revisable/acts/common.rb

@@ -1,29 +1,68 @@
 module FatJam
   module ActsAsRevisable
+    # This module is mixed into the revision and revisable classes.
+    # 
+    # ==== Callbacks
+    # 
+    # * +before_branch+ is called on the +Revisable+ or +Revision+ that is 
+    #   being branched
+    # * +after_branch+ is called on the +Revisable+ or +Revision+ that is 
+    #   being branched
     module Common
-      def self.included(base)
+      def self.included(base) #:nodoc:
         base.send(:extend, ClassMethods)
-
+        
+        base.class_inheritable_hash :revisable_after_callback_blocks
+        base.revisable_after_callback_blocks = {}
+        
+        base.class_inheritable_hash :revisable_current_states
+        base.revisable_current_states = {}
+        
         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
+          has_many :branches, (revisable_options.revision_association_options || {}).merge({: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  
+          after_save :execute_blocks_after_save
+          disable_revisable_scope :branch_source, :branches
+        end        
       end
-
-      def branch_source_with_open_scope(*args, &block)
-        self.class.without_model_scope do
-          branch_source_without_open_scope(*args, &block)
+            
+      # Executes the blocks stored in an accessor after a save.
+      def execute_blocks_after_save #:nodoc:
+        return unless revisable_after_callback_blocks[:save]
+        revisable_after_callback_blocks[:save].each do |block|
+          block.call
         end
+        revisable_after_callback_blocks.delete(:save)
       end
-
-      def branch(*args)
+      
+      # Stores a block for later execution after a given callback.
+      # The parameter +key+ is the callback the block should be 
+      # executed after.
+      def execute_after(key, &block) #:nodoc:
+        return unless block_given?
+        revisable_after_callback_blocks[key] ||= []
+        revisable_after_callback_blocks[key] << block
+      end
+            
+      # Branch the +Revisable+ or +Revision+ and return the new 
+      # +revisable+ instance. The instance has not been saved yet.
+      # 
+      # ==== Callbacks
+      # * +before_branch+ is called on the +Revisable+ or +Revision+ that is 
+      #   being branched
+      # * +after_branch+ is called on the +Revisable+ or +Revision+ that is 
+      #   being branched
+      # * +after_branch_created+ is called on the newly created 
+      #   +Revisable+ instance.
+      def branch(*args, &block)
+        is_branching!
+        
         unless run_callbacks(:before_branch) { |r, o| r == false}
           raise ActiveRecord::RecordNotSaved
         end
@@ -32,30 +71,138 @@ module FatJam
         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]
+          options[col.to_sym] = self[col] unless options.has_key?(col.to_sym)
         end
-
-        returning(self.class.revisable_class.create!(options)) do |br|
-          run_callbacks(:after_branch)
-          br.run_callbacks(:after_branch_created)
+        
+        br = self.class.revisable_class.new(options)
+        br.is_branching!
+        
+        br.execute_after(:save) do
+          begin
+            run_callbacks(:after_branch)
+            br.run_callbacks(:after_branch_created)
+          ensure
+            br.is_branching!(false)
+            is_branching!(false)
+          end
         end
+        
+        block.call(br) if block_given?
+        
+        br
       end
-
+      
+      # Same as #branch except it calls #save! on the new +Revisable+ instance.
+      def branch!(*args)
+        branch(*args) do |br|
+          br.save!
+        end
+      end
+      
+      # Globally sets the reverting state of this record.
+      def is_branching!(value=true) #:nodoc:
+        set_revisable_state(:branching, value)
+      end
+      
+      # Returns true if the _record_ (not just this instance 
+      # of the record) is currently being branched.
+      def is_branching?
+        get_revisable_state(:branching)
+      end
+      
+      # When called on a +Revision+ it returns the original id. When
+      # called on a +Revisable+ it returns the id.
       def original_id
         self[:revisable_original_id] || self[:id]
       end
       
-      module ClassMethods      
-        def revisable_should_clone_column?(col)
+      # Globally sets the state for a given record. This is keyed
+      # on the primary_key of a saved record or the object_id
+      # on a new instance.
+      def set_revisable_state(type, value) #:nodoc:
+        key = self.read_attribute(self.class.primary_key)
+        key = object_id if key.nil?
+        revisable_current_states[type] ||= {}
+        revisable_current_states[type][key] = value
+        revisable_current_states[type].delete(key) unless value
+      end
+      
+      # Returns the state of the given record.
+      def get_revisable_state(type) #:nodoc:
+        key = self.read_attribute(self.class.primary_key)
+        revisable_current_states[type] ||= {}
+        revisable_current_states[type][key] || revisable_current_states[type][object_id] || false
+      end
+      
+      # Returns true if the instance is the first revision.
+      def first_revision?
+        self.revision_number == 1
+      end
+      
+      # Returns true if the instance is the most recent revision.
+      def latest_revision?
+        self.revision_number == self.current_revision.revision_number
+      end
+      
+      # Returns true if the instance is the current record and not a revision.
+      def current_revision?
+        self.is_a? self.class.revisable_class
+      end
+      
+      # Accessor for revisable_number just to make external API more pleasant.
+      def revision_number
+        self[:revisable_number]
+      end
+      
+      def diffs(what)
+        what = current_revision.find_revision(what)
+        returning({}) do |changes|
+          self.class.revisable_class.revisable_watch_columns.each do |c|
+            changes[c] = [self[c], what[c]] unless self[c] == what[c]
+          end
+        end
+      end
+      
+      module ClassMethods
+        def disable_revisable_scope(*args)
+          args.each do |a|            
+            class_eval <<-EOT
+              def #{a.to_s}_with_open_scope(*args, &block)
+                assoc = self.class.reflect_on_association(#{a.inspect})
+                models = [self.class]
+                
+                if [:has_many, :has_one].member? assoc.macro
+                  models << (assoc.options[:class_name] ? assoc.options[:class_name] : #{a.inspect}.to_s.singularize.camelize).constantize
+                end
+                
+                begin
+                  models.each {|m| m.scoped_model_enabled = false}
+                  if associated = #{a.to_s}_without_open_scope(*args, &block)
+                    associated.reload
+                  end
+                ensure
+                  models.each {|m| m.scoped_model_enabled = true}
+                end
+              end
+            EOT
+            alias_method_chain a, :open_scope
+          end
+        end
+        
+        # Returns true if the revision should clone the given column.    
+        def revisable_should_clone_column?(col) #:nodoc:
           return false if (REVISABLE_SYSTEM_COLUMNS + REVISABLE_UNREVISABLE_COLUMNS).member? col
           true
         end
-
-        def instantiate_with_revisable(record)
+        
+        # acts_as_revisable's override for instantiate so we can
+        # return the appropriate type of model based on whether
+        # or not the record is the current record.
+        def instantiate_with_revisable(record) #:nodoc:
           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)
+          if (is_current && self == self.revisable_class) || (!is_current && self == self.revision_class)
             return instantiate_without_revisable(record)
           end
 

data/lib/acts_as_revisable/acts/deletable.rb

@@ -0,0 +1,29 @@
+module FatJam
+  module ActsAsRevisable
+    module Deletable
+      def self.included(base)        
+        base.instance_eval do
+          alias_method_chain :destroy, :revisable
+        end
+      end
+      
+      def destroy_with_revisable
+        now = Time.now
+        
+        prev = self.revisions.first
+        self.revisable_deleted_at = now
+        self.revisable_is_current = false
+                
+        self.revisable_current_at = if prev
+          prev.update_attribute(:revisable_revised_at, now)
+          prev.revisable_revised_at + 1.second
+        else
+          self.created_at
+        end
+        
+        self.revisable_revised_at = self.revisable_deleted_at
+        self.save(:without_revision => true)
+      end
+    end
+  end
+end