RubyGems - acts_as_audited_rails3 - Versions diffs - 1.1.1.4 - Mend

acts_as_audited_rails3 1.1.1.4

Files changed (39) hide show

data/.gitignore +4 -0
data/CHANGELOG +25 -0
data/LICENSE +19 -0
data/README +76 -0
data/Rakefile +60 -0
data/VERSION +1 -0
data/acts_as_audited.gemspec +90 -0
data/acts_as_audited_rails3.gemspec +90 -0
data/doc/classes/Audit.html +407 -0
data/doc/classes/CollectiveIdea/Acts/Audited/ClassMethods.html +226 -0
data/doc/classes/CollectiveIdea/Acts/Audited/InstanceMethods.html +330 -0
data/doc/classes/CollectiveIdea/Acts/Audited/SingletonMethods.html +254 -0
data/doc/created.rid +1 -0
data/doc/files/README.html +226 -0
data/doc/files/lib/acts_as_audited/audit_rb.html +108 -0
data/doc/files/lib/acts_as_audited/audit_sweeper_rb.html +101 -0
data/doc/files/lib/acts_as_audited_rb.html +129 -0
data/doc/fr_class_index.html +30 -0
data/doc/fr_file_index.html +30 -0
data/doc/fr_method_index.html +47 -0
data/doc/index.html +24 -0
data/doc/rdoc-style.css +208 -0
data/lib/acts_as_audited/audit.rb +119 -0
data/lib/acts_as_audited/audit_sweeper.rb +37 -0
data/lib/acts_as_audited/base.rb +316 -0
data/lib/acts_as_audited.rb +9 -0
data/lib/generators/audited_migration/USAGE +7 -0
data/lib/generators/audited_migration/audited_migration_generator.rb +24 -0
data/lib/generators/audited_migration/templates/migration.rb +29 -0
data/lib/generators/audited_migration_update/USAGE +7 -0
data/lib/generators/audited_migration_update/audited_migration_update_generator.rb +24 -0
data/lib/generators/audited_migration_update/templates/migration.rb +9 -0
data/test/acts_as_audited_test.rb +437 -0
data/test/audit_sweeper_test.rb +31 -0
data/test/audit_test.rb +179 -0
data/test/db/database.yml +21 -0
data/test/db/schema.rb +33 -0
data/test/test_helper.rb +75 -0
metadata +152 -0

data/doc/index.html ADDED Viewed

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html
+     PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">
+<!--
+    acts_as_audited
+  -->
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <title>acts_as_audited</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+</head>
+<frameset rows="20%, 80%">
+    <frameset cols="25%,35%,45%">
+        <frame src="fr_file_index.html"   title="Files" name="Files" />
+        <frame src="fr_class_index.html"  name="Classes" />
+        <frame src="fr_method_index.html" name="Methods" />
+    </frameset>
+    <frame src="files/README.html" name="docwin" />
+</frameset>
+</html>

data/doc/rdoc-style.css ADDED Viewed

@@ -0,0 +1,208 @@
+body {
+    font-family: Verdana,Arial,Helvetica,sans-serif;
+    font-size:   90%;
+    margin: 0;
+    margin-left: 40px;
+    padding: 0;
+    background: white;
+}
+h1,h2,h3,h4 { margin: 0; color: #efefef; background: transparent; }
+h1 { font-size: 150%; }
+h2,h3,h4 { margin-top: 1em; }
+a { background: #eef; color: #039; text-decoration: none; }
+a:hover { background: #039; color: #eef; }
+/* Override the base stylesheet's Anchor inside a table cell */
+td > a {
+  background: transparent;
+  color: #039;
+  text-decoration: none;
+}
+/* and inside a section title */
+.section-title > a {
+  background: transparent;
+  color: #eee;
+  text-decoration: none;
+}
+/* === Structural elements =================================== */
+div#index {
+    margin: 0;
+    margin-left: -40px;
+    padding: 0;
+    font-size: 90%;
+}
+div#index a {
+    margin-left: 0.7em;
+}
+div#index .section-bar {
+   margin-left: 0px;
+   padding-left: 0.7em;
+   background: #ccc;
+   font-size: small;
+}
+div#classHeader, div#fileHeader {
+    width: auto;
+    color: white;
+    padding: 0.5em 1.5em 0.5em 1.5em;
+    margin: 0;
+    margin-left: -40px;
+    border-bottom: 3px solid #006;
+}
+div#classHeader a, div#fileHeader a {
+    background: inherit;
+    color: white;
+}
+div#classHeader td, div#fileHeader td {
+    background: inherit;
+    color: white;
+}
+div#fileHeader {
+    background: #057;
+}
+div#classHeader {
+    background: #048;
+}
+.class-name-in-header {
+  font-size:  180%;
+  font-weight: bold;
+}
+div#bodyContent {
+    padding: 0 1.5em 0 1.5em;
+}
+div#description {
+    padding: 0.5em 1.5em;
+    background: #efefef;
+    border: 1px dotted #999;
+}
+div#description h1,h2,h3,h4,h5,h6 {
+    color: #125;;
+    background: transparent;
+}
+div#validator-badges {
+    text-align: center;
+}
+div#validator-badges img { border: 0; }
+div#copyright {
+    color: #333;
+    background: #efefef;
+    font: 0.75em sans-serif;
+    margin-top: 5em;
+    margin-bottom: 0;
+    padding: 0.5em 2em;
+}
+/* === Classes =================================== */
+table.header-table {
+    color: white;
+    font-size: small;
+}
+.type-note {
+    font-size: small;
+    color: #DEDEDE;
+}
+.xxsection-bar {
+    background: #eee;
+    color: #333;
+    padding: 3px;
+}
+.section-bar {
+   color: #333;
+   border-bottom: 1px solid #999;
+    margin-left: -20px;
+}
+.section-title {
+    background: #79a;
+    color: #eee;
+    padding: 3px;
+    margin-top: 2em;
+    margin-left: -30px;
+    border: 1px solid #999;
+}
+.top-aligned-row {  vertical-align: top }
+.bottom-aligned-row { vertical-align: bottom }
+/* --- Context section classes ----------------------- */
+.context-row { }
+.context-item-name { font-family: monospace; font-weight: bold; color: black; }
+.context-item-value { font-size: small; color: #448; }
+.context-item-desc { color: #333; padding-left: 2em; }
+/* --- Method classes -------------------------- */
+.method-detail {
+    background: #efefef;
+    padding: 0;
+    margin-top: 0.5em;
+    margin-bottom: 1em;
+    border: 1px dotted #ccc;
+}
+.method-heading {
+  color: black;
+  background: #ccc;
+  border-bottom: 1px solid #666;
+  padding: 0.2em 0.5em 0 0.5em;
+}
+.method-signature { color: black; background: inherit; }
+.method-name { font-weight: bold; }
+.method-args { font-style: italic; }
+.method-description { padding: 0 0.5em 0 0.5em; }
+/* --- Source code sections -------------------- */
+a.source-toggle { font-size: 90%; }
+div.method-source-code {
+    background: #262626;
+    color: #ffdead;
+    margin: 1em;
+    padding: 0.5em;
+    border: 1px dashed #999;
+    overflow: hidden;
+}
+div.method-source-code pre { color: #ffdead; overflow: hidden; }
+/* --- Ruby keyword styles --------------------- */
+.standalone-code { background: #221111; color: #ffdead; overflow: hidden; }
+.ruby-constant  { color: #7fffd4; background: transparent; }
+.ruby-keyword { color: #00ffff; background: transparent; }
+.ruby-ivar    { color: #eedd82; background: transparent; }
+.ruby-operator  { color: #00ffee; background: transparent; }
+.ruby-identifier { color: #ffdead; background: transparent; }
+.ruby-node    { color: #ffa07a; background: transparent; }
+.ruby-comment { color: #b22222; font-weight: bold; background: transparent; }
+.ruby-regexp  { color: #ffa07a; background: transparent; }
+.ruby-value   { color: #7fffd4; background: transparent; }

data/lib/acts_as_audited/audit.rb ADDED Viewed

@@ -0,0 +1,119 @@
+require 'set'
+# Audit saves the changes to ActiveRecord models.  It has the following attributes:
+#
+# * <tt>auditable</tt>: the ActiveRecord model that was changed
+# * <tt>user</tt>: the user that performed the change; a string or an ActiveRecord model
+# * <tt>action</tt>: one of create, update, or delete
+# * <tt>audit_changes</tt>: a serialized hash of all the changes
+# * <tt>created_at</tt>: Time that the change was performed
+#
+class Audit < ActiveRecord::Base
+  belongs_to :auditable, :polymorphic => true
+  belongs_to :user, :polymorphic => true
+  before_create :set_version_number, :set_audit_user
+  serialize :audit_changes
+  cattr_accessor :audited_class_names
+  self.audited_class_names = Set.new
+  def self.audited_classes
+    self.audited_class_names.map(&:constantize)
+  end
+  # All audits made during the block called will be recorded as made
+  # by +user+. This method is hopefully threadsafe, making it ideal
+  # for background operations that require audit information.
+  def self.as_user(user, &block)
+    Thread.current[:acts_as_audited_user] = user
+    yield
+    Thread.current[:acts_as_audited_user] = nil
+  end
+  # Allows user to be set to either a string or an ActiveRecord object
+  def user_as_string=(user) #:nodoc:
+    # reset both either way
+    self.user_as_model = self.username = nil
+    user.is_a?(ActiveRecord::Base) ?
+      self.user_as_model = user :
+      self.username = user
+  end
+  alias_method :user_as_model=, :user=
+  alias_method :user=, :user_as_string=
+  def user_as_string #:nodoc:
+    self.user_as_model || self.username
+  end
+  alias_method :user_as_model, :user
+  alias_method :user, :user_as_string
+  def revision
+    clazz = auditable_type.constantize
+    returning clazz.find_by_id(auditable_id) || clazz.new do |m|
+      Audit.assign_revision_attributes(m, self.class.reconstruct_attributes(ancestors).merge({:version => version}))
+    end
+  end
+  def ancestors
+    self.class.find(:all, :order => 'version',
+      :conditions => ['auditable_id = ? and auditable_type = ? and version <= ?',
+      auditable_id, auditable_type, version])
+  end
+  # Returns a hash of the changed attributes with the new values
+  def new_attributes
+    (audit_changes || {}).inject({}.with_indifferent_access) do |attrs,(attr,values)|
+      attrs[attr] = values.is_a?(Array) ? values.last : values
+      attrs
+    end
+  end
+  # Returns a hash of the changed attributes with the old values
+  def old_attributes
+    (audit_changes || {}).inject({}.with_indifferent_access) do |attrs,(attr,values)|
+      attrs[attr] = Array(values).first
+      attrs
+    end
+  end
+  def self.reconstruct_attributes(audits)
+    attributes = {}
+    result = audits.collect do |audit|
+      attributes.merge!(audit.new_attributes).merge!(:version => audit.version)
+      yield attributes if block_given?
+    end
+    block_given? ? result : attributes
+  end
+  def self.assign_revision_attributes(record, attributes)
+    attributes.each do |attr, val|
+      if record.respond_to?("#{attr}=")
+        record.attributes.has_key?(attr.to_s) ?
+          record[attr] = val :
+          record.send("#{attr}=", val)
+      end
+    end
+    record
+  end
+private
+  def set_version_number
+    max = self.class.maximum(:version,
+      :conditions => {
+        :auditable_id => auditable_id,
+        :auditable_type => auditable_type
+      }) || 0
+    self.version = max + 1
+  end
+  def set_audit_user
+    self.user = Thread.current[:acts_as_audited_user] if Thread.current[:acts_as_audited_user]
+    nil # prevent stopping callback chains
+  end
+end

data/lib/acts_as_audited/audit_sweeper.rb ADDED Viewed

@@ -0,0 +1,37 @@
+module CollectiveIdea #:nodoc:
+  module ActionController #:nodoc:
+    module Audited #:nodoc:
+      def audit(*models)
+        ActiveSupport::Deprecation.warn("#audit is deprecated. Declare #acts_as_audited in your models.", caller)
+        options = models.extract_options!
+        # Parse the options hash looking for classes
+        options.each_key do |key|
+          models << [key, options.delete(key)] if key.is_a?(Class)
+        end
+        models.each do |(model, model_options)|
+          model.send :acts_as_audited, model_options || {}
+        end
+      end
+    end
+  end
+end
+class AuditSweeper < ActionController::Caching::Sweeper #:nodoc:
+  observe Audit
+  def before_create(audit)
+    audit.user ||= current_user
+  end
+  def current_user
+    controller.send :current_user if controller.respond_to?(:current_user, true)
+  end
+end
+ActionController::Base.class_eval do
+  extend CollectiveIdea::ActionController::Audited
+  cache_sweeper :audit_sweeper
+end
+Audit.add_observer(AuditSweeper.instance)

data/lib/acts_as_audited/base.rb ADDED Viewed

@@ -0,0 +1,316 @@
+# Copyright (c) 2006 Brandon Keepers
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+module CollectiveIdea #:nodoc:
+  module Acts #:nodoc:
+    # Specify this act if you want changes to your model to be saved in an
+    # audit table.  This assumes there is an audits table ready.
+    #
+    #   class User < ActiveRecord::Base
+    #     acts_as_audited
+    #   end
+    #
+    # To store an audit comment set model.audit_comment to your comment before
+    # a create, update or destroy operation.
+    #
+    # See <tt>CollectiveIdea::Acts::Audited::ClassMethods#acts_as_audited</tt>
+    # for configuration options
+    module Audited #:nodoc:
+      CALLBACKS = [:audit_create, :audit_update, :audit_destroy]
+      def self.included(base) # :nodoc:
+        base.extend ClassMethods
+      end
+      module ClassMethods
+        # == Configuration options
+        #
+        #
+        # * +only+ - Only audit the given attributes
+        # * +except+ - Excludes fields from being saved in the audit log.
+        #   By default, acts_as_audited will audit all but these fields:
+        #
+        #     [self.primary_key, inheritance_column, 'lock_version', 'created_at', 'updated_at']
+        #   You can add to those by passing one or an array of fields to skip.
+        #
+        #     class User < ActiveRecord::Base
+        #       acts_as_audited :except => :password
+        #     end
+        # * +protect+ - set to false to raise an error if your model uses +attr_protected+, by default it is true
+        #
+        # * +require_comment+ - Ensures that audit_comment is supplied before
+        #   any create, update or destroy operation.
+        #
+        #     class User < ActiveRecord::Base
+        #       acts_as_audited :protect => false
+        #       attr_accessible :name
+        #     end
+        # * +full_model_enabled+ - in YAML, save the current state of the record to the audits table
+        # * +full_model_enabled+ - in YAML, save the current state of the record to the audits table
+        #
+        def acts_as_audited(options = {})
+          # don't allow multiple calls
+          return if self.included_modules.include?(CollectiveIdea::Acts::Audited::InstanceMethods)
+          class_inheritable_reader :auditing_full_model_enabled
+          write_inheritable_attribute :auditing_full_model_enabled, (false || options[:full_model_enabled])
+          options = {:protect => true}.merge(options)
+          class_inheritable_reader :non_audited_columns
+          class_inheritable_reader :auditing_enabled
+          if options[:only]
+            except = self.column_names - options[:only].flatten.map(&:to_s)
+          else
+            except = [self.primary_key, inheritance_column, 'lock_version',
+              'created_at', 'updated_at', 'created_on', 'updated_on', 'created_by', 'updated_by']
+            except |= Array(options[:except]).collect(&:to_s) if options[:except]
+          end
+          write_inheritable_attribute :non_audited_columns, ['audits'] + (except || [])
+          if options[:comment_required]
+            validates_presence_of :audit_comment
+            before_destroy :require_comment
+          end
+          attr_accessor :audit_comment
+          unless accessible_attributes.nil? || options[:protect]
+            attr_accessible :audit_comment
+          end
+          has_many :audits, :as => :auditable, :order => "#{Audit.quoted_table_name}.version"
+          attr_protected :audit_ids if options[:protect]
+          Audit.audited_class_names << self.to_s
+          after_create  :audit_create if !options[:on] || (options[:on] && options[:on].include?(:create))
+          before_update :audit_update if !options[:on] || (options[:on] && options[:on].include?(:update))
+          after_destroy :audit_destroy if !options[:on] || (options[:on] && options[:on].include?(:destroy))
+          attr_accessor :version
+          extend CollectiveIdea::Acts::Audited::SingletonMethods
+          include CollectiveIdea::Acts::Audited::InstanceMethods
+          write_inheritable_attribute :auditing_enabled, true
+        end
+      end
+      module InstanceMethods
+        # Temporarily turns off auditing while saving.
+        def save_without_auditing
+          without_auditing { save }
+        end
+        # Executes the block with the auditing callbacks disabled.
+        #
+        #   @foo.without_auditing do
+        #     @foo.save
+        #   end
+        #
+        def without_auditing(&block)
+          self.class.without_auditing(&block)
+        end
+        # Gets an array of the revisions available
+        #
+        #   user.revisions.each do |revision|
+        #     user.name
+        #     user.version
+        #   end
+        #
+        def revisions(from_version = 1)
+          audits = self.audits.find(:all, :conditions => ['version >= ?', from_version])
+          return [] if audits.empty?
+          revision = self.audits.find_by_version(from_version).revision
+          Audit.reconstruct_attributes(audits) {|attrs| revision.revision_with(attrs) }
+        end
+        # Get a specific revision specified by the version number, or +:previous+
+        def revision(version)
+          revision_with Audit.reconstruct_attributes(audits_to(version))
+        end
+        def revision_at(date_or_time)
+          audits = self.audits.find(:all, :conditions => ["created_at <= ?", date_or_time])
+          revision_with Audit.reconstruct_attributes(audits) unless audits.empty?
+        end
+        def audited_attributes
+          attributes.except(*non_audited_columns)
+        end
+        protected
+        def revision_with(attributes)
+          returning self.dup do |revision|
+            revision.send :instance_variable_set, '@attributes', self.attributes_before_type_cast
+            Audit.assign_revision_attributes(revision, attributes)
+            # Remove any association proxies so that they will be recreated
+            # and reference the correct object for this revision. The only way
+            # to determine if an instance variable is a proxy object is to
+            # see if it responds to certain methods, as it forwards almost
+            # everything to its target.
+            for ivar in revision.instance_variables
+              proxy = revision.instance_variable_get ivar
+              if !proxy.nil? and proxy.respond_to? :proxy_respond_to?
+                revision.instance_variable_set ivar, nil
+              end
+            end
+          end
+        end
+        private
+        def audited_changes
+          changed_attributes.except(*non_audited_columns).inject({}) do |changes,(attr, old_value)|
+            changes[attr] = [old_value, self[attr]]
+            changes
+          end
+        end
+        def audits_to(version = nil)
+          if version == :previous
+            version = if self.version
+              self.version - 1
+            else
+              previous = audits.find(:first, :offset => 1,
+                :order => "#{Audit.quoted_table_name}.version DESC")
+              previous ? previous.version : 1
+            end
+          end
+          audits.find(:all, :conditions => ['version <= ?', version])
+        end
+        def audit_create
+          write_audit(:action => 'create', :audit_changes => audited_attributes,
+            :comment => audit_comment)
+        end
+        def audit_update
+          unless (changes = audited_changes).empty?
+            write_audit(:action => 'update', :audit_changes => changes,
+              :comment => audit_comment)
+          end
+        end
+        def audit_destroy
+          write_audit(:action => 'destroy', :audit_changes => audited_attributes,
+            :comment => audit_comment)
+        end
+        # Note- with to_yaml it's easy to get into some sort of recursion issues.  If you see something like:
+        #    yaml TypeError: wrong argument type nil (expected Data)
+        # check to see what other model objects are being pulled in; you may want to limit them.  For example, the RequestProgram was pulling in
+        # request as an attribute.  This caused issues.  I solved this by adding not pulling in request_programs into YAML via the to_yaml_properties_with_specific method.
+        # In general, you want to stay away from linking objects like RequestProgram and instead use one that list programs.
+        def write_audit(attrs)
+          self.audit_comment = nil
+          if auditing_full_model_enabled
+            # Grab all the object attributes and dump them into a Map, then turn the map into YAML and store in the Audit table
+            self.class.reflect_on_all_associations.each {|assn| self.send assn.name.to_sym} # Load up all associations to store in the full_model serialization
+            ignore_properties = if non_audited_columns
+              non_audited_columns.map {|prop| "@#{prop.to_s}"}
+            else
+              []
+            end
+            props = (self.to_yaml_properties.map{|y| y.strip} - ignore_properties)
+            attributes_map = props.inject({}) do |acc, name|
+              name = name.gsub /@/, ''
+              begin
+                if self.respond_to? name.to_sym
+                  val = self.send name.to_sym
+                  unless val.blank? || (val.is_a?(Array) && val.empty?)
+                    acc[name.to_sym] = val
+                  end
+                end
+              rescue Exception => exception
+                error_msg = "Error serializing property #{name}; got exception #{exception.to_s} with backtrace #{exception.backtrace.inspect}"
+                p error_msg
+                logger.error error_msg
+              end
+              acc
+            end
+            attributes_map[:attributes] = self.attributes.except(*non_audited_columns)
+            attrs[:full_model] = attributes_map.to_yaml
+          end
+          self.audits.create attrs if auditing_enabled
+        end
+        def require_comment
+          if audit_comment.blank?
+            errors.add(:audit_comment, "Comment required before destruction")
+            return false
+          end
+        end
+        CALLBACKS.each do |attr_name|
+          alias_method "#{attr_name}_callback".to_sym, attr_name
+        end
+        def empty_callback #:nodoc:
+        end
+      end # InstanceMethods
+      module SingletonMethods
+        # Returns an array of columns that are audited.  See non_audited_columns
+        def audited_columns
+          self.columns.select { |c| !non_audited_columns.include?(c.name) }
+        end
+        # Executes the block with auditing disabled.
+        #
+        #   Foo.without_auditing do
+        #     @foo.save
+        #   end
+        #
+        def without_auditing(&block)
+          auditing_was_enabled = auditing_enabled
+          disable_auditing
+          returning(block.call) { enable_auditing if auditing_was_enabled }
+        end
+        def disable_auditing
+          write_inheritable_attribute :auditing_enabled, false
+        end
+        def enable_auditing
+          write_inheritable_attribute :auditing_enabled, true
+        end
+        # All audit operations during the block are recorded as being
+        # made by +user+. This is not model specific, the method is a
+        # convenience wrapper around #Audit.as_user.
+        def audit_as( user, &block )
+          Audit.as_user( user, &block )
+        end
+      end
+    end
+  end
+end