act_as_dirty 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+/nbproject/private/
+/nbproject/

data/.rspec

@@ -0,0 +1 @@
+--color

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## v0.0.1
+
+* initial release

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in act_as_dirty.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 OrangeBrule
+
+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.

data/README.md

@@ -0,0 +1,5 @@
+Add 'act_as_dirty' to your model to gain dirty_messages functionality
+
+Add an observer to your project and save your changes to the database to create an activity log.
+
+More details coming soon.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/act_as_dirty.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "act_as_dirty/version"
+
+Gem::Specification.new do |s|
+  s.name        = "act_as_dirty"
+  s.version     = ActAsDirty::VERSION
+  s.authors     = ["Mathieu Gagne"]
+  s.email       = ["mathieu@orangebrule.com"]
+  s.homepage    = "http://github.com/orangebrule/act_as_dirty"
+  s.summary     = %q{Create a message of all changes made to a record each time it saves using ActiveModel::Dirty. }
+  s.description = %q{Keep a log of what every user does on your system. Very useful in CRM, it would allow you to easily keep track of what every user has done to the record.}
+
+  s.rubyforge_project = "act_as_dirty"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/act_as_dirty.gemspec~

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "act_as_dirty/version"
+
+Gem::Specification.new do |s|
+  s.name        = "act_as_dirty"
+  s.version     = ActAsDirty::VERSION
+  s.authors     = ["Mathieu Gagne"]
+  s.email       = ["mathieu@orangebrule.com"]
+  s.homepage    = ""
+  s.summary     = %q{TODO: Write a gem summary}
+  s.description = %q{TODO: Write a gem description}
+
+  s.rubyforge_project = "act_as_dirty"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/act_as_dirty.rb

@@ -0,0 +1,8 @@
+require "act_as_dirty/version"
+require "act_as_dirty/active_model"
+require "act_as_dirty/active_record"
+require "act_as_dirty/railtie" if defined? Rails
+
+module ActAsDirty
+  
+end

data/lib/act_as_dirty/active_model.rb

@@ -0,0 +1,13 @@
+require 'act_as_dirty/active_model/cleaner'
+require 'act_as_dirty/active_model/cleans'
+require 'act_as_dirty/active_model/dirt'
+
+module ActAsDirty  
+  module ActiveModel
+    extend ActiveSupport::Autoload
+    
+    autoload :Cleans
+    autoload :Cleaner
+    autoload :Dirt
+  end
+end

data/lib/act_as_dirty/active_model/cleaner.rb

@@ -0,0 +1,54 @@
+module ActAsDirty  
+  
+  module ActiveModel
+    
+    # == DirtyMe Cleaner
+    #
+    #
+    class Cleaner
+      attr_reader :options, :attributes
+
+      # Accepts options that will be made available through the +options+ reader.
+      def initialize(options)
+        @attributes = Array.wrap(options[:attributes])
+        raise ":attributes cannot be blank" if @attributes.empty?
+        @options = options.freeze
+      end
+
+      # Performs cleaning on the supplied record. By default this will call
+      # +clean_each+ to determine cleanliness therefore subclasses should
+      # override +clean_each+ with cleaning logic.
+      def clean(record)
+        return unless record.changed?
+        attributes.each do |attribute|
+          next unless record.changes[attribute.to_s]
+          clean_each(record, attribute)
+        end
+      end
+      
+      def clean_each(record, attribute)
+        record.dirt.set(attribute, generate_message(record, attribute))
+      end
+              
+      protected
+      
+      def generate_message record, attribute
+        changes = record.read_changes_for_cleaning(attribute)
+        if record.new_record?
+          if @options[:create]
+            message = @options[:create].call(record)
+          else
+            message = "Added #{record.class.to_s} #{attribute.to_s.humanize} #{changes[1]}"
+          end
+        elsif @options[:update]
+          message = @options[:update].call(record)
+        else
+          message = "Updated #{record.class.to_s} #{attribute.to_s.humanize} from #{changes[0]} to #{changes[1]}"
+        end
+        message
+      end
+      
+    end    
+  end
+  
+end

data/lib/act_as_dirty/active_model/cleans.rb

@@ -0,0 +1,122 @@
+module ActAsDirty
+  module ActiveModel
+    module Cleans
+    
+      extend ActiveSupport::Concern
+      include ActiveSupport::Callbacks
+      
+      included do
+        attr_accessor :cleaning_context
+        define_callbacks :clean, :scope => :name
+                
+        class_attribute :_cleaners
+        self._cleaners = Hash.new { |h,k| h[k] = [] }
+      end
+    
+      module ClassMethods
+        
+        def act_as_dirty
+          has_many :dirty_messages, :as => :dirtable, dependent: :destroy
+          accepts_nested_attributes_for :dirty_messages, :reject_if => lambda { |a| a[:message].blank? }, :allow_destroy => true
+        end
+        
+        def cleans(*attributes)
+          defaults = attributes.extract_options!
+          options = defaults.slice!(*_cleaning_default_keys)
+          
+          raise ArgumentError, 'Specify at least one attribute you would like DirtyMe to handle the message for' if attributes.empty?
+          
+          attributes = self.attribute_names.map(&:to_sym) if attributes.include? :all
+          defaults.merge!(:attributes => attributes)
+          
+          attributes.each do |attr, options|
+            raise ArgumentError, "The attribute '#{attr}' doesn't correspond to a column in the database" unless self.columns_hash[attr.to_s]            
+            cleans_with(ActAsDirty::ActiveModel::Cleaner, defaults)
+          end
+        end
+        
+        def cleans_with(*args, &block)
+          options = args.extract_options!
+          args.each do |klass|
+            cleaner = klass.new(options, &block)
+            cleaner.setup(self) if cleaner.respond_to?(:setup)
+
+            if cleaner.respond_to?(:attributes) && !cleaner.attributes.empty?
+              cleaner.attributes.each do |attribute|
+                _cleaners[attribute.to_sym] << cleaner
+              end
+            else
+              _cleaners[nil] << cleaner
+            end
+
+            clean(cleaner, options)
+          end
+        end
+        
+        def clean(*args, &block)
+          options = args.extract_options!
+          if options.key?(:on)
+            options = options.dup
+            options[:if] = Array.wrap(options[:if])
+            options[:if].unshift("cleaning_context == :#{options[:on]}")
+          end
+          args << options
+          set_callback(:clean, *args, &block)
+        end
+        
+        # List all trackers that are being used to create the message using
+        def cleaners
+          _cleaners.values.flatten.uniq
+        end
+        
+        # List all validators that being used to validate a specific attribute.
+        def cleaners_on(*attributes)
+          attributes.map do |attribute|
+            _cleaners[attribute.to_sym]
+          end.flatten
+        end
+
+        # Copy validators on inheritance.
+        def inherited(base)
+          dup = _cleaners.dup
+          base._cleaners = dup.each { |k, v| dup[k] = v.dup }
+          super
+        end
+      
+        protected
+        
+        def _cleaning_default_keys
+          [:create, :update, :delete, :using, :allow_blank, :allow_nil]
+        end
+
+      end
+      
+      def dirt
+        @dirt ||= Dirt.new(self)
+      end
+      
+      def clean?(context= nil)
+        current_context, self.cleaning_context = cleaning_context, context
+        dirt.clear
+        run_cleaners!
+      ensure
+        self.cleaning_context = current_context
+      end
+      
+      def dirty?(context = nil)
+        !clean?(context)
+      end
+      
+      def read_changes_for_cleaning(key)
+        [self.changes[key][0], self.changes[key][1]]
+      end
+        
+      protected
+          
+      def run_cleaners!
+        run_callbacks :clean
+        dirt.empty?
+      end
+    end
+  end
+end

data/lib/act_as_dirty/active_model/dirt.rb

@@ -0,0 +1,284 @@
+# -*- coding: utf-8 -*-
+
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/array/conversions'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/ordered_hash'
+
+module ActAsDirty
+  module ActiveModel
+    class Dirt
+      include Enumerable
+          
+      attr_reader :messages
+    
+      def initialize(base)
+        @base = base
+        @messages = ActiveSupport::OrderedHash.new
+      end
+      
+      # Clear the messages
+      def clear
+        messages.clear
+      end
+      
+      # Do the dirty messages include a message for the attribute +attribute+?
+      def include?(attribute)
+        (v = messages[attribute]) && v.any?
+      end
+      alias :has_key? :include?
+      
+      # Get messages for +key+
+      def get(key)
+        messages[key]
+      end
+      
+      # Set messages for +key+ to +value+
+      def set(key, value)
+        messages[key] = value
+      end
+    
+      # Delete messages for +key+
+      def delete(key)
+        messages.delete(key)
+      end
+    
+      # When passed a symbol or a name of a method, returns an array of messages
+      # for the method.
+      #
+      #   p.dirt[:name]   # => ["has been updated from Bob to John"]
+      #   p.dirt['name']  # => ["has been updated from Bob to John"]
+      def [](attribute)
+        get(attribute.to_sym) || set(attribute.to_sym, [])
+      end
+    
+      # Iterates through each error key, value pair in the error messages hash.
+      # Yields the attribute and the error for that attribute. If the attribute
+      # has more than one error message, yields once for each error message.
+      #
+      #   p.errors.add(:name, "can't be blank")
+      #   p.errors.each do |attribute, errors_array|
+      #     # Will yield :name and "can't be blank"
+      #   end
+      #
+      #   p.errors.add(:name, "must be specified")
+      #   p.errors.each do |attribute, errors_array|
+      #     # Will yield :name and "can't be blank"
+      #     # then yield :name and "must be specified"
+      #   end
+      def each
+        messages.each_key do |attribute|
+          yield attribute
+        end
+      end
+      
+      # Returns the number of error messages.
+      #
+      #   p.dirt.add(:name, "has been updated from Bob to John")
+      #   p.dirt.size # => 1
+      #   p.dirt.add(:name, "has been updated from Bob to John")
+      #   p.dirt.size # => 2
+#      def size
+#        values.flatten.size
+#      end
+      
+      # Returns all message values
+      def values
+        messages.values
+      end
+      
+      # Returns all message keys
+      def keys
+        messages.keys
+      end
+      
+      # Returns an array of dirty messages, with the attribute name included
+      #
+      #   p.dirt.add(:name, "has been updated from Bob to John")
+      #   p.dirt.add(:nickname, "has been updated from Bobby to Johnny")
+      #   p.dirt.to_a # => ["Name has been updated from Bob to John", "Nickname has been updated from Bobby to Johnny"]
+      def to_a
+        full_messages
+      end
+    
+      # Returns the number of dirty messages.
+      def count
+        to_a.size
+      end
+    
+      # Returns true if no dirty messages are found, false otherwise.
+      # If the dirty message is a string it can be empty.
+      def empty?
+        values.compact.empty?
+      end
+      alias_method :blank?, :empty?
+
+      # Returns an xml formatted representation of the Dirt hash.
+      #
+      #   p.dirt.add(:name, "has been updated from Bob to John")
+      #   p.dirt.add(:nickname, "has been updated from Bobby to Johnny")
+      #   p.dirt.to_xml
+      #   # =>
+      #   #  <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+      #   #  <dirts>
+      #   #    <dirt>name has been updated from Bob to John</dirt>
+      #   #    <dirt>name has been updated from Bobby to Johnny</dirt>
+      #   #  </dirts>
+      def to_xml(options={})
+        to_a.to_xml options.reverse_merge(:root => "dirts", :skip_types => true)
+      end
+    
+      # Returns an ActiveSupport::OrderedHash that can be used as the JSON representation for this object.
+      def as_json(options=nil)
+        to_hash
+      end
+
+      def to_hash
+        messages.dup
+      end
+
+      # Adds +message+ to the dirty messages on +attribute+. More than one error can be added to the same
+      # +attribute+.
+      # If no +message+ is supplied, <tt>:invalid</tt> is assumed.
+      #
+      # If +message+ is a symbol, it will be translated using the appropriate scope (see +translate_dirt+).
+      # If +message+ is a proc, it will be called, allowing for things like <tt>Time.now</tt> to be used within an error.
+#      def add(attribute, message = nil, options = {})
+#        message = normalize_message(attribute, message, options)
+#        self[attribute] << message
+#      end
+
+      # Will add a dirty message to each of the attributes in +attributes+ that is empty.
+#      def add_on_empty(attributes, options = {})
+#        [attributes].flatten.each do |attribute|
+#          value = @base.send(:read_attribute_for_cleaning, attribute)
+#          is_empty = value.respond_to?(:empty?) ? value.empty? : false
+#          add(attribute, :empty, options) if value.nil? || is_empty
+#        end
+#      end
+#
+#      # Will add a dirty message to each of the attributes in +attributes+ that is blank (using Object#blank?).
+#      def add_on_blank(attributes, options = {})
+#        [attributes].flatten.each do |attribute|
+#          value = @base.send(:read_attribute_for_cleaning, attribute)
+#          add(attribute, :blank, options) if value.blank?
+#        end
+#      end
+
+      # Returns true if a dirty message on the attribute with the given message is present, false otherwise.
+      # +message+ is treated the same as for +add+.
+      #   p.dirt.add :name, :blank
+      #   p.dirt.added? :name, :blank # => true
+#      def added?(attribute, message = nil, options = {})
+#        message = normalize_message(attribute, message, options)
+#        self[attribute].include? message
+#      end
+
+      def added?(attribute)
+        keys.include? attribute && messages[attribute].present?
+      end
+      
+#      # Returns all the full error messages in an array.
+#      #
+#      #   class User
+#      #     cleans :name, :nickname, :email
+#      #   end
+#      #
+#      #   company = Company.create(:name => "John Doe", :nickname => "Johnny", :email => "john@example.com")
+#      #   company.dirt.full_messages # =>
+#      #     ["Added John Doe as a name", "Added Johnny as a nickname", "Added john@example.com as an email"]
+      def full_messages
+#        map { |attribute, message| full_message(attribute, message) }
+        values.flatten
+      end
+
+#      # Returns a full message for a given attribute.
+#      #
+#      #   user.dirt.full_message(:name)  # =>
+#      #     "Added John Doe as a name"
+#      def full_message(attribute, message)
+#        return message if attribute == :base
+#        attr_name = attribute.to_s.gsub('.', '_').humanize
+#        attr_name = @base.class.human_attribute_name(attribute, :default => attr_name)
+#        I18n.t(:"errors.format", {
+#            :default   => "%{attribute} %{message}",
+#            :attribute => attr_name,
+#            :message   => message
+#          })
+#      end
+
+      # Translates a dirty message in its default scope
+      # (<tt>activemodel.dirty.messages</tt>).
+      #
+      # Dirty messages are first looked up in <tt>models.MODEL.attributes.ATTRIBUTE.MESSAGE</tt>,
+      # if it's not there, it's looked up in <tt>models.MODEL.MESSAGE</tt> and if that is not
+      # there also, it returns the translation of the default message
+      # (e.g. <tt>activemodel.errors.messages.MESSAGE</tt>). The translated model name,
+      # translated attribute name and the value are available for interpolation.
+      #
+      # When using inheritance in your models, it will check all the inherited
+      # models too, but only if the model itself hasn't been found. Say you have
+      # <tt>class Admin < User; end</tt> and you wanted the translation for
+      # the <tt>:blank</tt> error message for the <tt>title</tt> attribute,
+      # it looks for these translations:
+      #
+      # * <tt>activemodel.dirty.models.admin.attributes.title.blank</tt>
+      # * <tt>activemodel.dirty.models.admin.blank</tt>
+      # * <tt>activemodel.dirty.models.user.attributes.title.blank</tt>
+      # * <tt>activemodel.dirty.models.user.blank</tt>
+      # * any default you provided through the +options+ hash (in the <tt>activemodel.dirty</tt> scope)
+      # * <tt>activemodel.dirty.messages.blank</tt>
+      # * <tt>dirty.attributes.title.blank</tt>
+      # * <tt>dirty.messages.blank</tt>
+      #
+      def generate_message(attribute, type = :invalid, options = {})
+        type = options.delete(:message) if options[:message].is_a?(Symbol)
+
+        if @base.class.respond_to?(:i18n_scope)
+          defaults = @base.class.lookup_ancestors.map do |klass|
+            [ :"#{@base.class.i18n_scope}.dirty.models.#{klass.model_name.i18n_key}.attributes.#{attribute}.#{type}",
+              :"#{@base.class.i18n_scope}.dirty.models.#{klass.model_name.i18n_key}.#{type}" ]
+          end
+        else
+          defaults = []
+        end
+
+        defaults << options.delete(:message)
+        defaults << :"#{@base.class.i18n_scope}.dirty.messages.#{type}" if @base.class.respond_to?(:i18n_scope)
+        defaults << :"dirty.attributes.#{attribute}.#{type}"
+        defaults << :"dirty.messages.#{type}"
+
+        defaults.compact!
+        defaults.flatten!
+
+        key = defaults.shift
+        value = (attribute != :base ? @base.send(:read_attribute_for_cleaning, attribute) : nil)
+
+        options = {
+          :default => defaults,
+          :model => @base.class.model_name.human,
+          :attribute => @base.class.human_attribute_name(attribute),
+          :value => value
+        }.merge(options)
+
+        I18n.translate(key, options)
+      end
+
+      private
+      def normalize_message(attribute, message, options)
+        message ||= :invalid
+
+        if message.is_a?(Symbol)
+          generate_message(attribute, message, options.except(*CALLBACKS_OPTIONS))
+        elsif message.is_a?(Proc)
+          message.call
+        else
+          message
+        end
+      end
+        
+    end  
+  end
+end

data/lib/act_as_dirty/active_record.rb

@@ -0,0 +1,9 @@
+require 'act_as_dirty/active_model'
+require 'act_as_dirty/active_record/cleans'
+
+module ActAsDirty  
+  module ActiveRecord
+    extend ActiveSupport::Autoload    
+    autoload :Cleans    
+  end
+end

data/lib/act_as_dirty/active_record/cleans.rb

@@ -0,0 +1,31 @@
+module ActAsDirty  
+  module ActiveRecord    
+    module Cleans
+      extend ActiveSupport::Concern
+      include ActAsDirty::ActiveModel::Cleans
+      
+      def save(options={})
+        perform_cleanings(options)
+        super
+      end
+      
+      def clean?(context = nil)
+        context ||= (new_record? ? :create : :update)
+        output = super(context)
+        dirt.empty? && output
+      end
+      
+      def dirty?(context = nil)
+        !clean?(context)
+      end
+      
+      protected
+      
+      def perform_cleanings(options={})
+        perform_cleaning = options[:clean] != false
+        perform_cleaning ? clean?(options[:context]) : true
+      end
+      
+    end    
+  end  
+end

data/lib/act_as_dirty/railtie.rb

@@ -0,0 +1,10 @@
+module ActAsDirty
+  class Railtie < Rails::Railtie
+    initializer 'act_as_dirty' do
+      ActiveSupport.on_load :active_record do
+        include ActAsDirty::ActiveModel::Cleans
+        include ActAsDirty::ActiveRecord::Cleans
+      end
+    end
+  end
+end

data/lib/act_as_dirty/version.rb

@@ -0,0 +1,3 @@
+module ActAsDirty
+  VERSION = "0.0.1"
+end

data/lib/act_as_dirty/version.rb~

@@ -0,0 +1,3 @@
+module ActAsDirty
+  VERSION = "0.0.1"
+end

data/spec/act_as_dirty/dirty_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe ActAsDirty do
+  
+  it "should have tests" do
+    pending "Port your tests to the gem to prove the world you are not an idiot."
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'rails'
+require 'act_as_dirty'

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: act_as_dirty
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Mathieu Gagne
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &12388040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12388040
+description: Keep a log of what every user does on your system. Very useful in CRM,
+  it would allow you to easily keep track of what every user has done to the record.
+email:
+- mathieu@orangebrule.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- act_as_dirty.gemspec
+- act_as_dirty.gemspec~
+- lib/act_as_dirty.rb
+- lib/act_as_dirty/active_model.rb
+- lib/act_as_dirty/active_model/cleaner.rb
+- lib/act_as_dirty/active_model/cleans.rb
+- lib/act_as_dirty/active_model/dirt.rb
+- lib/act_as_dirty/active_record.rb
+- lib/act_as_dirty/active_record/cleans.rb
+- lib/act_as_dirty/railtie.rb
+- lib/act_as_dirty/version.rb
+- lib/act_as_dirty/version.rb~
+- spec/act_as_dirty/dirty_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/orangebrule/act_as_dirty
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: act_as_dirty
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Create a message of all changes made to a record each time it saves using
+  ActiveModel::Dirty.
+test_files: []