paper_trail 4.0.0.beta2 → 4.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7b96c067cab9f8789c0942d19fe7db30c83b0854
-  data.tar.gz: a2f6e330b8c28de3c575c9a7c13ba54c352702ed
+  metadata.gz: c4a505b4f0b1cb4242e1a8eeb291fa5b95df54de
+  data.tar.gz: 26ef2a95bf0a15137d707b52b7a8f1aeff207b46
 SHA512:
-  metadata.gz: 2eb6e5433a4e085a9ccaa41b5c1862f2c1b25fd4f77d08061470d4cf411560f02aa1cd18179f5fb058b446c0d3e26ba58ea917fbe20c4c13032128e8d3837c3a
-  data.tar.gz: 435e06ff6d5e3071f09cb3d4a1b415c132114efb6d01b36d9b15d794a6b249db0392ddad6a1f75f6d0fdbf826befa6509b01c1235cce54034f621e5ab5e04594
+  metadata.gz: 24bf40f194ddd24066e4ff0737eb35a603cb8b0e54b14060315a0d5ad57a98b53b8aaecbf7a07d69d65d3ab1d99ac6cead49b0396560a4d2f8545c3580d70041
+  data.tar.gz: f7efc50eab66db98cea15c876201ebe5773c7b5f64c0320f98743b607819a1f8084438096e9e3849b1b233d3b0c2e9f86114be07e8de72d09f18ed24c04175f4

data/.gitignore

@@ -17,3 +17,5 @@ vendor/*
 .rvmrc
 .tags
 .tags_sorted_by_file
+.ruby-version
+.ruby-gemset

data/.travis.yml

@@ -6,9 +6,12 @@ rvm:
   - jruby-19mode
   - jruby-18mode
 env:
-  - DB=mysql
-  - DB=postgres
-  - DB=sqlite
+  global:
+    - TRAVIS=true
+  matrix:
+    - DB=mysql
+    - DB=postgres
+    - DB=sqlite
 
 sudo: false
 
@@ -27,11 +30,10 @@ gemfile:
 matrix:
   fast_finish: true
   allow_failures:
-    - rvm: jruby-19mode
-      env: DB=postgres
-      gemfile: Gemfile
     - rvm: jruby-18mode
       gemfile: Gemfile
     - rvm: 1.8.7
       gemfile: Gemfile
-    
+
+addons:
+  postgresql: "9.4"

data/CHANGELOG.md

@@ -9,13 +9,35 @@ PaperTrail::Rails::Engine.eager_load!
 
 If you depend on the `RSpec` or `Cucumber` helpers, you will need to [manually load them into your test helper](https://github.com/airblade/paper_trail#testing).
 
+  - [#525](https://github.com/airblade/paper_trail/issues/525) / [#512](https://github.com/airblade/paper_trail/pull/512) -
+    Support for virtual accessors and redefined setter and getter methods.
+  - [#518](https://github.com/airblade/paper_trail/pull/518) - Support for querying against PostgreSQL's
+    [`JSON` and `JSONB` column types](http://www.postgresql.org/docs/9.4/static/datatype-json.html) via
+    `PaperTrail::VersionConcern#where_object` and `PaperTrail::VersionConcern#where_object_changes`
+  - [#507](https://github.com/airblade/paper_trail/pull/507) - Support for opting out of saving changesets on models by choice
+    when the `object_changes` column exists on the default `versions` table.
+  - [#500](https://github.com/airblade/paper_trail/pull/500) - Support for passing `on: []` as an argument, with only manual
+    versioning via calls to `touch_with_version`
+  - [#494](https://github.com/airblade/paper_trail/issues/494) - The install generator will warn the user if the migration they are
+    attempting to generate already exists.
+  - [#484](https://github.com/airblade/paper_trail/pull/484) - Support for
+    [PostgreSQL's `JSONB` Type](http://www.postgresql.org/docs/9.4/static/datatype-json.html) for storing `object`
+    and `object_changes`.
+  - [#479](https://github.com/airblade/paper_trail/issues/479) - Deprecated `originator` method in favor of `paper_trail_originator`
+    Deprecation warning informs users that the `originator` of the methods will be removed in version `4.0`
   - [#458](https://github.com/airblade/paper_trail/pull/458) - For `create` events, metadata pointing at attributes should attempt
     to grab the current value instead of looking at the value prior to the change (which would always be `nil`)
+  - [#451](https://github.com/airblade/paper_trail/issues/451) - Fix `reify` method in context of model where the base class
+    has a default scope, and the live instance is not scoped within that default scope
   - [#440](https://github.com/airblade/paper_trail/pull/440) - `versions` association should clear/reload after a transaction rollback.
   - [#439](https://github.com/airblade/paper_trail/pull/439) / [#12](https://github.com/airblade/paper_trail/issues/12) -
     Support for versioning of associations (Has Many, Has One, HABTM, etc.)
-  - [#438](https://github.com/airblade/paper_trail/issues/438) - `Model.paper_trail_enabled_for_model?` should return `false` if
+  - [#438](https://github.com/airblade/paper_trail/issues/438) - `ModelKlass.paper_trail_enabled_for_model?` should return `false` if
     `has_paper_trail` has not been declared on the class.
+  - [#404](https://github.com/airblade/paper_trail/issues/404) / [#428](https://github.com/airblade/paper_trail/issues/428) -
+    `model_instance.dup` does not need to be invoked when examining what the instance looked like before changes were persisted,
+    which avoids issues if a 3rd party has overriden the `dup` behavior. Also fixes errors occuring when a user attempts to
+    update the inheritance column on an STI model instance in `ActiveRecord` 4.1.x
   - [#427](https://github.com/airblade/paper_trail/pull/427) - Fix `reify` method in context of model where a column has been removed.
   - [#420](https://github.com/airblade/paper_trail/issues/420) - Add `VersionConcern#where_object_changes` instance method;
     acts as a helper for querying against the `object_changes` column in versions table.
@@ -24,6 +46,8 @@ If you depend on the `RSpec` or `Cucumber` helpers, you will need to [manually l
     deprecated in `ActiveRecord` version `4.2` and will be removed in version `5.0`
   - [#414](https://github.com/airblade/paper_trail/issues/414) - Fix functionality `ignore` argument to `has_paper_trail`
     in `ActiveRecord` 4.
+  - [#413](https://github.com/airblade/paper_trail/issues/413) - Utilize [RequestStore](https://github.com/steveklabnik/request_store)
+    to ensure that the `PaperTrail.whodunnit` is set in a thread safe manner within Rails & Sinatra.
   - [#399](https://github.com/airblade/paper_trail/pull/399) - Add `:dup` argument for options hash to `reify` which forces a new model instance.
   - [#394](https://github.com/airblade/paper_trail/pull/394) - Add RSpec matcher `have_a_version_with` for easier testing.
   - [#391](https://github.com/airblade/paper_trail/issues/391) - `object_changes` value should dump to `YAML` as a normal `Hash`
@@ -38,6 +62,18 @@ If you depend on the `RSpec` or `Cucumber` helpers, you will need to [manually l
     the gem is used with `Rails`.
   - Methods handling serialized attributes should fallback to the currently set Serializer instead of always falling back
     to `PaperTrail::Serializers::YAML`.
+  - Both `PaperTrail.config` and `PaperTrail.configure` are now identical, and will both return the `PaperTrail::Config`
+    instance and also yield it if a block is provided.
+
+## 3.0.8
+
+  - [#525](https://github.com/airblade/paper_trail/issues/525) / [#512](https://github.com/airblade/paper_trail/pull/512) -
+    Support for virtual accessors and redefined setter and getter methods.
+
+## 3.0.7
+
+  - [#404](https://github.com/airblade/paper_trail/issues/404) / [#428](https://github.com/airblade/paper_trail/issues/428) -
+    Fix errors occuring when a user attempts to update the inheritance column on an STI model instance in `ActiveRecord` 4.1.x
 
 ## 3.0.6
 
@@ -46,7 +82,7 @@ If you depend on the `RSpec` or `Cucumber` helpers, you will need to [manually l
 
 ## 3.0.5
 
-  - [#401](https://github.com/airblade/paper_trail/issues/401) / [#406](https://github.com/airblade/paper_trail/issues/406)
+  - [#401](https://github.com/airblade/paper_trail/issues/401) / [#406](https://github.com/airblade/paper_trail/issues/406) -
     `PaperTrail::Version` class is not loaded via a `Rails::Engine`, even when the gem is used with in Rails. This feature has
     will be re-introduced in version `4.0`.
   - [#398](https://github.com/airblade/paper_trail/pull/398) - Only require the `RSpec` helper if `RSpec::Core` is required.

data/README.md

@@ -44,7 +44,7 @@ The Rails 2.3 code is on the [`rails2`](https://github.com/airblade/paper_trail/
 
 1. Add PaperTrail to your `Gemfile`.
 
-    `gem 'paper_trail', '~> 3.0.6'`
+    `gem 'paper_trail', '~> 4.0.0.rc'`
 
 2. Generate a migration which will add a `versions` table to your database.
 
@@ -66,7 +66,7 @@ your applications `ActiveRecord` connection in a manner similar to the way `Rail
 
 1. Add PaperTrail to your `Gemfile`.
 
-    `gem 'paper_trail', '~> 3.0.6'`
+    `gem 'paper_trail', '~> 4.0.0.rc'`
 
 2. Generate a migration to add a `versions` table to your database.
 
@@ -117,7 +117,7 @@ widget.version
 widget.live?
 
 # Returns who put the widget into its current state.
-widget.originator
+widget.paper_trail_originator
 
 # Returns the widget (not a version) as it looked at the given timestamp.
 widget.version_at(timestamp)
@@ -152,7 +152,7 @@ version.reify(options = {})
 version.reify(dup: true)
 
 # Returns who put the item into the state stored in this version.
-version.originator
+version.paper_trail_originator
 
 # Returns who changed the item from the state it had in this version.
 version.terminator
@@ -473,7 +473,7 @@ And you can perform `WHERE` queries for object versions based on attributes:
 
 ## Finding Out Who Was Responsible For A Change
 
-If your `ApplicationController` has a `current_user` method, PaperTrail will store the value it returns in the version's `whodunnit` column.  Note that this column is of type `String`, so you will have to convert it to an integer if it's an id and you want to look up the user later on:
+If your `ApplicationController` has a `current_user` method, PaperTrail will attempt to store the value returned by `current_user.id` in the version's `whodunnit` column (if it returns).  Note that this column is of type `String`, so you will have to convert it to an integer if it's an id and you want to look up the user later on:
 
 ```ruby
 >> last_change = widget.versions.last
@@ -529,22 +529,22 @@ Sometimes you want to define who is responsible for a change in a small scope wi
 
 A version's `whodunnit` records who changed the object causing the `version` to be stored.  Because a version stores the object as it looked before the change (see the table above), `whodunnit` returns who stopped the object looking like this -- not who made it look like this.  Hence `whodunnit` is aliased as `terminator`.
 
-To find out who made a version's object look that way, use `version.originator`.  And to find out who made a "live" object look like it does, use `originator` on the object.
+To find out who made a version's object look that way, use `version.paper_trail_originator`.  And to find out who made a "live" object look like it does, call `paper_trail_originator` on the object.
 
 ```ruby
 >> widget = Widget.find 153                    # assume widget has 0 versions
 >> PaperTrail.whodunnit = 'Alice'
 >> widget.update_attributes :name => 'Yankee'
->> widget.originator                           # 'Alice'
+>> widget..paper_trail_originator              # 'Alice'
 >> PaperTrail.whodunnit = 'Bob'
 >> widget.update_attributes :name => 'Zulu'
->> widget.originator                           # 'Bob'
+>> widget.paper_trail_originator               # 'Bob'
 >> first_version, last_version = widget.versions.first, widget.versions.last
 >> first_version.whodunnit                     # 'Alice'
->> first_version.originator                    # nil
+>> first_version.paper_trail_originator        # nil
 >> first_version.terminator                    # 'Alice'
 >> last_version.whodunnit                      # 'Bob'
->> last_version.originator                     # 'Alice'
+>> last_version.paper_trail_originator         # 'Alice'
 >> last_version.terminator                     # 'Bob'
 ```
 
@@ -570,7 +570,7 @@ If you are using Postgres, you should also define the sequence that your custom
 ```ruby
 class PostVersion < PaperTrail::Version
   self.table_name = :post_versions
-  self.sequence_name = :post_version_id_seq
+  self.sequence_name = :post_versions_id_seq
 end
 ```
 
@@ -655,7 +655,7 @@ If the parent and child are updated in one go, PaperTrail can use the aforementi
 >> t.location.latitude              # 12.345, instead of 54.321
 ```
 
-By default, PaperTrail excludes an associated record from the reified parent model if the associated record exists in the live model but did not exist as at the time the version was created. This is usually what you want if you just want to look at the reified version. But if you want to persist it, it would be better to pass in option `:mark_for_destruction => true` so that the associated record is included and marked for destruction.
+By default, PaperTrail excludes an associated record from the reified parent model if the associated record exists in the live model but did not exist as at the time the version was created. This is usually what you want if you just want to look at the reified version. But if you want to persist it, it would be better to pass in option `:mark_for_destruction => true` so that the associated record is included and marked for destruction. Note that `mark_for_destruction` only has [an effect on associations marked with `autosave: true`](http://api.rubyonrails.org/classes/ActiveRecord/AutosaveAssociation.html#method-i-mark_for_destruction).
 
 ```ruby
 class Widget < ActiveRecord::Base
@@ -844,6 +844,7 @@ For diffing two ActiveRecord objects:
 * [Jeremy Weiskotten's PaperTrail fork](http://github.com/jeremyw/paper_trail/blob/master/lib/paper_trail/has_paper_trail.rb#L151-156): uses ActiveSupport's diff to return an array of hashes of the changes.
 * [activerecord-diff](http://github.com/tim/activerecord-diff): rather like ActiveRecord::Dirty but also allows you to specify which columns to compare.
 
+If you wish to selectively record changes for some models but not others you can opt out of recording changes by passing `:save_changes => false` to your `has_paper_trail` method declaration.
 
 ## Turning PaperTrail Off/On
 
@@ -951,6 +952,23 @@ A valid serializer is a `module` (or `class`) that defines a `load` and `dump` m
 * [PaperTrail::Serializers::YAML](https://github.com/airblade/paper_trail/blob/master/lib/paper_trail/serializers/yaml.rb) - Default
 * [PaperTrail::Serializers::JSON](https://github.com/airblade/paper_trail/blob/master/lib/paper_trail/serializers/json.rb)
 
+### PostgreSQL JSON column type support
+
+If you use PostgreSQL, and would like to store your `object` (and/or `object_changes`) data in a column of
+[type `JSON` or type `JSONB`](http://www.postgresql.org/docs/9.4/static/datatype-json.html),
+specify `json` instead of `text` for these columns in your migration:
+
+```ruby
+create_table :versions do |t|
+  ...
+  t.json :object          # Full object changes
+  t.json :object_changes  # Optional column-level changes
+  ...
+end
+```
+
+Note: You don't need to use a particular serializer for the PostgreSQL `JSON` column type.
+
 ## SerializedAttributes support
 
 PaperTrail has a config option that can be used to enable/disable whether PaperTrail attempts to utilize

data/Rakefile

@@ -23,7 +23,7 @@ Rake::TestTask.new(:test) do |t|
 end
 
 require 'rspec/core/rake_task'
-desc 'Run PaperTrail specs for the RSpec helper.'
+desc 'Run tests on PaperTrail with RSpec'
 RSpec::Core::RakeTask.new(:spec)
 
 desc 'Default: run all available test suites'

data/gemfiles/3.0.gemfile

@@ -2,11 +2,12 @@ source 'https://rubygems.org'
 
 gem 'activerecord', '~> 3.0'
 gem 'i18n', '~> 0.6.11'
+gem 'request_store', '~> 1.1.0'
 
 group :development, :test do
   gem 'rake', '~> 10.1.1'
   gem 'shoulda', '~> 3.5'
-  gem 'ffaker',  '>= 1.15'
+  gem 'ffaker',  '<= 1.31.0'
 
   # Testing of Rails
   gem 'railties', '~> 3.0'
@@ -46,5 +47,6 @@ group :development, :test do
     gem 'activerecord-jdbcsqlite3-adapter', '~> 1.3'
     gem 'activerecord-jdbcpostgresql-adapter', '~> 1.3'
     gem 'activerecord-jdbcmysql-adapter', '~> 1.3'
+    gem 'activerecord-jdbc-adapter', '1.3.15'
   end
 end

data/lib/generators/paper_trail/install_generator.rb

@@ -30,8 +30,11 @@ module PaperTrail
     def add_paper_trail_migration(template)
       migration_dir = File.expand_path('db/migrate')
 
-      if !self.class.migration_exists?(migration_dir, template)
+      unless self.class.migration_exists?(migration_dir, template)
         migration_template "#{template}.rb", "db/migrate/#{template}.rb"
+      else
+        warn("ALERT: Migration already exists named '#{template}'." +
+               " Please check your migrations directory before re-running")
       end
     end
   end

data/lib/paper_trail/cleaner.rb

@@ -25,7 +25,7 @@ module PaperTrail
     # Returns a hash of versions grouped by the `item_id` attribute formatted like this: {:item_id => PaperTrail::Version}.
     # If `item_id` or `date` is set, versions will be narrowed to those pointing at items with those ids that were created on specified date.
     def gather_versions(item_id = nil, date = :all)
-      raise "`date` argument must receive a Timestamp or `:all`" unless date == :all || date.respond_to?(:to_date)
+      raise ArgumentError.new("`date` argument must receive a Timestamp or `:all`") unless date == :all || date.respond_to?(:to_date)
       versions = item_id ? PaperTrail::Version.where(:item_id => item_id) : PaperTrail::Version
       versions = versions.between(date.to_date, date.to_date + 1.day) unless date == :all
       versions = PaperTrail::Version.all if versions == PaperTrail::Version # if versions has not been converted to an ActiveRecord::Relation yet, do so now

data/lib/paper_trail/config.rb

@@ -5,6 +5,7 @@ module PaperTrail
     include Singleton
     attr_accessor :enabled, :timestamp_field, :serializer, :version_limit
     attr_reader :serialized_attributes
+    attr_writer :track_associations
 
     def initialize
       @enabled         = true # Indicates whether PaperTrail is on or off.
@@ -27,5 +28,10 @@ module PaperTrail
       end
       @serialized_attributes = value
     end
+
+    def track_associations
+      @track_associations ||= PaperTrail::VersionAssociation.table_exists?
+    end
+    alias_method :track_associations?, :track_associations
   end
 end

data/lib/paper_trail/frameworks/sinatra.rb

@@ -5,6 +5,7 @@ module PaperTrail
 
     # Register this module inside your Sinatra application to gain access to controller-level methods used by PaperTrail
     def self.registered(app)
+      app.use RequestStore::Middleware
       app.helpers self
       app.before { set_paper_trail_whodunnit }
     end

data/lib/paper_trail/has_paper_trail.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/object' # provides the `try` method
+
 module PaperTrail
   module Model
 
@@ -10,26 +12,28 @@ module PaperTrail
       # the model is available in the `versions` association.
       #
       # Options:
-      # :on           the events to track (optional; defaults to all of them).  Set to an array of
-      #               `:create`, `:update`, `:destroy` as desired.
-      # :class_name   the name of a custom Version class.  This class should inherit from `PaperTrail::Version`.
-      # :ignore       an array of attributes for which a new `Version` will not be created if only they change.
-      #               it can also aceept a Hash as an argument where the key is the attribute to ignore (a `String` or `Symbol`),
-      #               which will only be ignored if the value is a `Proc` which returns truthily.
-      # :if, :unless  Procs that allow to specify conditions when to save versions for an object
-      # :only         inverse of `ignore` - a new `Version` will be created only for these attributes if supplied
-      #               it can also aceept a Hash as an argument where the key is the attribute to track (a `String` or `Symbol`),
-      #               which will only be counted if the value is a `Proc` which returns truthily.
-      # :skip         fields to ignore completely.  As with `ignore`, updates to these fields will not create
-      #               a new `Version`.  In addition, these fields will not be included in the serialized versions
-      #               of the object whenever a new `Version` is created.
-      # :meta         a hash of extra data to store.  You must add a column to the `versions` table for each key.
-      #               Values are objects or procs (which are called with `self`, i.e. the model with the paper
-      #               trail).  See `PaperTrail::Controller.info_for_paper_trail` for how to store data from
-      #               the controller.
-      # :versions     the name to use for the versions association.  Default is `:versions`.
-      # :version      the name to use for the method which returns the version the instance was reified from.
-      #               Default is `:version`.
+      # :on            the events to track (optional; defaults to all of them).  Set to an array of
+      #                `:create`, `:update`, `:destroy` as desired.
+      # :class_name    the name of a custom Version class.  This class should inherit from `PaperTrail::Version`.
+      # :ignore        an array of attributes for which a new `Version` will not be created if only they change.
+      #                it can also aceept a Hash as an argument where the key is the attribute to ignore (a `String` or `Symbol`),
+      #                which will only be ignored if the value is a `Proc` which returns truthily.
+      # :if, :unless   Procs that allow to specify conditions when to save versions for an object
+      # :only          inverse of `ignore` - a new `Version` will be created only for these attributes if supplied
+      #                it can also aceept a Hash as an argument where the key is the attribute to track (a `String` or `Symbol`),
+      #                which will only be counted if the value is a `Proc` which returns truthily.
+      # :skip          fields to ignore completely.  As with `ignore`, updates to these fields will not create
+      #                a new `Version`.  In addition, these fields will not be included in the serialized versions
+      #                of the object whenever a new `Version` is created.
+      # :meta          a hash of extra data to store.  You must add a column to the `versions` table for each key.
+      #                Values are objects or procs (which are called with `self`, i.e. the model with the paper
+      #                trail).  See `PaperTrail::Controller.info_for_paper_trail` for how to store data from
+      #                the controller.
+      # :versions      the name to use for the versions association.  Default is `:versions`.
+      # :version       the name to use for the method which returns the version the instance was reified from.
+      #                Default is `:version`.
+      # :save_changes  whether or not to save changes to the object_changes column if it exists. Default is true
+      #
       def has_paper_trail(options = {})
         # Lazily include the instance methods so we don't clutter up
         # any more ActiveRecord models than we have to.
@@ -53,6 +57,7 @@ module PaperTrail
         end
 
         paper_trail_options[:meta] ||= {}
+        paper_trail_options[:save_changes] = true if paper_trail_options[:save_changes].nil?
 
         class_attribute :versions_association_name
         self.versions_association_name = options[:versions] || :versions
@@ -70,14 +75,15 @@ module PaperTrail
             :order      => self.paper_trail_version_class.timestamp_sort_order
         end
 
+        options[:on] ||= [:create, :update, :destroy]
         options_on = Array(options[:on]) # so that a single symbol can be passed in without wrapping it in an `Array`
-        after_create  :record_create, :if => :save_version? if options_on.empty? || options_on.include?(:create)
-        if options_on.empty? || options_on.include?(:update)
+        after_create  :record_create, :if => :save_version? if options_on.include?(:create)
+        if options_on.include?(:update)
           before_save   :reset_timestamp_attrs_for_update_if_needed!, :on => :update
           after_update  :record_update, :if => :save_version?
           after_update  :clear_version_instance!
         end
-        after_destroy :record_destroy, :if => :save_version? if options_on.empty? || options_on.include?(:destroy)
+        after_destroy :record_destroy, :if => :save_version? if options_on.include?(:destroy)
 
         # Reset the transaction id when the transaction is closed
         after_commit :reset_transaction_id
@@ -115,7 +121,7 @@ module PaperTrail
       end
 
       # Used for Version#object attribute
-      def serialize_attributes_for_paper_trail(attributes)
+      def serialize_attributes_for_paper_trail!(attributes)
         # don't serialize before values before inserting into columns of type `JSON` on `PostgreSQL` databases
         return attributes if self.paper_trail_version_class.object_col_is_json?
 
@@ -128,7 +134,7 @@ module PaperTrail
         end
       end
 
-      def unserialize_attributes_for_paper_trail(attributes)
+      def unserialize_attributes_for_paper_trail!(attributes)
         # don't serialize before values before inserting into columns of type `JSON` on `PostgreSQL` databases
         return attributes if self.paper_trail_version_class.object_col_is_json?
 
@@ -141,7 +147,7 @@ module PaperTrail
       end
 
       # Used for Version#object_changes attribute
-      def serialize_attribute_changes(changes)
+      def serialize_attribute_changes_for_paper_trail!(changes)
         # don't serialize before values before inserting into columns of type `JSON` on `PostgreSQL` databases
         return changes if self.paper_trail_version_class.object_changes_col_is_json?
 
@@ -156,7 +162,7 @@ module PaperTrail
         end
       end
 
-      def unserialize_attribute_changes(changes)
+      def unserialize_attribute_changes_for_paper_trail!(changes)
         # don't serialize before values before inserting into columns of type `JSON` on `PostgreSQL` databases
         return changes if self.paper_trail_version_class.object_changes_col_is_json?
 
@@ -181,10 +187,15 @@ module PaperTrail
       end
 
       # Returns who put the object into its current state.
-      def originator
+      def paper_trail_originator
         (source_version || send(self.class.versions_association_name).last).try(:whodunnit)
       end
 
+      def originator
+        warn "DEPRECATED: use `paper_trail_originator` instead of `originator`. Support for `originator` will be removed in PaperTrail 4.0"
+        self.paper_trail_originator
+      end
+
       # Invoked after rollbacks to ensure versions records are not created
       # for changes that never actually took place
       def clear_rolled_back_versions
@@ -268,7 +279,9 @@ module PaperTrail
         current_time = current_time_from_proper_timezone
 
         attributes.each { |column| write_attribute(column, current_time) }
-        save!
+        # ensure a version is written even if the `:on` collection is empty
+        record_update(true) if paper_trail_options[:on] == []
+        save!(:validate => false)
       end
 
       private
@@ -280,13 +293,13 @@ module PaperTrail
       def record_create
         if paper_trail_switched_on?
           data = {
-            :event          => paper_trail_event || 'create',
-            :whodunnit      => PaperTrail.whodunnit
+            :event     => paper_trail_event || 'create',
+            :whodunnit => PaperTrail.whodunnit
           }
           if respond_to?(:created_at)
             data[PaperTrail.timestamp_field] = created_at
           end
-          if changed_notably? and self.class.paper_trail_version_class.column_names.include?('object_changes')
+          if paper_trail_options[:save_changes] && changed_notably? && self.class.paper_trail_version_class.column_names.include?('object_changes')
             data[:object_changes] = self.class.paper_trail_version_class.object_changes_col_is_json? ? changes_for_paper_trail :
               PaperTrail.serializer.dump(changes_for_paper_trail)
           end
@@ -299,18 +312,18 @@ module PaperTrail
         end
       end
 
-      def record_update
-        if paper_trail_switched_on? && changed_notably?
-          object_attrs = object_attrs_for_paper_trail(item_before_change)
+      def record_update(force = nil)
+        if paper_trail_switched_on? && (force || changed_notably?)
+          object_attrs = object_attrs_for_paper_trail(attributes_before_change)
           data = {
-            :event          => paper_trail_event || 'update',
-            :object         => self.class.paper_trail_version_class.object_col_is_json? ? object_attrs : PaperTrail.serializer.dump(object_attrs),
-            :whodunnit      => PaperTrail.whodunnit
+            :event     => paper_trail_event || 'update',
+            :object    => self.class.paper_trail_version_class.object_col_is_json? ? object_attrs : PaperTrail.serializer.dump(object_attrs),
+            :whodunnit => PaperTrail.whodunnit
           }
           if respond_to?(:updated_at)
             data[PaperTrail.timestamp_field] = updated_at
           end
-          if self.class.paper_trail_version_class.column_names.include?('object_changes')
+          if paper_trail_options[:save_changes] && self.class.paper_trail_version_class.column_names.include?('object_changes')
             data[:object_changes] = self.class.paper_trail_version_class.object_changes_col_is_json? ? changes_for_paper_trail :
               PaperTrail.serializer.dump(changes_for_paper_trail)
           end
@@ -326,7 +339,7 @@ module PaperTrail
       def changes_for_paper_trail
         _changes = changes.delete_if { |k,v| !notably_changed.include?(k) }
         if PaperTrail.serialized_attributes?
-          self.class.serialize_attribute_changes(_changes)
+          self.class.serialize_attribute_changes_for_paper_trail!(_changes)
         end
         _changes.to_hash
       end
@@ -350,13 +363,13 @@ module PaperTrail
 
       def record_destroy
         if paper_trail_switched_on? and not new_record?
-          object_attrs = object_attrs_for_paper_trail(item_before_change)
+          object_attrs = object_attrs_for_paper_trail(attributes_before_change)
           data = {
-            :item_id        => self.id,
-            :item_type      => self.class.base_class.name,
-            :event          => paper_trail_event || 'destroy',
-            :object         => self.class.paper_trail_version_class.object_col_is_json? ? object_attrs : PaperTrail.serializer.dump(object_attrs),
-            :whodunnit      => PaperTrail.whodunnit
+            :item_id   => self.id,
+            :item_type => self.class.base_class.name,
+            :event     => paper_trail_event || 'destroy',
+            :object    => self.class.paper_trail_version_class.object_col_is_json? ? object_attrs : PaperTrail.serializer.dump(object_attrs),
+            :whodunnit => PaperTrail.whodunnit
           }
           if self.class.paper_trail_version_class.column_names.include?('transaction_id')
             data[:transaction_id] = PaperTrail.transaction_id
@@ -371,15 +384,23 @@ module PaperTrail
 
       # saves associations if the join table for `VersionAssociation` exists
       def save_associations(version)
-        return unless PaperTrail::VersionAssociation.table_exists?
+        return unless PaperTrail.config.track_associations?
         self.class.reflect_on_all_associations(:belongs_to).each do |assoc|
-          if assoc.klass.paper_trail_enabled_for_model?
-            PaperTrail::VersionAssociation.create(
+          assoc_version_args = {
               :version_id => version.id,
-              :foreign_key_name => assoc.foreign_key,
-              :foreign_key_id => self.send(assoc.foreign_key)
-            )
+              :foreign_key_name => assoc.foreign_key
+          }
+
+          if assoc.options[:polymorphic]
+            associated_record = send(assoc.name) if send(assoc.foreign_type)
+            if associated_record && associated_record.class.paper_trail_enabled_for_model?
+              assoc_version_args.merge!(:foreign_key_id => associated_record.id)
+            end
+          elsif assoc.klass.paper_trail_enabled_for_model?
+            assoc_version_args.merge!(:foreign_key_id => send(assoc.foreign_key))
           end
+
+          PaperTrail::VersionAssociation.create(assoc_version_args) if assoc_version_args.has_key?(:foreign_key_id)
         end
       end
 
@@ -403,7 +424,7 @@ module PaperTrail
             if v.respond_to?(:call)
               v.call(self)
             elsif v.is_a?(Symbol) && respond_to?(v)
-              # if it is an attribute that is changing in an existing object, 
+              # if it is an attribute that is changing in an existing object,
               # be sure to grab the current version
               if has_attribute?(v) && send("#{v}_changed?".to_sym) && data[:event] != 'create'
                 send("#{v}_was".to_sym)
@@ -418,17 +439,9 @@ module PaperTrail
         data.merge(PaperTrail.controller_info || {})
       end
 
-      def item_before_change
-        previous = self.dup
-        # `dup` clears timestamps so we add them back.
-        all_timestamp_attributes.each do |column|
-          if self.class.column_names.include?(column.to_s) and not send("#{column}_was").nil?
-            previous[column] = send("#{column}_was")
-          end
-        end
-        enums = previous.respond_to?(:defined_enums) ? previous.defined_enums : {}
-        previous.tap do |prev|
-          prev.id = id # `dup` clears the `id` so we add that back
+      def attributes_before_change
+        attributes.tap do |prev|
+          enums = self.respond_to?(:defined_enums) ? self.defined_enums : {}
           changed_attributes.select { |k,v| self.class.column_names.include?(k) }.each do |attr, before|
             before = enums[attr][before] if enums[attr]
             prev[attr] = before
@@ -438,10 +451,10 @@ module PaperTrail
 
       # returns hash of attributes (with appropriate attributes serialized),
       # ommitting attributes to be skipped
-      def object_attrs_for_paper_trail(object)
-        attrs = object.attributes.except(*self.paper_trail_options[:skip])
+      def object_attrs_for_paper_trail(attributes_hash)
+        attrs = attributes_hash.except(*self.paper_trail_options[:skip])
         if PaperTrail.serialized_attributes?
-          self.class.serialize_attributes_for_paper_trail(attrs)
+          self.class.serialize_attributes_for_paper_trail!(attrs)
         end
         attrs
       end

data/lib/paper_trail/serializers/yaml.rb

@@ -23,7 +23,8 @@ module PaperTrail
       # in the serialized object_changes
       def where_object_changes_condition(arel_field, field, value)
         # Need to check first (before) and secondary (after) fields
-        if defined?(::YAML::ENGINE) && ::YAML::ENGINE.yamler == 'psych'
+        if (defined?(::YAML::ENGINE) && ::YAML::ENGINE.yamler == 'psych') ||
+          (defined?(::Psych) && ::YAML == ::Psych)
           arel_field.matches("%\n#{field}:\n- #{value}\n%").
             or(arel_field.matches("%\n#{field}:\n-%\n- #{value}\n%"))
         else # Syck adds extra spaces into array dumps