auditable 0.1.5 → 0.1.6

data/.travis.yml

@@ -1,8 +1,13 @@
 language: ruby
 rvm:
-  - 1.8.7
-  - 1.9.2
   - 1.9.3
+  - jruby-19mode
   - ruby-head
+env:
+  - "RAILS_VERSION=3.2.0"
+  - "RAILS_VERSION=4.0.0"
+matrix:
+  allow_failures:
+    - rvm: ruby-head
 # uncomment this line if your project needs to run something other than `rake`:
 script: bundle exec rspec spec

data/Gemfile

@@ -2,3 +2,12 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in auditable.gemspec
 gemspec
+
+if rails_version = ENV["RAILS_VERSION"] || '4.0.0'
+	gem 'activerecord', "~> #{rails_version}"
+	gem 'activesupport', "~> #{rails_version}"
+
+	if rails_version == "4.0.0"
+		gem 'activerecord-jdbc-adapter', github: 'jruby/activerecord-jdbc-adapter', platform: :jruby
+	end
+end

data/auditable.gemspec

@@ -18,11 +18,15 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec', '>= 2'
   gem.add_development_dependency 'watchr'
-  gem.add_development_dependency 'sqlite3'
+  if RUBY_PLATFORM == 'java'
+    gem.add_development_dependency 'activerecord-jdbcsqlite3-adapter'
+  else
+    gem.add_development_dependency 'sqlite3'
+  end
   gem.add_development_dependency 'timecop'
-  # documetation stuff
+  # documentation stuff
   gem.add_development_dependency 'yard'
-  gem.add_development_dependency 'rdiscount'
+  gem.add_development_dependency 'kramdown'
 
   # debugger. only included if one sets DEBUGGER env variable
   if ENV['DEBUGGER']

data/lib/auditable/audit.rb

@@ -1,81 +1,7 @@
-module Auditable
-  class Audit < ActiveRecord::Base
-    belongs_to :auditable, :polymorphic => true
-    belongs_to :user, :polymorphic => true
-    serialize :modifications
-
-    attr_accessible :action, :modifications
-
-    # Diffing two audits' modifications
-    #
-    # Returns a hash containing arrays of the form
-    #   {
-    #     :key_1 => [<value_in_other_audit>, <value_in_this_audit>],
-    #     :key_2 => [<value_in_other_audit>, <value_in_this_audit>],
-    #     :other_audit_own_key => [<value_in_other_audit>, nil],
-    #     :this_audio_own_key  => [nil, <value_in_this_audit>]
-    #   }
-    def diff(other_audit)
-      other_modifications = other_audit ? other_audit.modifications : {}
-
-      {}.tap do |d|
-        # find keys present only in this audit
-        (self.modifications.keys - other_modifications.keys).each do |k|
-          d[k] = [nil, self.modifications[k]] if self.modifications[k]
-        end
-
-        # find keys present only in other audit
-        (other_modifications.keys - self.modifications.keys).each do |k|
-          d[k] = [other_modifications[k], nil] if other_modifications[k]
-        end
+require 'auditable/base'
 
-        # find common keys and diff values
-        self.modifications.keys.each do |k|
-          if self.modifications[k] != other_modifications[k]
-            d[k] = [other_modifications[k], self.modifications[k]]
-          end
-        end
-      end
-    end
-
-    # Diff this audit with the one created immediately before it
-    #
-    # See #diff for more details
-    def latest_diff(options = {})
-      if options.present?
-        scoped = auditable.audits.order("id DESC")
-        if tag = options.delete(:tag)
-          scoped = scoped.where(:tag => tag)
-        end
-        if changed_by = options.delete(:changed_by)
-          scoped = scoped.where(:user_id => changed_by.id, :user_type => changed_by.class.name)
-        end
-        if audit_tag = options.delete(:audit_tag)
-          scoped = scoped.where(:tag => audit_tag)
-        end
-        diff scoped.first
-      else
-        diff_since(created_at)
-      end
-    end
-
-    # Diff this audit with the latest audit created before the `time` variable passed
-    def diff_since(time)
-      other_audit = auditable.audits.where("created_at <= ? AND id != ?", time, id).order("id DESC").limit(1).first
-      diff(other_audit)
-   end
-
-    # Returns user object
-    #
-    # Use same method name like in update_attributes:
-    alias_attribute :changed_by, :user
-
-    def same_audited_content?(other_audit)
-      other_audit and relevant_attributes == other_audit.relevant_attributes
-    end
+module Auditable
+  class Audit < Base
 
-    def relevant_attributes
-      attributes.slice("modifications", "tag", "action", "user").reject {|k,v| v.blank? }
-    end
   end
 end

data/lib/auditable/auditing.rb

@@ -3,16 +3,109 @@ module Auditable
     extend ActiveSupport::Concern
 
     module ClassMethods
-      attr_writer :audited_attributes
 
       # Get the list of methods to track over record saves, including those inherited from parent
       def audited_attributes
-        attrs =  @audited_attributes || []
-        # handle STI case: include parent's audited_attributes
-        if superclass != ActiveRecord::Base and superclass.respond_to?(:audited_attributes)
-          attrs.push(*superclass.audited_attributes)
+        audited_cache('attributes') do |parent_class, attrs|
+          (attrs || []).push(*parent_class.audited_attributes)
         end
-        attrs
+      end
+
+      def audited_attributes=(attributes)
+        set_audited_cache( 'attributes', attributes ) do |parent_class, attrs|
+          attrs.push(*parent_class.audited_attributes)
+        end
+      end
+
+      def audited_version
+        audited_cache('version')
+      end
+
+      def audited_version=(version)
+        set_audited_cache( 'version', version )
+      end
+
+      def audited_after_create
+        audited_cache('after_create')
+      end
+
+      def audited_after_create=(after_create)
+        set_audited_cache('after_create', after_create) do |parent_class, callback|
+
+          # Disable the inherited audit create callback
+          skip_callback(:create, :after, parent_class.audited_after_create)
+
+          callback
+        end
+      end
+
+      def audited_after_update
+        audited_cache('after_update')
+      end
+
+      def audited_after_update=(after_update)
+        set_audited_cache('after_update', after_update) do |parent_class, callback|
+
+          # Disable the inherited audit create callback
+          skip_callback(:update, :after, parent_class.audited_after_update)
+
+          callback
+        end
+      end
+
+      # Set the configuration of Auditable. Optional block to access the parent class configuration setting.
+      def set_audited_cache(key,val,&blk)
+
+        if superclass != ActiveRecord::Base && superclass.respond_to?(:audited_cache)
+          if block_given?
+            begin
+              val = yield( superclass, val )
+            rescue
+              raise "Failed to create audit for #{self.name} accessing parent #{superclass.name} - #{$!}"
+            end
+          end
+        end
+
+        # init the cache, since child classes may not declare audit
+        @audited_cache ||= {}.with_indifferent_access
+        @audited_cache[key] = val
+      end
+
+      # Get the configuration of Auditable. Check the parent class for the configuration if it does not exist in the
+      # implementing class.
+      def audited_cache( key, &blk )
+
+        # init the cache, since child classes may not declare audit
+        @audited_cache ||= {}.with_indifferent_access
+        topic =  @audited_cache[key]
+
+        # Check the parent for a val
+        if topic.nil? && superclass != ActiveRecord::Base && superclass.respond_to?(:audited_cache)
+          begin
+            if block_given?
+                topic = yield( superclass, topic )
+            else
+              topic = superclass.audited_cache( key )
+            end
+          rescue
+            raise "Failed to create audit for #{self.name} accessing parent #{superclass.name} - #{$!}"
+          end
+
+          # Set cache explicitly to false if the result was nil
+          if topic.nil?
+            topic = @audited_cache[key] = false
+
+          # Coerce to symbol if a string
+          elsif topic.is_a? String
+            topic = @audited_cache[key] = topic.to_sym
+
+          # Otherwise set the cache straight up
+          else
+            @audited_cache[key] = topic
+          end
+        end
+
+        topic
       end
 
       # Set the list of methods to track over record saves
@@ -23,12 +116,50 @@ module Auditable
       #     audit :page_count, :question_ids
       #   end
       def audit(*args)
+
         options = args.extract_options!
+
+        # Setup callbacks
+        callback = options.delete(:after_create)
+        self.audited_after_create = callback if callback
+        callback = options.delete(:after_update)
+        self.audited_after_update = callback if callback
+
+        # setup changed_by
+        changed_by = options.delete(:changed_by)
+
+        if changed_by.is_a?(String) || changed_by.is_a?(Symbol) || changed_by.respond_to?(:call)
+          set_audited_cache('changed_by', changed_by)
+
+        # If inherited from parent's changed_by, do nothing
+        elsif audited_cache('changed_by')
+          # noop
+
+        # Otherwise create the default changed_by methods and set configuration in cache.
+        else
+          set_audited_cache('changed_by', :changed_by )
+          define_method(:changed_by) { @changed_by }
+          define_method(:changed_by=) { |change| @changed_by = change }
+        end
+
         options[:class_name] ||= "Auditable::Audit"
         options[:as] = :auditable
+
+        self.audited_version = options.delete(:version)
+
         has_many :audits, options
-        after_create {|record| record.snap!(:action => "create")}
-        after_update {|record| record.snap!(:action => "update")}
+
+        if self.audited_after_create
+          after_create self.audited_after_create
+        else
+          after_create :audit_create_callback
+        end
+
+        if self.audited_after_update
+          after_update self.audited_after_update
+        else
+          after_update :audit_update_callback
+        end
 
         self.audited_attributes = Array.wrap args
       end
@@ -36,53 +167,120 @@ module Auditable
 
     # INSTANCE METHODS
 
-    attr_accessor :changed_by, :audit_action, :audit_tag
+    attr_accessor :audit_action, :audit_tag
+
+    def audit_changed_by
+      changed_by_call = self.class.audited_cache('changed_by')
+
+      if changed_by_call.respond_to? :call
+        changed_by_call.call(self)
+      else
+        self.send(changed_by_call)
+      end
+    end
 
     # Get the latest audit record
     def last_audit
-      audits.last
+      # if version is enabled, use the version
+      if self.class.audited_version
+        audits.order('version DESC').first
+
+      # other pull last inserted
+      else
+        audits.last
+      end
     end
 
     # Mark the latest record with a tag in order to easily find and perform diff against later
     # If there are no audits for this record, create a new audit with this tag
     def audit_tag_with(tag)
-      if last_audit
-        last_audit.update_attribute(:tag, tag)
+      if audit = last_audit
+        audit.update_attribute(:tag, tag)
+
+        # Force the trigger of a reload if audited_version is used. Happens automatically otherwise
+        audits.reload if self.class.audited_version
       else
         self.audit_tag = tag
         snap!
       end
     end
 
+    # Take a snapshot of the current state of the audited record's audited attributes
+    def snap
+      serialize_attribute = lambda do |attribute| 
+        # If a proc, do nothing, cannot be serialized
+        # XXX: raise warning on passing in a proc?
+        if attribute.is_a? Proc
+          # noop
+         
+        # Is an ActiveRecord, serialize as hash instead of serializing the object
+        elsif attribute.class.ancestors.include?(ActiveRecord::Base)            
+          attribute.serializable_hash
+
+        # If an array, such as from an association, serialize the elements in the array
+        elsif attribute.is_a?(Array) || attribute.is_a?(ActiveRecord::Associations::CollectionProxy)
+          attribute.map { |element| serialize_attribute.call(element) }
+
+        # otherwise, return val
+        else
+          attribute
+        end
+      end
+
+      {}.tap do |s|
+        self.class.audited_attributes.each do |attr|
+          val = self.send attr
+          s[attr.to_s] = serialize_attribute.call(val)
+        end
+      end
+    end
+
     # Take a snapshot of and save the current state of the audited record's audited attributes
     #
     # Accept values for :tag, :action and :user in the argument hash. However, these are overridden by the values set by the auditable record's virtual attributes (#audit_tag, #audit_action, #changed_by) if defined
     def snap!(options = {})
-      snap = {}.tap do |s|
-        self.class.audited_attributes.each do |attr|
-          s[attr.to_s] = self.send attr
-        end
-      end
+      data = options.merge(:modifications => self.snap)
+
+      data[:tag]        = self.audit_tag    if self.audit_tag
+      data[:action]     = self.audit_action if self.audit_action
+      data[:changed_by] = self.audit_changed_by   if self.audit_changed_by
 
-      last_saved_audit = audits.last
+      self.save_audit( data )
+    end
+
+    def save_audit(data)
+      last_saved_audit = last_audit
 
       # build new audit
-      audit = audits.build(options.merge :modifications => snap)
-      audit.tag = self.audit_tag if audit_tag
-      audit.action = self.audit_action if audit_action
-      audit.changed_by = self.changed_by if changed_by
+      audit = audits.build(data)
 
       # only save if it's different from before
       if !audit.same_audited_content?(last_saved_audit)
-        audit.save
+        # If version is enabled, wrap in a transaction to get the next version number
+        # before saving
+        if self.class.audited_version
+          ActiveRecord::Base.transaction do
+            if self.class.audited_version.is_a? Symbol
+              audit.version = self.send( self.class.audited_version )
+            else
+              audit.version = (audits.maximum('version')||0) + 1
+            end
+            audit.save
+          end
+
+        # Save as usual
+        else
+          audit.save
+        end
       else
         audits.delete(audit)
       end
+
     end
 
     # Get the latest changes by comparing the latest two audits
     def audited_changes(options = {})
-      audits.last.try(:latest_diff, options) || {}
+      last_audit.try(:latest_diff, options) || {}
     end
 
     # Return last attribute's change
@@ -101,5 +299,17 @@ module Auditable
       end
       nil
     end
+
+    protected
+
+    # Create callback
+    def audit_create_callback
+      self.snap!(:action => "create")
+    end
+
+    # Update callback
+    def audit_update_callback
+      self.snap!(:action => "update")
+    end
   end
 end

data/lib/auditable/base.rb

@@ -0,0 +1,98 @@
+
+module Auditable
+  class Base < ActiveRecord::Base
+    self.abstract_class = true
+    belongs_to :auditable, :polymorphic => true
+    belongs_to :user, :polymorphic => true
+    serialize :modifications
+
+    if ActiveRecord::VERSION::STRING < "4.0.0"
+      attr_accessible :action, :modifications, :tag, :changed_by, :version
+    end
+
+    # Diffing two audits' modifications
+    #
+    # Returns a hash containing arrays of the form
+    #   {
+    #     :key_1 => [<value_in_other_audit>, <value_in_this_audit>],
+    #     :key_2 => [<value_in_other_audit>, <value_in_this_audit>],
+    #     :other_audit_own_key => [<value_in_other_audit>, nil],
+    #     :this_audio_own_key  => [nil, <value_in_this_audit>]
+    #   }
+    def diff(other_audit)
+      other_modifications = other_audit ? other_audit.modifications : {}
+
+      {}.tap do |d|
+        # find keys present only in this audit
+        (self.modifications.keys - other_modifications.keys).each do |k|
+          d[k] = [nil, self.modifications[k]] if self.modifications[k]
+        end
+
+        # find keys present only in other audit
+        (other_modifications.keys - self.modifications.keys).each do |k|
+          d[k] = [other_modifications[k], nil] if other_modifications[k]
+        end
+
+        # find common keys and diff values
+        self.modifications.keys.each do |k|
+          if self.modifications[k] != other_modifications[k]
+            d[k] = [other_modifications[k], self.modifications[k]]
+          end
+        end
+      end
+    end
+
+    # Diff this audit with the one created immediately before it
+    #
+    # See #diff for more details
+    def latest_diff(options = {})
+      if options.present?
+        scoped = auditable.class.audited_version ? auditable.audits.order("version DESC") : auditable.audits.order("id DESC")
+        if tag = options.delete(:tag)
+          scoped = scoped.where(:tag => tag)
+        end
+        if changed_by = options.delete(:changed_by)
+          scoped = scoped.where(:user_id => changed_by.id, :user_type => changed_by.class.name)
+        end
+        if audit_tag = options.delete(:audit_tag)
+          scoped = scoped.where(:tag => audit_tag)
+        end
+        diff scoped.first
+      else
+        if auditable.class.audited_version
+          diff_since_version(version)
+        else
+          diff_since(created_at)
+        end
+
+      end
+    end
+
+    # Diff this audit with the latest audit created before the `time` variable passed
+    def diff_since(time)
+      other_audit = auditable.audits.where("created_at <= ? AND id != ?", time, id).order("id DESC").limit(1).first
+
+      diff(other_audit)
+    end
+
+    # Diff this audit with the latest audit created before this version
+    def diff_since_version(version)
+      other_audit = auditable.audits.where("version <= ? AND id != ?", version, id).order("version DESC").limit(1).first
+
+      diff(other_audit)
+    end
+
+    # Returns user object
+    #
+    # Use same method name like in update_attributes:
+    alias_attribute :changed_by, :user
+
+    def same_audited_content?(other_audit)
+      other_audit and relevant_attributes == other_audit.relevant_attributes
+    end
+
+    def relevant_attributes
+      attributes.slice("modifications", "tag", "user").reject {|k,v| v.blank? }
+    end
+  end
+end

data/lib/auditable/version.rb

@@ -1,3 +1,3 @@
 module Auditable
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

data/lib/generators/auditable/migration_generator.rb

@@ -10,7 +10,7 @@ module Auditable
         @source_root ||= File.join(File.dirname(__FILE__), 'templates')
       end
 
-      # Rails expects us to override/implement this ourself
+      # Rails expects us to override/implement this our self
       def self.next_migration_number(dirname)
         if ActiveRecord::Base.timestamped_migrations
           Time.new.utc.strftime("%Y%m%d%H%M%S")

data/lib/generators/auditable/templates/migration.rb

@@ -6,10 +6,12 @@ class CreateAudits < ActiveRecord::Migration
       t.text :modifications
       t.string :action
       t.string :tag
+      t.integer :version
       t.timestamps
     end
 
     add_index :audits, [:auditable_id, :auditable_type], :name => 'auditable_index'
+    add_index :audits, [:auditable_id, :auditable_type, :version], :name => 'auditable_version_idx'
     add_index :audits, [:user_id, :user_type], :name => 'user_index'
     add_index :audits, :created_at
     add_index :audits, :action

data/lib/generators/auditable/templates/update.rb

@@ -0,0 +1,7 @@
+class UpdateAudits < ActiveRecord::Migration
+  def change
+    add_column :audits, :version, :integer
+
+    add_index :audits, [:auditable_id, :auditable_type, :version], :name => 'auditable_version_idx'
+  end
+end

data/lib/generators/auditable/update_generator.rb

@@ -0,0 +1,27 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Auditable
+  module Generators
+    class UpdateGenerator < ::Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      def self.source_root
+        @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+      end
+
+      # Rails expects us to override/implement this our self
+      def self.next_migration_number(dirname)
+        if ActiveRecord::Base.timestamped_migrations
+          Time.new.utc.strftime("%Y%m%d%H%M%S")
+        else
+          "%.3d" % (current_migration_number(dirname) + 1)
+        end
+      end
+
+      def generate_files
+        migration_template 'update.rb', 'db/migrate/update_audits.rb'
+      end
+    end
+  end
+end

data/spec/lib/auditable_spec.rb

@@ -1,9 +1,13 @@
 require 'spec_helper'
 
-describe "Model.audited_attributes" do
-  it "should be available to models using audit" do
+describe "Model class methods" do
+  it "#audited_attributes should be available using audit" do
     Survey.audited_attributes.should include :title
   end
+
+  it "#audited_version should be available using audit" do
+    Survey.audited_version.should be_true
+  end
 end
 
 describe Auditable do
@@ -21,6 +25,10 @@ describe Auditable do
     survey.audits.last.action.should == "create"
   end
 
+  it "should have a version" do
+    survey.audits.last.version.should eql 1
+  end
+
   it "should work when we have multiple audits created per second (same created_at timestamps)" do
     require 'timecop'
     Timecop.freeze do
@@ -107,7 +115,7 @@ describe Auditable do
     end
 
     it "should set audit_action" do
-      survey.update_attributes(:audit_action => "modified")
+      survey.update_attributes(:title => 'new title', :audit_action => "modified")
       survey.audits.last.action.should == "modified"
     end
 

data/spec/lib/callbacks_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe 'Auditable#callbacks' do
+
+  describe Plant do
+    let(:plant) { Plant.create :name => 'a green shrub' }
+
+    it 'should have a valid audit to start with' do
+      plant.name.should == 'a green shrub'
+      plant.audited_changes.should == {'name' => [nil, 'a green shrub']}
+      plant.audits.last.action.should == 'manual create'
+    end
+
+    it 'should create a new audit using callback' do
+      plant.should_receive(:manually_update_audit) { plant.save_audit( {'action' => 'dig', :tag => 'tagged!', 'modifications' => { 'name' => 'over ruled!' } } ) }
+      plant.update_attributes :name => 'an orange shrub'
+      plant.audited_changes.should == {'name' => ['a green shrub', 'over ruled!']}
+      plant.audits.last.action.should == 'dig'
+      plant.audits.last.tag.should == 'tagged!'
+    end
+  end
+
+  describe Tree do
+    let(:tree) { Tree.create :name => 'a tall pine', tastey: false }
+
+    it 'should inherit callback of the parent' do
+      tree.class.audited_after_create.should eql :manually_create_audit
+      tree.class.audited_after_update.should eql :manually_update_audit
+    end
+
+    it 'should have a valid audit to start with, include inherited attributes from Plant' do
+      tree.name.should == 'a tall pine'
+      tree.audits.size.should eql(1)
+      tree.audited_changes.should == {"plants"=>[nil, []], "name"=>[nil, "a tall pine"], "tastey"=>[nil, false]}
+      tree.audits.last.action.should == 'manual create'
+    end
+
+    it 'should create a new audit using callback' do
+      tree.should_receive(:manually_update_audit) { tree.save_audit( {'action' => 'dig', :tag => 'tagged!', 'modifications' => { 'name' => 'over ruled!' } } ) }
+      tree.update_attributes :name => 'a small oak'
+      tree.audited_changes.should == {"plants"=>[[], nil], "name"=>["a tall pine", "over ruled!"]}
+      tree.audits.last.action.should == 'dig'
+      tree.audits.last.tag.should == 'tagged!'
+    end
+  end
+
+  describe Kale do
+    let(:kale) { Kale.create :name => 'a bunch of leafy kale', tastey: true }
+
+    it 'should inherit the update callback of the parent' do
+      kale.class.audited_after_update.should eql :manually_update_audit
+    end
+
+    it 'should override the create callback of the parent' do
+      kale.class.audited_after_create.should eql :audit_create_callback
+    end
+
+    it 'should have a valid audit to start with, include inherited attributes from Plant' do
+      kale.name.should == 'a bunch of leafy kale'
+      kale.audits.size.should eql(1)
+      kale.audited_changes.should == {'name'=>[nil, 'a bunch of leafy kale'], 'tastey'=>[nil, true]}
+      kale.audits.last.action.should == 'audit action'
+    end
+
+    it 'should create a new audit using callback' do
+      kale.should_receive(:manually_update_audit) { kale.save_audit( {'action' => 'dig', 'modifications' => { 'name' => 'over ruled!' } } ) }
+      kale.update_attributes :name => 'a small oak'
+      kale.audited_changes.should ==  {'tastey'=>[true, nil], 'name'=>['a bunch of leafy kale', 'over ruled!']}
+      kale.audits.last.action.should == 'dig'
+    end
+  end
+end

data/spec/lib/changed_by_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe 'Auditable#changed_By' do
+
+  describe Survey do
+    let(:survey) { Survey.create :title => 'Survey', changed_by: User.create( name: 'Surveyor') }
+
+    it 'should set changed_by using default' do
+      survey.audits.last.changed_by.name.should eql 'Surveyor'
+    end
+  end
+
+  describe Plant do
+    let(:plant) { Plant.create :name => 'an odd fungus', tastey: false }
+
+    it 'should set changed_by from symbol' do
+      plant.audits.last.changed_by.name.should eql 'Bob'
+    end
+
+  end
+
+  describe Tree do
+    let(:tree) { Tree.create :name => 'a tall pine', tastey: false }
+
+    it 'should set changed_by from symbol inherited from parent' do
+      tree.audits.last.changed_by.name.should eql 'Sue'
+    end
+
+  end
+
+  describe Kale do
+    let(:kale) { Kale.create :name => 'a bunch of leafy kale', tastey: true }
+
+    it 'should set changed_by from proc' do
+      kale.audits.last.changed_by.name.should eql 'bob loves a bunch of leafy kale'
+    end
+
+  end
+end

data/spec/lib/snap_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe "Auditing#snap" do  
+  let(:weed) { Plant.create :name => 'a green shrub' }
+  let(:tree) { Tree.create :name => 'a graspy vine', plants: [weed] }
+
+  it "#snap should serialize model" do
+   	tree.snap.should eql({
+   		"tastey"=>nil, 
+   		"plants"=>[{"id"=>weed.id, "name"=>"a green shrub", "plant_id"=>tree.id, "tastey"=>nil}], 
+   		"name"=>"a graspy vine"
+   	})
+  end
+  
+end

data/spec/lib/version_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe "Auditable::Audit#version" do
+  describe Document do
+    let(:model) { Document.create(:title => "Test") }
+
+    it "#audited_version should be set to symbol" do
+      Document.audited_version.should eql :latest_version
+    end
+
+    it "should have a version" do
+      model.audits.last.version.should eql 110
+    end
+
+    it "it should call #latest_version on snap" do
+      model.should_receive(:latest_version) { 12345 }
+      model.update_attributes :title => 'Another Test'
+      model.audits.last.version.should eql 12345
+    end
+
+    it "should diff by version" do
+      model.update_attributes :title => 'Manual Version Change'
+
+      model.audited_changes.should eql({"title"=>["Test", "Manual Version Change"]})
+
+      audit = model.audits.first
+      audit.version = 7000
+      audit.save!
+
+      model.audited_changes.should eql({"title"=>["Manual Version Change", "Test"]})
+    end
+  end
+
+  describe Kale do
+    let(:kale) { Kale.create :name => "a bunch of leafy kale", tastey: true }
+
+    it "should inherit version from parent" do
+      kale.audits.last.version.should eql 1
+    end
+
+    it "should increment version on update" do
+      kale.update_attributes :name => 'a single leaf of kale'
+      kale.audits.last.version.should eql 2
+    end
+  end
+
+end

data/spec/support/models.rb

@@ -1,17 +1,64 @@
 class Survey < ActiveRecord::Base
   attr_accessor :current_page
 
-  audit :title, :current_page, :class_name => "MyAudit"
+  audit :title, :current_page, :version => true, :class_name => "MyAudit"
 end
 
 class User < ActiveRecord::Base
   audit :name
 end
 
+class Document < ActiveRecord::Base
+  self.table_name = 'surveys'
+
+  audit :title, :version => :latest_version
+
+  def latest_version
+    @counter= (@counter ||= 100) + 10
+  end
+end
+
 class MyAudit < Auditable::Audit
 
 end
 
+
+class Plant < ActiveRecord::Base
+  audit :name, :after_create => :manually_create_audit, :after_update => :manually_update_audit, changed_by: :lumberjack, :version => true
+
+  has_many :plants
+  
+  def audit_action
+    'audit action'
+  end
+
+  def manually_create_audit
+    self.save_audit( {:action => 'manual create', :changed_by => self.audit_changed_by, :modifications => self.snap } )
+  end
+
+  def manually_update_audit
+    self.save_audit( {:action => 'manual update', :changed_by => self.audit_changed_by, :tag => 'tagged!', :modifications => self.snap} )
+  end
+
+
+  def lumberjack
+    User.create( name: "Bob" )
+  end
+end
+
+class Tree < Plant
+  audit :tastey, :plants
+
+
+  def lumberjack
+    User.create( name: "Sue" )
+  end
+end
+
+class Kale < Plant
+  audit :tastey, after_create: :audit_create_callback, changed_by: Proc.new { |kale| User.create( name: "bob loves #{kale.name}") }
+end
+
 # TODO add Question class to give examples on association stuff
 
 

data/spec/support/schema.rb

@@ -12,6 +12,11 @@ class CreateTestSchema < ActiveRecord::Migration
     create_table "users", :force => true do |t|
       t.string "name"
     end
+    create_table "plants", :force => true do |t|
+      t.string "name"
+      t.boolean "tastey"
+      t.integer "plant_id"
+    end
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: auditable
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-11 00:00:00.000000000 Z
+date: 2013-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -108,7 +108,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rdiscount
+  name: kramdown
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -178,10 +178,17 @@ files:
 - lib/auditable.rb
 - lib/auditable/audit.rb
 - lib/auditable/auditing.rb
+- lib/auditable/base.rb
 - lib/auditable/version.rb
 - lib/generators/auditable/migration_generator.rb
 - lib/generators/auditable/templates/migration.rb
+- lib/generators/auditable/templates/update.rb
+- lib/generators/auditable/update_generator.rb
 - spec/lib/auditable_spec.rb
+- spec/lib/callbacks_spec.rb
+- spec/lib/changed_by_spec.rb
+- spec/lib/snap_spec.rb
+- spec/lib/version_spec.rb
 - spec/spec_helper.rb
 - spec/support/models.rb
 - spec/support/schema.rb
@@ -200,7 +207,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2404637449666859294
+      hash: -3344788208757919701
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -209,7 +216,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2404637449666859294
+      hash: -3344788208757919701
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -218,6 +225,10 @@ specification_version: 3
 summary: A simple gem to audit attributes and methods in ActiveRecord models.
 test_files:
 - spec/lib/auditable_spec.rb
+- spec/lib/callbacks_spec.rb
+- spec/lib/changed_by_spec.rb
+- spec/lib/snap_spec.rb
+- spec/lib/version_spec.rb
 - spec/spec_helper.rb
 - spec/support/models.rb
 - spec/support/schema.rb