paper_trail 3.0.9 → 4.0.0.beta1

data/gemfiles/3.0.gemfile

@@ -6,7 +6,7 @@ gem 'i18n', '~> 0.6.11'
 group :development, :test do
   gem 'rake', '~> 10.1.1'
   gem 'shoulda', '~> 3.5'
-  gem 'ffaker',  '<= 1.31.0'
+  gem 'ffaker',  '>= 1.15'
 
   # Testing of Rails
   gem 'railties', '~> 3.0'
@@ -16,16 +16,23 @@ group :development, :test do
   gem 'rack-test', '>= 0.6'
 
   # RSpec testing
-  gem 'rspec-rails', '~> 2.14'
+  gem 'rspec-rails', '~> 3.1.0'
   gem 'generator_spec'
 
   # To do proper transactional testing with ActiveSupport::TestCase on MySQL
   gem 'database_cleaner', '~> 1.2.0'
 
+  # Allow time travel in testing. timecop is only supported after 1.9.2 but does a better cleanup at 'return'
+  if RUBY_VERSION < "1.9.2"
+    gem 'delorean'
+  else
+    gem 'timecop'
+  end
+
   platforms :ruby do 
     gem 'sqlite3', '~> 1.2'
     gem 'mysql2', '~> 0.3'
-    gem 'pg', '~> 0.17.1'
+    gem 'pg', '~> 0.17'
   end
 
   platforms :jruby, :ruby_18 do
@@ -39,6 +46,5 @@ 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

@@ -6,17 +6,33 @@ module PaperTrail
     include ::Rails::Generators::Migration
 
     source_root File.expand_path('../templates', __FILE__)
-    class_option :with_changes, :type => :boolean, :default => false, :desc => "Store changeset (diff) with each version"
+    class_option :with_changes, :type => :boolean, :default => false,
+      :desc => "Store changeset (diff) with each version"
+    class_option :with_associations, :type => :boolean, :default => false,
+      :desc => "Store transactional IDs to support association restoration"
 
     desc 'Generates (but does not run) a migration to add a versions table.'
 
     def create_migration_file
-      migration_template 'create_versions.rb', 'db/migrate/create_versions.rb'
-      migration_template 'add_object_changes_to_versions.rb', 'db/migrate/add_object_changes_to_versions.rb' if options.with_changes?
+      add_paper_trail_migration('create_versions')
+      add_paper_trail_migration('add_object_changes_to_versions') if options.with_changes?
+      if options.with_associations?
+        add_paper_trail_migration('create_version_associations')
+        add_paper_trail_migration('add_transaction_id_column_to_versions')
+      end
     end
 
     def self.next_migration_number(dirname)
       ::ActiveRecord::Generators::Base.next_migration_number(dirname)
     end
+
+    protected
+    def add_paper_trail_migration(template)
+      migration_dir = File.expand_path('db/migrate')
+
+      if !self.class.migration_exists?(migration_dir, template)
+        migration_template "#{template}.rb", "db/migrate/#{template}.rb"
+      end
+    end
   end
 end

data/lib/generators/paper_trail/templates/add_transaction_id_column_to_versions.rb

@@ -0,0 +1,11 @@
+class AddTransactionIdColumnToVersions < ActiveRecord::Migration
+  def self.up
+    add_column :versions, :transaction_id, :integer
+    add_index :versions, [:transaction_id]
+  end
+
+  def self.down
+    remove_index :versions, [:transaction_id]
+    remove_column :versions, :transaction_id
+  end
+end

data/lib/generators/paper_trail/templates/create_version_associations.rb

@@ -0,0 +1,17 @@
+class CreateVersionAssociations < ActiveRecord::Migration
+  def self.up
+    create_table :version_associations do |t|
+      t.integer  :version_id
+      t.string   :foreign_key_name, :null => false
+      t.integer  :foreign_key_id
+    end
+    add_index :version_associations, [:version_id]
+    add_index :version_associations, [:foreign_key_name, :foreign_key_id], :name => 'index_version_associations_on_foreign_key'
+  end
+
+  def self.down
+    remove_index :version_associations, [:version_id]
+    remove_index :version_associations, :name => 'index_version_associations_on_foreign_key'
+    drop_table :version_associations
+  end
+end

data/lib/paper_trail.rb

@@ -22,6 +22,13 @@ module PaperTrail
     !!PaperTrail.config.enabled
   end
 
+  # ActiveRecord 5 drops support for serialized attributes; for previous
+  # versions of ActiveRecord it is supported, we have a config option 
+  # to enable it within PaperTrail.
+  def self.serialized_attributes?
+    !!PaperTrail.config.serialized_attributes && ::ActiveRecord::VERSION::MAJOR < 5
+  end
+
   # Sets whether PaperTrail is enabled or disabled for the current request.
   def self.enabled_for_controller=(value)
     paper_trail_store[:request_enabled_for_controller] = value
@@ -94,6 +101,18 @@ module PaperTrail
     @active_record_protected_attributes ||= ::ActiveRecord::VERSION::MAJOR < 4 || !!defined?(ProtectedAttributes)
   end
 
+  def self.transaction?
+    ActiveRecord::Base.connection.open_transactions > 0
+  end
+
+  def self.transaction_id
+    paper_trail_store[:transaction_id]
+  end
+
+  def self.transaction_id=(id)
+    paper_trail_store[:transaction_id] = id
+  end
+
   private
 
   # Thread-safe hash to hold PaperTrail's data.
@@ -125,8 +144,9 @@ ActiveSupport.on_load(:active_record) do
 end
 
 # Require frameworks
-require 'paper_trail/frameworks/active_record'
 require 'paper_trail/frameworks/sinatra'
-require 'paper_trail/frameworks/rails' if defined? Rails
-require 'paper_trail/frameworks/rspec' if defined? RSpec::Core
-require 'paper_trail/frameworks/cucumber' if defined? World
+if defined? Rails
+  require 'paper_trail/frameworks/rails'
+else
+  require 'paper_trail/frameworks/active_record'
+end

data/lib/paper_trail/cleaner.rb

@@ -12,10 +12,10 @@ module PaperTrail
     def clean_versions!(options = {})
       options = {:keeping => 1, :date => :all}.merge(options)
       gather_versions(options[:item_id], options[:date]).each do |item_id, versions|
-        versions.group_by { |v| v.send(PaperTrail.timestamp_field).to_date }.each do |date, versions|
+        versions.group_by { |v| v.send(PaperTrail.timestamp_field).to_date }.each do |date, _versions|
           # remove the number of versions we wish to keep from the collection of versions prior to destruction
-          versions.pop(options[:keeping])
-          versions.map(&:destroy)
+          _versions.pop(options[:keeping])
+          _versions.map(&:destroy)
         end
       end
     end

data/lib/paper_trail/config.rb

@@ -4,11 +4,28 @@ module PaperTrail
   class Config
     include Singleton
     attr_accessor :enabled, :timestamp_field, :serializer, :version_limit
+    attr_reader :serialized_attributes
 
     def initialize
       @enabled         = true # Indicates whether PaperTrail is on or off.
       @timestamp_field = :created_at
       @serializer      = PaperTrail::Serializers::YAML
+
+      # This setting only defaults to false on AR 4.2+, because that's when
+      # it was deprecated. We want it to function with older versions of
+      # ActiveRecord by default.
+      if ::ActiveRecord::VERSION::STRING < '4.2'
+        @serialized_attributes = true
+      end
+    end
+
+    def serialized_attributes=(value)
+      if ::ActiveRecord::VERSION::MAJOR >= 5
+        warn("DEPRECATED: ActiveRecord 5.0 deprecated `serialized_attributes` "  +
+          "without replacement, so this PaperTrail config setting does " +
+          "nothing with this version, and is always turned off")
+      end
+      @serialized_attributes = value
     end
   end
 end

data/lib/paper_trail/frameworks/active_record/models/paper_trail/version_association.rb

@@ -0,0 +1,7 @@
+require 'paper_trail/version_association_concern'
+
+module PaperTrail
+  class VersionAssociation < ::ActiveRecord::Base
+    include PaperTrail::VersionAssociationConcern
+  end
+end

data/lib/paper_trail/frameworks/rails.rb

@@ -1,4 +1,5 @@
 require 'paper_trail/frameworks/rails/controller'
+require 'paper_trail/frameworks/rails/engine'
 
 module PaperTrail
   module Rails

data/lib/paper_trail/frameworks/rspec.rb

@@ -22,3 +22,8 @@ RSpec::Matchers.define :be_versioned do
   # check to see if the model has `has_paper_trail` declared on it
   match { |actual| actual.kind_of?(::PaperTrail::Model::InstanceMethods) }
 end
+
+RSpec::Matchers.define :have_a_version_with do |attributes|
+  # check if the model has a version with the specified attributes
+  match { |actual| actual.versions.where_object(attributes).any? }
+end

data/lib/paper_trail/has_paper_trail.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/object' # provides the `try` method
-
 module PaperTrail
   module Model
 
@@ -76,10 +74,15 @@ module PaperTrail
         after_create  :record_create, :if => :save_version? if options_on.empty? || options_on.include?(:create)
         if options_on.empty? || options_on.include?(:update)
           before_save   :reset_timestamp_attrs_for_update_if_needed!, :on => :update
-          before_update :record_update, :if => :save_version?
+          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)
+
+        # Reset the transaction id when the transaction is closed
+        after_commit :reset_transaction_id
+        after_rollback :reset_transaction_id
+        after_rollback :clear_rolled_back_versions
       end
 
       # Switches PaperTrail off for this class.
@@ -103,6 +106,7 @@ module PaperTrail
       end
 
       def paper_trail_enabled_for_model?
+        return false unless self.include?(PaperTrail::Model::InstanceMethods)
         PaperTrail.enabled_for_model?(self)
       end
 
@@ -117,7 +121,8 @@ module PaperTrail
 
         serialized_attributes.each do |key, coder|
           if attributes.key?(key)
-            coder = PaperTrail::Serializers::YAML unless coder.respond_to?(:dump) # Fall back to YAML if `coder` has no `dump` method
+            # Fall back to current serializer if `coder` has no `dump` method
+            coder = PaperTrail.serializer unless coder.respond_to?(:dump)
             attributes[key] = coder.dump(attributes[key])
           end
         end
@@ -129,7 +134,7 @@ module PaperTrail
 
         serialized_attributes.each do |key, coder|
           if attributes.key?(key)
-            coder = PaperTrail::Serializers::YAML unless coder.respond_to?(:dump)
+            coder = PaperTrail.serializer unless coder.respond_to?(:dump)
             attributes[key] = coder.load(attributes[key])
           end
         end
@@ -142,7 +147,8 @@ module PaperTrail
 
         serialized_attributes.each do |key, coder|
           if changes.key?(key)
-            coder = PaperTrail::Serializers::YAML unless coder.respond_to?(:dump) # Fall back to YAML if `coder` has no `dump` method
+            # Fall back to current serializer if `coder` has no `dump` method
+            coder = PaperTrail.serializer unless coder.respond_to?(:dump)
             old_value, new_value = changes[key]
             changes[key] = [coder.dump(old_value),
                             coder.dump(new_value)]
@@ -156,7 +162,7 @@ module PaperTrail
 
         serialized_attributes.each do |key, coder|
           if changes.key?(key)
-            coder = PaperTrail::Serializers::YAML unless coder.respond_to?(:dump)
+            coder = PaperTrail.serializer unless coder.respond_to?(:dump)
             old_value, new_value = changes[key]
             changes[key] = [coder.load(old_value),
                             coder.load(new_value)]
@@ -175,13 +181,14 @@ module PaperTrail
       end
 
       # Returns who put the object into its current state.
-      def paper_trail_originator
+      def 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
+      # Invoked after rollbacks to ensure versions records are not created
+      # for changes that never actually took place
+      def clear_rolled_back_versions
+        send(self.class.versions_association_name).reload
       end
 
       # Returns the object (not a Version) as it was at the given timestamp.
@@ -228,6 +235,16 @@ module PaperTrail
         self.class.paper_trail_on! if paper_trail_was_enabled
       end
 
+      # Utility method for reifying. Anything executed inside the block will appear like a new record
+      def appear_as_new_record
+        instance_eval {
+          alias :old_new_record? :new_record?
+          alias :new_record? :present?
+        }
+        yield
+        instance_eval { alias :new_record? :old_new_record? }
+      end
+
       # Temporarily overwrites the value of whodunnit and then executes the provided block.
       def whodunnit(value)
         raise ArgumentError, 'expected to receive a block' unless block_given?
@@ -263,15 +280,20 @@ 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,
+            :transaction_id => PaperTrail.transaction_id
           }
-
+          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')
             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
-          send(self.class.versions_association_name).create! merge_metadata(data)
+          version = send(self.class.versions_association_name).create! merge_metadata(data)
+          set_transaction_id(version)
+          save_associations(version)
         end
       end
 
@@ -279,23 +301,30 @@ module PaperTrail
         if paper_trail_switched_on? && changed_notably?
           object_attrs = object_attrs_for_paper_trail(item_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,
+            :transaction_id => PaperTrail.transaction_id
           }
-
+          if respond_to?(:updated_at)
+            data[PaperTrail.timestamp_field] = updated_at
+          end
           if 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
-          send(self.class.versions_association_name).build merge_metadata(data)
+          version = send(self.class.versions_association_name).create merge_metadata(data)
+          set_transaction_id(version)
+          save_associations(version)
         end
       end
 
       def changes_for_paper_trail
-        self.changes.delete_if do |key, value|
-          !notably_changed.include?(key)
-        end.tap { |changes| self.class.serialize_attribute_changes(changes) }
+        _changes = changes.delete_if { |k,v| !notably_changed.include?(k) }
+        if PaperTrail.serialized_attributes?
+          self.class.serialize_attribute_changes(_changes)
+        end
+        _changes.to_hash
       end
 
       # Invoked via`after_update` callback for when a previous version is reified and then saved
@@ -305,24 +334,59 @@ module PaperTrail
 
       def reset_timestamp_attrs_for_update_if_needed!
         return if self.live? # invoked via callback when a user attempts to persist a reified `Version`
-        timestamp_attributes_for_update_in_model.each { |column| send("reset_#{column}!") }
+        timestamp_attributes_for_update_in_model.each do |column|
+          # ActiveRecord 4.2 deprecated `reset_column!` in favor of `restore_column!`
+          if respond_to?("restore_#{column}!")
+            send("restore_#{column}!")
+          else
+            send("reset_#{column}!")
+          end
+        end
       end
 
       def record_destroy
         if paper_trail_switched_on? and not new_record?
           object_attrs = object_attrs_for_paper_trail(item_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,
+            :transaction_id => PaperTrail.transaction_id
           }
-          send("#{self.class.version_association_name}=", self.class.paper_trail_version_class.create(merge_metadata(data)))
+          version = self.class.paper_trail_version_class.create(merge_metadata(data))
+          send("#{self.class.version_association_name}=", version)
           send(self.class.versions_association_name).send :load_target
+          set_transaction_id(version)
+          save_associations(version)
+        end
+      end
+
+      def save_associations(version)
+        self.class.reflect_on_all_associations(:belongs_to).each do |assoc|
+          if assoc.klass.paper_trail_enabled_for_model?
+            PaperTrail::VersionAssociation.create(
+              :version_id => version.id,
+              :foreign_key_name => assoc.foreign_key,
+              :foreign_key_id => self.send(assoc.foreign_key)
+            )
+          end
+        end
+      end
+
+      def set_transaction_id(version)
+        if PaperTrail.transaction? && PaperTrail.transaction_id.nil?
+           PaperTrail.transaction_id = version.id
+           version.transaction_id = version.id
+           version.save
         end
       end
 
+      def reset_transaction_id
+        PaperTrail.transaction_id = nil
+      end
+
       def merge_metadata(data)
         # First we merge the model-level metadata in `meta`.
         paper_trail_options[:meta].each do |k,v|
@@ -345,8 +409,16 @@ module PaperTrail
       end
 
       def item_before_change
-        attributes.tap do |prev|
-          enums = self.respond_to?(:defined_enums) ? self.defined_enums : {}
+        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
           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
@@ -356,16 +428,18 @@ module PaperTrail
 
       # returns hash of attributes (with appropriate attributes serialized),
       # ommitting attributes to be skipped
-      def object_attrs_for_paper_trail(attributes_hash)
-        attributes_hash.except(*self.paper_trail_options[:skip]).tap do |attributes|
-          self.class.serialize_attributes_for_paper_trail(attributes)
+      def object_attrs_for_paper_trail(object)
+        attrs = object.attributes.except(*self.paper_trail_options[:skip])
+        if PaperTrail.serialized_attributes?
+          self.class.serialize_attributes_for_paper_trail(attrs)
         end
+        attrs
       end
 
       # This method is invoked in order to determine whether it is appropriate to generate a new version instance.
-      # In ActiveRecord 4, the way ActiveModel::Dirty handles the `changes` hash has changed so that
-      # `timestamp_attributes_for_update` get inserted PRIOR to the persistence happening, so we must accomodate
-      # this by checking to ensure attributes other than those ignored and update timestamps are really being modified.
+      # Because we are now using `after_(create/update/etc)` callbacks, we need to go out of our way to
+      # ensure that during updates timestamp attributes are not acknowledged as a notable changes
+      # to raise false positives when attributes are ignored.
       def changed_notably?
         if self.paper_trail_options[:ignore].any? && (changed & self.paper_trail_options[:ignore]).any?
           (notably_changed - timestamp_attributes_for_update_in_model.map(&:to_s)).any?