audited 4.6.0 → 4.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 11243e8bfb9c50162f0f939a283270f7bf706387
-  data.tar.gz: 9b081dea623844e1bd37b71f774490dc8596ef84
+  metadata.gz: 6a2d5a695157822691d7e8a980742c9dab27769c
+  data.tar.gz: 41262a1baa392f65fd172c6971985ca43ab53e92
 SHA512:
-  metadata.gz: f5ca8463b13d3c2fc463749a1ff46c1522b5ed6c049dd743e72d47577c5da025f46f3ab90492fa19a88cfbf7cd38ee302e2aefced16098dcd3bd7846a6be0eb9
-  data.tar.gz: e4e5b349f6a8db618deb7a6fd48a853eb75729ddbff3b78c431c89247ec17aaceb2e4a67dd206defbfeb5fe4e8b6a47c4af0212c5898fd777848c08625aca90e
+  metadata.gz: f4d0ebf2b9683b96d7954efb7e2ddab5c21e3c0cea29d9d7388334a9f9215f8729b337c850f60abf9b9084773158609d32e99ab580aec244393dc79d41846fad
+  data.tar.gz: 32a48ffa57d8ebd24ece8714b4c26c8c0a0af4ed7021f165a625a619c058c71749510e20417e9a15629385e72b999409b39186e050af10f5cf73ad36760b25b5

data/.travis.yml

@@ -2,9 +2,10 @@ language: ruby
 cache: bundler
 rvm:
   - 2.1
-  - 2.2.8
-  - 2.3.5
-  - 2.4.2
+  - 2.2.9
+  - 2.3.6
+  - 2.4.3
+  - 2.5.0
   - ruby-head
 env:
   - DB=SQLITE
@@ -12,6 +13,10 @@ env:
   - DB=MYSQL
 addons:
   postgresql: "9.4"
+before_install:
+  # https://github.com/travis-ci/travis-ci/issues/8978
+  - "travis_retry gem update --system"
+  - "travis_retry gem install bundler"
 gemfile:
   - gemfiles/rails40.gemfile
   - gemfiles/rails41.gemfile
@@ -29,9 +34,13 @@ matrix:
       gemfile: gemfiles/rails51.gemfile
     - rvm: 2.1
       gemfile: gemfiles/rails52.gemfile
-    - rvm: 2.4.2
+    - rvm: 2.4.3
       gemfile: gemfiles/rails40.gemfile
-    - rvm: 2.4.2
+    - rvm: 2.4.3
+      gemfile: gemfiles/rails41.gemfile
+    - rvm: 2.5.0
+      gemfile: gemfiles/rails40.gemfile
+    - rvm: 2.5.0
       gemfile: gemfiles/rails41.gemfile
     - rvm: ruby-head
       gemfile: gemfiles/rails40.gemfile

data/Appraisals

@@ -23,6 +23,6 @@ appraise 'rails51' do
 end
 
 appraise 'rails52' do
-  gem 'rails', '>= 5.2.0.beta2', '< 5.3'
+  gem 'rails', '>= 5.2.0.rc1', '< 5.3'
   gem 'mysql2', '~> 0.4.4'
 end

data/CHANGELOG.md

@@ -18,6 +18,38 @@ Fixed
 
 - None
 
+## 4.7.0 (2018-03-14)
+
+Breaking changes
+
+- None
+
+Added
+
+- Add `inverse_of: auditable` definition to audit relation
+  [#413](https://github.com/collectiveidea/audited/pull/413)
+- Add functionality to conditionally audit models
+  [#414](https://github.com/collectiveidea/audited/pull/414)
+- Allow limiting number of audits stored
+  [#405](https://github.com/collectiveidea/audited/pull/405)
+
+Changed
+
+- Reduced db calls in `#revisions` method
+  [#402](https://github.com/collectiveidea/audited/pull/402)
+  [#403](https://github.com/collectiveidea/audited/pull/403)
+- Update supported Ruby and Rails versions
+  [#404](https://github.com/collectiveidea/audited/pull/404)
+  [#409](https://github.com/collectiveidea/audited/pull/409)
+  [#415](https://github.com/collectiveidea/audited/pull/415)
+  [#416](https://github.com/collectiveidea/audited/pull/416)
+
+Fixed
+
+- Ensure that `on` and `except` options jive with `comment_required: true`
+  [#419](https://github.com/collectiveidea/audited/pull/419)
+- Fix RSpec matchers
+  [#420](https://github.com/collectiveidea/audited/pull/420)
 
 ## 4.6.0 (2018-01-10)
 

data/README.md

@@ -12,9 +12,10 @@ For Rails 3, use gem version 3.0 or see the [3.0-stable branch](https://github.c
 Audited supports and is [tested against](http://travis-ci.org/collectiveidea/audited) the following Ruby versions:
 
 * 2.1.10
-* 2.2.8
-* 2.3.5
-* 2.4.2
+* 2.2.9
+* 2.3.6
+* 2.4.3
+* 2.5.0
 
 Audited may work just fine with a Ruby version not listed above, but we can't guarantee that it will. If you'd like to maintain a Ruby that isn't listed, please let us know with a [pull request](https://github.com/collectiveidea/audited/pulls).
 
@@ -27,7 +28,7 @@ Audited is currently ActiveRecord-only. In a previous life, Audited worked with
 Add the gem to your Gemfile:
 
 ```ruby
-gem "audited", "~> 4.6"
+gem "audited", "~> 4.7"
 ```
 
 Then, from your Rails app directory, create the `audits` table:
@@ -141,6 +142,33 @@ class User < ActiveRecord::Base
 end
 ```
 
+### Limiting stored audits
+
+You can limit the number of audits stored for your model. To configure limiting for all audited models, put the following in an initializer:
+
+```ruby
+Audited.max_audits = 10 # keep only 10 latest audits
+```
+
+or customize per model:
+
+```ruby
+class User < ActiveRecord::Base
+  audited max_audits: 2
+end
+```
+
+Whenever an object is updated or destroyed, extra audits are combined with newer ones and the old ones are destroyed.
+
+```ruby
+user = User.create!(name: "Steve")
+user.audits.count # => 1
+user.update_attributes!(name: "Ryan")
+user.audits.count # => 2
+user.destroy
+user.audits.count # => 2
+```
+
 ### Current User Tracking
 
 If you're using Audited in a Rails application, all audited changes made within a request will automatically be attributed to the current user. By default, Audited uses the `current_user` method in your controller.
@@ -227,6 +255,32 @@ user.audits.last.associated # => #<Company name: "Collective Idea">
 company.associated_audits.last.auditable # => #<User name: "Steve Richert">
 ```
 
+### Conditional auditing
+
+If you want to audit only under specific conditions, you can provide conditional options (similar to ActiveModel callbacks) that will ensure your model is only audited for these conditions.
+
+```ruby
+class User < ActiveRecord::Base
+  audited if: :active?
+
+  private
+
+  def active?
+    last_login > 6.months.ago
+  end
+end
+```
+
+Just like in ActiveModel, you can use an inline Proc in your conditions:
+
+```ruby
+class User < ActiveRecord::Base
+  audited unless: Proc.new { |u| u.ninja? }
+end
+```
+
+In the above case, the user will only be audited when `User#ninja` is `false`.
+
 ### Disabling auditing
 
 If you want to disable auditing temporarily doing certain tasks, there are a few
@@ -278,30 +332,6 @@ Audited.config do |config|
 end
 ```
 
-## Gotchas
-
-### Using attr_protected with Rails 4.x
-
-If you're using the `protected_attributes` gem with Rails 4.0, 4.1 or 4.2 (the gem isn't supported in Rails 5.0 or higher), you'll have to take an extra couple of steps to get `audited` working.
-
-First be sure to add `allow_mass_assignment: true` to your `audited` call; otherwise Audited will
-interfere with `protected_attributes` and none of your `save` calls will work.
-
-```ruby
-class User < ActiveRecord::Base
-  audited allow_mass_assignment: true
-end
-```
-
-Second, be sure to add `audit_ids` to the list of protected attributes to prevent data loss.
-
-```ruby
-class User < ActiveRecord::Base
-  audited allow_mass_assignment: true
-  attr_protected :logins, :audit_ids
-end
-```
-
 ## Support
 
 You can find documentation at: http://rdoc.info/github/collectiveidea/audited

data/gemfiles/rails52.gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "rails", ">= 5.2.0.beta2", "< 5.3"
+gem "rails", ">= 5.2.0.rc1", "< 5.3"
 gem "mysql2", "~> 0.4.4"
 
 gemspec name: "audited", path: "../"

data/lib/audited.rb

@@ -2,7 +2,7 @@ require 'active_record'
 
 module Audited
   class << self
-    attr_accessor :ignored_attributes, :current_user_method
+    attr_accessor :ignored_attributes, :current_user_method, :max_audits
     attr_writer :audit_class
 
     def audit_class

data/lib/audited/auditor.rb

@@ -33,6 +33,18 @@ module Audited
       #
       # * +require_comment+ - Ensures that audit_comment is supplied before
       #   any create, update or destroy operation.
+      # * +max_audits+ - Limits the number of stored audits.
+      #
+      # * +if+ - Only audit the model when the given function returns true
+      # * +unless+ - Only audit the model when the given function returns false
+      #
+      #     class User < ActiveRecord::Base
+      #       audited :if => :active?
+      #
+      #       def active?
+      #         self.status == 'active'
+      #       end
+      #     end
       #
       def audited(options = {})
         # don't allow multiple calls
@@ -41,7 +53,7 @@ module Audited
         extend Audited::Auditor::AuditedClassMethods
         include Audited::Auditor::AuditedInstanceMethods
 
-        class_attribute :audit_associated_with,   instance_writer: false
+        class_attribute :audit_associated_with, instance_writer: false
         class_attribute :audited_options,       instance_writer: false
         attr_accessor :version, :audit_comment
 
@@ -51,11 +63,11 @@ module Audited
         self.audit_associated_with = audited_options[:associated_with]
 
         if audited_options[:comment_required]
-          validates_presence_of :audit_comment, if: :auditing_enabled
-          before_destroy :require_comment
+          validate :presence_of_audit_comment
+          before_destroy :require_comment if audited_options[:on].include?(:destroy)
         end
 
-        has_many :audits, -> { order(version: :asc) }, as: :auditable, class_name: Audited.audit_class.name
+        has_many :audits, -> { order(version: :asc) }, as: :auditable, class_name: Audited.audit_class.name, inverse_of: :auditable
         Audited.audit_class.audited_class_names << to_s
 
         after_create :audit_create    if audited_options[:on].include?(:create)
@@ -101,9 +113,17 @@ module Audited
       #   end
       #
       def revisions(from_version = 1)
-        audits = self.audits.from_version(from_version)
-        return [] if audits.empty?
-        audits.map(&:revision)
+        return [] unless audits.from_version(from_version).exists?
+
+        all_audits = audits.select([:audited_changes, :version]).to_a
+        targeted_audits = all_audits.select { |audit| audit.version >= from_version }
+
+        previous_attributes = reconstruct_attributes(all_audits - targeted_audits)
+
+        targeted_audits.map do |audit|
+          previous_attributes.merge!(audit.new_attributes)
+          revision_with(previous_attributes.merge!(version: audit.version))
+        end
       end
 
       # Get a specific revision specified by the version number, or +:previous+
@@ -125,6 +145,18 @@ module Audited
         attributes.except(*non_audited_columns)
       end
 
+      # Combine multiple audits into one.
+      def combine_audits(audits_to_combine)
+        combine_target = audits_to_combine.last
+        combine_target.audited_changes = audits_to_combine.pluck(:audited_changes).reduce(&:merge)
+        combine_target.comment = "#{combine_target.comment}\nThis audit is the result of multiple audits being combined."
+
+        transaction do
+          combine_target.save!
+          audits_to_combine.unscope(:limit).where("version < ?", combine_target.version).delete_all
+        end
+      end
+
       protected
 
       def non_audited_columns
@@ -208,14 +240,41 @@ module Audited
       def write_audit(attrs)
         attrs[:associated] = send(audit_associated_with) unless audit_associated_with.nil?
         self.audit_comment = nil
-        run_callbacks(:audit)  { audits.create(attrs) } if auditing_enabled
+
+        if auditing_enabled
+          run_callbacks(:audit) {
+            audit = audits.create(attrs)
+            combine_audits_if_needed if attrs[:action] != 'create'
+            audit
+          }
+        end
+      end
+
+      def presence_of_audit_comment
+        if comment_required_state?
+          errors.add(:audit_comment, "Comment can't be blank!") unless audit_comment.present?
+        end
+      end
+
+      def comment_required_state?
+        auditing_enabled &&
+          ((audited_options[:on].include?(:create) && self.new_record?) ||
+          (audited_options[:on].include?(:update) && self.persisted? && self.changed?))
+      end
+
+      def combine_audits_if_needed
+        max_audits = audited_options[:max_audits]
+        if max_audits && (extra_count = audits.count - max_audits) > 0
+          audits_to_combine = audits.limit(extra_count + 1)
+          combine_audits(audits_to_combine)
+        end
       end
 
       def require_comment
         if auditing_enabled && audit_comment.blank?
-          errors.add(:audit_comment, "Comment required before destruction")
+          errors.add(:audit_comment, "Comment can't be blank!")
           return false if Rails.version.start_with?('4.')
-          throw :abort
+          throw(:abort)
         end
       end
 
@@ -224,12 +283,29 @@ module Audited
       end
 
       def auditing_enabled
-        self.class.auditing_enabled
+        return run_conditional_check(audited_options[:if]) &&
+          run_conditional_check(audited_options[:unless], matching: false) &&
+          self.class.auditing_enabled
+      end
+
+      def run_conditional_check(condition, matching: true)
+        return true if condition.blank?
+
+        return condition.call(self) == matching if condition.respond_to?(:call)
+        return send(condition) == matching if respond_to?(condition.to_sym)
+
+        true
       end
 
       def auditing_enabled=(val)
         self.class.auditing_enabled = val
       end
+
+      def reconstruct_attributes(audits)
+        attributes = {}
+        audits.each { |audit| attributes.merge!(audit.new_attributes) }
+        attributes
+      end
     end # InstanceMethods
 
     module AuditedClassMethods
@@ -240,9 +316,7 @@ module Audited
 
       # We have to calculate this here since column_names may not be available when `audited` is called
       def non_audited_columns
-        @non_audited_columns ||= audited_options[:only].present? ?
-                                 column_names - audited_options[:only] :
-                                 default_ignored_attributes | audited_options[:except]
+        @non_audited_columns ||= calculate_non_audited_columns
       end
 
       def non_audited_columns=(columns)
@@ -288,16 +362,29 @@ module Audited
         Audited.store["#{table_name}_auditing_enabled"] = val
       end
 
-      protected
       def default_ignored_attributes
-        [primary_key, inheritance_column] + Audited.ignored_attributes
+        [primary_key, inheritance_column] | Audited.ignored_attributes
       end
 
+      protected
+
       def normalize_audited_options
         audited_options[:on] = Array.wrap(audited_options[:on])
         audited_options[:on] = [:create, :update, :destroy] if audited_options[:on].empty?
         audited_options[:only] = Array.wrap(audited_options[:only]).map(&:to_s)
         audited_options[:except] = Array.wrap(audited_options[:except]).map(&:to_s)
+        max_audits = audited_options[:max_audits] || Audited.max_audits
+        audited_options[:max_audits] = Integer(max_audits).abs if max_audits
+      end
+
+      def calculate_non_audited_columns
+        if audited_options[:only].present?
+          (column_names | default_ignored_attributes) - audited_options[:only]
+        elsif audited_options[:except].present?
+          default_ignored_attributes | audited_options[:except]
+        else
+          default_ignored_attributes
+        end
       end
     end
   end

data/lib/audited/rspec_matchers.rb

@@ -41,12 +41,12 @@ module Audited
       end
 
       def only(*fields)
-        @options[:only] = fields.flatten
+        @options[:only] = fields.flatten.map(&:to_s)
         self
       end
 
       def except(*fields)
-        @options[:except] = fields.flatten
+        @options[:except] = fields.flatten.map(&:to_s)
         self
       end
 
@@ -56,16 +56,13 @@ module Audited
       end
 
       def on(*actions)
-        @options[:on] = actions.flatten
+        @options[:on] = actions.flatten.map(&:to_sym)
         self
       end
 
       def matches?(subject)
         @subject = subject
-        auditing_enabled? &&
-          associated_with_model? &&
-          records_changes_to_specified_fields? &&
-          comment_required_valid?
+        auditing_enabled? && required_checks_for_options_satisfied?
       end
 
       def failure_message
@@ -109,31 +106,83 @@ module Audited
       end
 
       def records_changes_to_specified_fields?
-        if @options[:only] || @options[:except]
-          if @options[:only]
-            except = model_class.column_names - @options[:only].map(&:to_s)
-          else
-            except = model_class.default_ignored_attributes + Audited.ignored_attributes
-            except |= @options[:except].collect(&:to_s) if @options[:except]
-          end
+        ignored_fields = build_ignored_fields_from_options
+
+        expects "non audited columns (#{model_class.non_audited_columns.inspect}) to match (#{ignored_fields})"
+        model_class.non_audited_columns.to_set == ignored_fields.to_set
+      end
+
+      def comment_required_valid?
+        expects "to require audit_comment before #{model_class.audited_options[:on]} when comment required"
+        validate_callbacks_include_presence_of_comment? && destroy_callbacks_include_comment_required?
+      end
 
-          expects "non audited columns (#{model_class.non_audited_columns.inspect}) to match (#{except})"
-          model_class.non_audited_columns =~ except
+      def only_audit_on_designated_callbacks?
+        {
+          create: [:after, :audit_create],
+          update: [:before, :audit_update],
+          destroy: [:before, :audit_destroy]
+        }.map do |(action, kind_callback)|
+          kind, callback = kind_callback
+          callbacks_for(action, kind: kind).include?(callback) if @options[:on].include?(action)
+        end.compact.all?
+      end
+
+      def validate_callbacks_include_presence_of_comment?
+        if @options[:comment_required] && audited_on_create_or_update?
+          callbacks_for(:validate).include?(:presence_of_audit_comment)
         else
           true
         end
       end
 
-      def comment_required_valid?
-        if @options[:comment_required]
-          @subject.audit_comment = nil
+      def audited_on_create_or_update?
+        model_class.audited_options[:on].include?(:create) || model_class.audited_options[:on].include?(:update)
+      end
 
-          expects "to be invalid when audit_comment is not specified"
-          @subject.valid? == false && @subject.errors.key?(:audit_comment)
+      def destroy_callbacks_include_comment_required?
+        if @options[:comment_required] && model_class.audited_options[:on].include?(:destroy)
+          callbacks_for(:destroy).include?(:require_comment)
         else
           true
         end
       end
+
+      def requires_comment_before_callbacks?
+        [:create, :update, :destroy].map do |action|
+          if @options[:comment_required] && model_class.audited_options[:on].include?(action)
+            callbacks_for(action).include?(:require_comment)
+          end
+        end.compact.all?
+      end
+
+      def callbacks_for(action, kind: :before)
+        model_class.send("_#{action}_callbacks").select { |cb| cb.kind == kind }.map(&:filter)
+      end
+
+      def build_ignored_fields_from_options
+        default_ignored_attributes = model_class.default_ignored_attributes
+
+        if @options[:only].present?
+          (default_ignored_attributes | model_class.column_names) - @options[:only]
+        elsif @options[:except].present?
+          default_ignored_attributes | @options[:except]
+        else
+          default_ignored_attributes
+        end
+      end
+
+      def required_checks_for_options_satisfied?
+        {
+          only: :records_changes_to_specified_fields?,
+          except: :records_changes_to_specified_fields?,
+          comment_required: :comment_required_valid?,
+          associated_with: :associated_with_model?,
+          on: :only_audit_on_designated_callbacks?
+        }.map do |(option, check)|
+          send(check) if @options[option].present?
+        end.compact.all?
+      end
     end
 
     class AssociatedAuditMatcher # :nodoc:

data/lib/audited/version.rb

@@ -1,3 +1,3 @@
 module Audited
-  VERSION = "4.6.0"
+  VERSION = "4.7.0"
 end

data/spec/audited/auditor_spec.rb

@@ -17,6 +17,114 @@ describe Audited::Auditor do
       end
     end
 
+    context "should be configurable which conditions are audited" do
+      subject { ConditionalCompany.new.send(:auditing_enabled) }
+
+      context "when passing a method name" do
+        before do
+          class ConditionalCompany < ::ActiveRecord::Base
+            self.table_name = 'companies'
+
+            audited if: :public?
+
+            def public?; end
+          end
+        end
+
+        context "when conditions are true" do
+          before { allow_any_instance_of(ConditionalCompany).to receive(:public?).and_return(true) }
+          it     { is_expected.to be_truthy }
+        end
+
+        context "when conditions are false" do
+          before { allow_any_instance_of(ConditionalCompany).to receive(:public?).and_return(false) }
+          it     { is_expected.to be_falsey }
+        end
+      end
+
+      context "when passing a Proc" do
+        context "when conditions are true" do
+          before do
+            class InclusiveCompany < ::ActiveRecord::Base
+              self.table_name = 'companies'
+              audited if: Proc.new { true }
+            end
+          end
+
+          subject { InclusiveCompany.new.send(:auditing_enabled) }
+
+          it { is_expected.to be_truthy }
+        end
+
+        context "when conditions are false" do
+          before do
+            class ExclusiveCompany < ::ActiveRecord::Base
+              self.table_name = 'companies'
+              audited if: Proc.new { false }
+            end
+          end
+          subject { ExclusiveCompany.new.send(:auditing_enabled) }
+          it { is_expected.to be_falsey }
+        end
+      end
+    end
+
+    context "should be configurable which conditions aren't audited" do
+      context "when using a method name" do
+        before do
+          class ExclusionaryCompany < ::ActiveRecord::Base
+            self.table_name = 'companies'
+
+            audited unless: :non_profit?
+
+            def non_profit?; end
+          end
+        end
+
+        subject { ExclusionaryCompany.new.send(:auditing_enabled) }
+
+        context "when conditions are true" do
+          before { allow_any_instance_of(ExclusionaryCompany).to receive(:non_profit?).and_return(true) }
+          it     { is_expected.to be_falsey }
+        end
+
+        context "when conditions are false" do
+          before { allow_any_instance_of(ExclusionaryCompany).to receive(:non_profit?).and_return(false) }
+          it     { is_expected.to be_truthy }
+        end
+      end
+
+      context "when using a proc" do
+        context "when conditions are true" do
+          before do
+            class ExclusionaryCompany < ::ActiveRecord::Base
+              self.table_name = 'companies'
+              audited unless: Proc.new { |c| c.exclusive? }
+
+              def exclusive?
+                true
+              end
+            end
+          end
+
+          subject { ExclusionaryCompany.new.send(:auditing_enabled) }
+          it      { is_expected.to be_falsey }
+        end
+
+        context "when conditions are false" do
+          before do
+            class InclusiveCompany < ::ActiveRecord::Base
+              self.table_name = 'companies'
+              audited unless: Proc.new { false }
+            end
+          end
+
+          subject { InclusiveCompany.new.send(:auditing_enabled) }
+          it      { is_expected.to be_truthy }
+        end
+      end
+    end
+
     it "should be configurable which attributes are not audited via ignored_attributes" do
       Audited.ignored_attributes = ['delta', 'top_secret', 'created_at']
       class Secret < ::ActiveRecord::Base
@@ -36,9 +144,14 @@ describe Audited::Auditor do
     end
 
     it "should not save non-audited columns" do
-      Models::ActiveRecord::User.non_audited_columns = (Models::ActiveRecord::User.non_audited_columns << :favourite_device)
+      previous = Models::ActiveRecord::User.non_audited_columns
+      begin
+        Models::ActiveRecord::User.non_audited_columns += [:favourite_device]
 
-      expect(create_user.audits.first.audited_changes.keys.any? { |col| ['favourite_device', 'created_at', 'updated_at', 'password'].include?( col ) }).to eq(false)
+        expect(create_user.audits.first.audited_changes.keys.any? { |col| ['favourite_device', 'created_at', 'updated_at', 'password'].include?( col ) }).to eq(false)
+      ensure
+        Models::ActiveRecord::User.non_audited_columns = previous
+      end
     end
 
     it "should not save other columns than specified in 'only' option" do
@@ -84,11 +197,11 @@ describe Audited::Auditor do
         let(:migrations_path) { SPEC_ROOT.join("support/active_record/postgres") }
 
         after do
-          ActiveRecord::Migrator.rollback([migrations_path])
+          run_migrations(:down, migrations_path)
         end
 
         it "should work if column type is 'json'" do
-          ActiveRecord::Migrator.up([migrations_path], 1)
+          run_migrations(:up, migrations_path, 1)
           Audited::Audit.reset_column_information
           expect(Audited::Audit.columns_hash["audited_changes"].sql_type).to eq("json")
 
@@ -99,7 +212,7 @@ describe Audited::Auditor do
         end
 
         it "should work if column type is 'jsonb'" do
-          ActiveRecord::Migrator.up([migrations_path], 2)
+          run_migrations(:up, migrations_path, 2)
           Audited::Audit.reset_column_information
           expect(Audited::Audit.columns_hash["audited_changes"].sql_type).to eq("jsonb")
 
@@ -329,6 +442,77 @@ describe Audited::Auditor do
     end
   end
 
+  describe "max_audits" do
+    it "should respect global setting" do
+      stub_global_max_audits(10) do
+        expect(Models::ActiveRecord::User.audited_options[:max_audits]).to eq(10)
+      end
+    end
+
+    it "should respect per model setting" do
+      stub_global_max_audits(10) do
+        expect(Models::ActiveRecord::MaxAuditsUser.audited_options[:max_audits]).to eq(5)
+      end
+    end
+
+    it "should delete old audits when keeped amount exceeded" do
+      stub_global_max_audits(2) do
+        user = create_versions(2)
+        user.update(name: 'John')
+        expect(user.audits.pluck(:version)).to eq([2, 3])
+      end
+    end
+
+    it "should not delete old audits when keeped amount not exceeded" do
+      stub_global_max_audits(3) do
+        user = create_versions(2)
+        user.update(name: 'John')
+        expect(user.audits.pluck(:version)).to eq([1, 2, 3])
+      end
+    end
+
+    it "should delete old extra audits after introducing limit" do
+      stub_global_max_audits(nil) do
+        user = Models::ActiveRecord::User.create!(name: 'Brandon', username: 'brandon')
+        user.update_attributes(name: 'Foobar')
+        user.update_attributes(name: 'Awesome', username: 'keepers')
+        user.update_attributes(activated: true)
+
+        Audited.max_audits = 3
+        Models::ActiveRecord::User.send(:normalize_audited_options)
+        user.update_attributes(favourite_device: 'Android Phone')
+        audits = user.audits
+
+        expect(audits.count).to eq(3)
+        expect(audits[0].audited_changes).to include({'name' => ['Foobar', 'Awesome'], 'username' => ['brandon', 'keepers']})
+        expect(audits[1].audited_changes).to eq({'activated' => [nil, true]})
+        expect(audits[2].audited_changes).to eq({'favourite_device' => [nil, 'Android Phone']})
+      end
+    end
+
+    it "should add comment line for combined audit" do
+      stub_global_max_audits(2) do
+        user = Models::ActiveRecord::User.create!(name: 'Foobar 1')
+        user.update(name: 'Foobar 2', audit_comment: 'First audit comment')
+        user.update(name: 'Foobar 3', audit_comment: 'Second audit comment')
+        expect(user.audits.first.comment).to match(/First audit comment.+is the result of multiple/m)
+      end
+    end
+
+    def stub_global_max_audits(max_audits)
+      previous_max_audits = Audited.max_audits
+      previous_user_audited_options = Models::ActiveRecord::User.audited_options.dup
+      begin
+        Audited.max_audits = max_audits
+        Models::ActiveRecord::User.send(:normalize_audited_options) # reloads audited_options
+        yield
+      ensure
+        Audited.max_audits = previous_max_audits
+        Models::ActiveRecord::User.audited_options = previous_user_audited_options
+      end
+    end
+  end
+
   describe "revisions" do
     let( :user ) { create_versions }
 
@@ -544,28 +728,44 @@ describe Audited::Auditor do
   describe "comment required" do
 
     describe "on create" do
-      it "should not validate when audit_comment is not supplied" do
-        expect(Models::ActiveRecord::CommentRequiredUser.new).not_to be_valid
+      it "should not validate when audit_comment is not supplied when initialized" do
+        expect(Models::ActiveRecord::CommentRequiredUser.new(name: 'Foo')).not_to be_valid
+      end
+
+      it "should not validate when audit_comment is not supplied trying to create" do
+        expect(Models::ActiveRecord::CommentRequiredUser.create(name: 'Foo')).not_to be_valid
       end
 
       it "should validate when audit_comment is supplied" do
-        expect(Models::ActiveRecord::CommentRequiredUser.new( audit_comment: 'Create')).to be_valid
+        expect(Models::ActiveRecord::CommentRequiredUser.create(name: 'Foo', audit_comment: 'Create')).to be_valid
+      end
+
+      it "should validate when audit_comment is not supplied, and creating is not being audited" do
+        expect(Models::ActiveRecord::OnUpdateCommentRequiredUser.create(name: 'Foo')).to be_valid
+        expect(Models::ActiveRecord::OnDestroyCommentRequiredUser.create(name: 'Foo')).to be_valid
       end
 
       it "should validate when audit_comment is not supplied, and auditing is disabled" do
         Models::ActiveRecord::CommentRequiredUser.disable_auditing
-        expect(Models::ActiveRecord::CommentRequiredUser.new).to be_valid
+        expect(Models::ActiveRecord::CommentRequiredUser.create(name: 'Foo')).to be_valid
         Models::ActiveRecord::CommentRequiredUser.enable_auditing
       end
     end
 
     describe "on update" do
       let( :user ) { Models::ActiveRecord::CommentRequiredUser.create!( audit_comment: 'Create' ) }
+      let( :on_create_user ) { Models::ActiveRecord::OnDestroyCommentRequiredUser.create }
+      let( :on_destroy_user ) { Models::ActiveRecord::OnDestroyCommentRequiredUser.create }
 
       it "should not validate when audit_comment is not supplied" do
         expect(user.update_attributes(name: 'Test')).to eq(false)
       end
 
+      it "should validate when audit_comment is not supplied, and updating is not being audited" do
+        expect(on_create_user.update_attributes(name: 'Test')).to eq(true)
+        expect(on_destroy_user.update_attributes(name: 'Test')).to eq(true)
+      end
+
       it "should validate when audit_comment is supplied" do
         expect(user.update_attributes(name: 'Test', audit_comment: 'Update')).to eq(true)
       end
@@ -579,6 +779,8 @@ describe Audited::Auditor do
 
     describe "on destroy" do
       let( :user ) { Models::ActiveRecord::CommentRequiredUser.create!( audit_comment: 'Create' )}
+      let( :on_create_user ) { Models::ActiveRecord::OnCreateCommentRequiredUser.create!( audit_comment: 'Create' ) }
+      let( :on_update_user ) { Models::ActiveRecord::OnUpdateCommentRequiredUser.create }
 
       it "should not validate when audit_comment is not supplied" do
         expect(user.destroy).to eq(false)
@@ -589,6 +791,11 @@ describe Audited::Auditor do
         expect(user.destroy).to eq(user)
       end
 
+      it "should validate when audit_comment is not supplied, and destroying is not being audited" do
+        expect(on_create_user.destroy).to eq(on_create_user)
+        expect(on_update_user.destroy).to eq(on_update_user)
+      end
+
       it "should validate when audit_comment is not supplied, and auditing is disabled" do
         Models::ActiveRecord::CommentRequiredUser.disable_auditing
         expect(user.destroy).to eq(user)

data/spec/audited/rspec_matchers_spec.rb

@@ -0,0 +1,69 @@
+require "spec_helper"
+
+describe Models::ActiveRecord::UserExceptPassword do
+  let(:non_audited_columns) { subject.class.non_audited_columns }
+
+  it { should_not be_audited.only(non_audited_columns) }
+  it { should be_audited.except(:password) }
+  it { should_not be_audited.requires_comment }
+  it { should be_audited.on(:create, :update, :destroy) }
+  # test chaining
+  it { should be_audited.except(:password).on(:create, :update, :destroy) }
+end
+
+describe Models::ActiveRecord::UserOnlyPassword do
+  let(:audited_columns) { subject.class.audited_columns }
+
+  it { should be_audited.only(:password) }
+  it { should_not be_audited.except(audited_columns) }
+  it { should_not be_audited.requires_comment }
+  it { should be_audited.on(:create, :update, :destroy) }
+  it { should be_audited.only(:password).on(:create, :update, :destroy) }
+end
+
+describe Models::ActiveRecord::CommentRequiredUser do
+  let(:audited_columns) { subject.class.audited_columns }
+  let(:non_audited_columns) { subject.class.non_audited_columns }
+
+  it { should_not be_audited.only(non_audited_columns) }
+  it { should_not be_audited.except(audited_columns) }
+  it { should be_audited.requires_comment }
+  it { should be_audited.on(:create, :update, :destroy) }
+  it { should be_audited.requires_comment.on(:create, :update, :destroy) }
+end
+
+describe Models::ActiveRecord::OnCreateCommentRequiredUser do
+  let(:audited_columns) { subject.class.audited_columns }
+  let(:non_audited_columns) { subject.class.non_audited_columns }
+
+  it { should_not be_audited.only(non_audited_columns) }
+  it { should_not be_audited.except(audited_columns) }
+  it { should be_audited.requires_comment }
+  it { should be_audited.on(:create) }
+  it { should_not be_audited.on(:update, :destroy) }
+  it { should be_audited.requires_comment.on(:create) }
+end
+
+describe Models::ActiveRecord::OnUpdateCommentRequiredUser do
+  let(:audited_columns) { subject.class.audited_columns }
+  let(:non_audited_columns) { subject.class.non_audited_columns }
+
+  it { should_not be_audited.only(non_audited_columns) }
+  it { should_not be_audited.except(audited_columns) }
+  it { should be_audited.requires_comment }
+  it { should be_audited.on(:update) }
+  it { should_not be_audited.on(:create, :destroy) }
+  it { should be_audited.requires_comment.on(:update) }
+end
+
+describe Models::ActiveRecord::OnDestroyCommentRequiredUser do
+  let(:audited_columns) { subject.class.audited_columns }
+  let(:non_audited_columns) { subject.class.non_audited_columns }
+
+  it { should_not be_audited.only(non_audited_columns) }
+  it { should_not be_audited.except(audited_columns) }
+  it { should be_audited.requires_comment }
+  it { should be_audited.on(:destroy) }
+  it { should_not be_audited.on(:create, :update) }
+  it { should be_audited.requires_comment.on(:destroy) }
+end

data/spec/audited_spec_helpers.rb

@@ -8,8 +8,8 @@ module AuditedSpecHelpers
     Models::ActiveRecord::User.new({name: 'darth', username: 'darth', password: 'noooooooo'}.merge(attrs))
   end
 
-  def create_versions(n = 2)
-    Models::ActiveRecord::User.create(name: 'Foobar 1').tap do |u|
+  def create_versions(n = 2, attrs = {})
+    Models::ActiveRecord::User.create(name: 'Foobar 1', **attrs).tap do |u|
       (n - 1).times do |i|
         u.update_attribute :name, "Foobar #{i + 2}"
       end
@@ -17,4 +17,16 @@ module AuditedSpecHelpers
     end
   end
 
+  def run_migrations(direction, migrations_paths, target_version = nil)
+    if rails_below?('5.2.0.rc1')
+      ActiveRecord::Migrator.send(direction, migrations_paths, target_version)
+    else
+      ActiveRecord::MigrationContext.new(migrations_paths).send(direction, target_version)
+    end
+  end
+
+  def rails_below?(rails_version)
+    Gem::Version.new(Rails::VERSION::STRING) < Gem::Version.new(rails_version)
+  end
+
 end

data/spec/spec_helper.rb

@@ -7,6 +7,7 @@ end
 require 'rails_app/config/environment'
 require 'rspec/rails'
 require 'audited'
+require 'audited-rspec'
 require 'audited_spec_helpers'
 require 'support/active_record/models'
 

data/spec/support/active_record/models.rb

@@ -4,7 +4,7 @@ require File.expand_path('../schema', __FILE__)
 module Models
   module ActiveRecord
     class User < ::ActiveRecord::Base
-      audited allow_mass_assignment: true, except: :password
+      audited except: :password
       attribute :non_column_attr if Rails.version >= '5.1'
       attr_protected :logins if respond_to?(:attr_protected)
 
@@ -13,10 +13,15 @@ module Models
       end
     end
 
+    class UserExceptPassword < ::ActiveRecord::Base
+      self.table_name = :users
+      audited except: :password
+    end
+
     class UserOnlyPassword < ::ActiveRecord::Base
       self.table_name = :users
       attribute :non_column_attr if Rails.version >= '5.1'
-      audited allow_mass_assignment: true, only: :password
+      audited only: :password
     end
 
     class CommentRequiredUser < ::ActiveRecord::Base
@@ -24,6 +29,21 @@ module Models
       audited comment_required: true
     end
 
+    class OnCreateCommentRequiredUser < ::ActiveRecord::Base
+      self.table_name = :users
+      audited comment_required: true, on: :create
+    end
+
+    class OnUpdateCommentRequiredUser < ::ActiveRecord::Base
+      self.table_name = :users
+      audited comment_required: true, on: :update
+    end
+
+    class OnDestroyCommentRequiredUser < ::ActiveRecord::Base
+      self.table_name = :users
+      audited comment_required: true, on: :destroy
+    end
+
     class AccessibleAfterDeclarationUser < ::ActiveRecord::Base
       self.table_name = :users
       audited
@@ -38,7 +58,7 @@ module Models
 
     class NoAttributeProtectionUser < ::ActiveRecord::Base
       self.table_name = :users
-      audited allow_mass_assignment: true
+      audited
     end
 
     class UserWithAfterAudit < ::ActiveRecord::Base
@@ -57,6 +77,11 @@ module Models
       end
     end
 
+    class MaxAuditsUser < ::ActiveRecord::Base
+      self.table_name = :users
+      audited max_audits: 5
+    end
+
     class Company < ::ActiveRecord::Base
       audited
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: audited
 version: !ruby/object:Gem::Version
-  version: 4.6.0
+  version: 4.7.0
 platform: ruby
 authors:
 - Brandon Keepers
@@ -13,7 +13,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-09 00:00:00.000000000 Z
+date: 2018-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -168,6 +168,7 @@ files:
 - lib/generators/audited/upgrade_generator.rb
 - spec/audited/audit_spec.rb
 - spec/audited/auditor_spec.rb
+- spec/audited/rspec_matchers_spec.rb
 - spec/audited/sweeper_spec.rb
 - spec/audited_spec_helpers.rb
 - spec/rails_app/config/application.rb