paper_trail 3.0.9 → 4.0.0.beta1

data/lib/paper_trail/version_association_concern.rb

@@ -0,0 +1,13 @@
+require 'active_support/concern'
+
+module PaperTrail
+  module VersionAssociationConcern
+    extend ::ActiveSupport::Concern
+
+    included do
+      belongs_to :version
+
+      attr_accessible :version_id, :foreign_key_name, :foreign_key_id if PaperTrail.active_record_protected_attributes?
+    end
+  end
+end

data/lib/paper_trail/version_concern.rb

@@ -6,10 +6,15 @@ module PaperTrail
 
     included do
       belongs_to :item, :polymorphic => true
+      has_many :version_associations, :dependent => :destroy
+
       validates_presence_of :event
-      attr_accessible :item_type, :item_id, :event, :whodunnit, :object, :object_changes if PaperTrail.active_record_protected_attributes?
+
+      attr_accessible :item_type, :item_id, :event, :whodunnit, :object, :object_changes, :transaction_id, :created_at if PaperTrail.active_record_protected_attributes?
 
       after_create :enforce_version_limit!
+
+      scope :within_transaction, lambda { |id| where :transaction_id => id }
     end
 
     module ClassMethods
@@ -102,21 +107,28 @@ module PaperTrail
 
     # Restore the item from this version.
     #
-    # This will automatically restore all :has_one associations as they were "at the time",
-    # if they are also being versioned by PaperTrail.  NOTE: this isn't always guaranteed
-    # to work so you can either change the lookback period (from the default 3 seconds) or
-    # opt out.
+    # Optionally this can also restore all :has_one and :has_many (including has_many :through) associations as
+    # they were "at the time", if they are also being versioned by PaperTrail.
     #
     # Options:
-    # :has_one     set to `false` to opt out of has_one reification.
-    #              set to a float to change the lookback time (check whether your db supports
-    #              sub-second datetimes if you want them).
+    # :has_one              set to `true` to also reify has_one associations. Default is `false`.
+    # :has_many             set to `true` to also reify has_many and has_many :through associations.
+    #                       Default is `false`.
+    # :mark_for_destruction set to `true` to mark the has_one/has_many associations that did not exist in the
+    #                       reified version for destruction, instead of remove them. Default is `false`.
+    #                       This option is handy for people who want to persist the reified version.
+    # :dup                  `false` default behavior
+    #                       `true` it always create a new object instance. It is useful for comparing two versions of the same object
     def reify(options = {})
       return nil if object.nil?
 
       without_identity_map do
-        options[:has_one] = 3 if options[:has_one] == true
-        options.reverse_merge! :has_one => false
+        options.reverse_merge!(
+          :version_at => created_at,
+          :mark_for_destruction => false,
+          :has_one    => false,
+          :has_many   => false
+        )
 
         attrs = self.class.object_col_is_json? ? object : PaperTrail.serializer.load(object)
 
@@ -133,7 +145,7 @@ module PaperTrail
         # `item_type` will be the base class, not the actual subclass.
         # If `type` is present but empty, the class is the base class.
 
-        if item
+        if item && options[:dup] != true
           model = item
           # Look for attributes that exist in the model and not in this version. These attributes should be set to nil.
           (model.attribute_names - attrs.keys).each { |k| attrs[k] = nil }
@@ -144,14 +156,14 @@ module PaperTrail
           model = klass.new
         end
 
-        model.class.unserialize_attributes_for_paper_trail attrs
+        if PaperTrail.serialized_attributes?
+          model.class.unserialize_attributes_for_paper_trail attrs
+        end
 
         # Set all the attributes in this version on the model
         attrs.each do |k, v|
           if model.has_attribute?(k)
             model[k.to_sym] = v
-          elsif model.respond_to?("#{k}=")
-            model.send("#{k}=", v)
           else
             logger.warn "Attribute #{k} does not exist on #{item_type} (Version id: #{id})."
           end
@@ -160,34 +172,35 @@ module PaperTrail
         model.send "#{model.class.version_association_name}=", self
 
         unless options[:has_one] == false
-          reify_has_ones model, options[:has_one]
+          reify_has_ones model, options
+        end
+
+        unless options[:has_many] == false
+          reify_has_manys model, options
         end
 
         model
       end
     end
 
-    # Returns what changed in this version of the item.  Cf. `ActiveModel::Dirty#changes`.
-    # Returns `nil` if your `versions` table does not have an `object_changes` text column.
+    # Returns what changed in this version of the item. `ActiveModel::Dirty#changes`.
+    # returns `nil` if your `versions` table does not have an `object_changes` text column.
     def changeset
       return nil unless self.class.column_names.include? 'object_changes'
 
       _changes = self.class.object_changes_col_is_json? ? object_changes : PaperTrail.serializer.load(object_changes)
       @changeset ||= HashWithIndifferentAccess.new(_changes).tap do |changes|
-        item_type.constantize.unserialize_attribute_changes(changes)
+        if PaperTrail.serialized_attributes?
+          item_type.constantize.unserialize_attribute_changes(changes)
+        end
       end
     rescue
       {}
     end
 
     # Returns who put the item into the state stored in this version.
-    def paper_trail_originator
-      @paper_trail_originator ||= previous.whodunnit rescue nil
-    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
+      @originator ||= previous.whodunnit rescue nil
     end
 
     # Returns who changed the item from the state it had in this version.
@@ -236,25 +249,119 @@ module PaperTrail
     # Restore the `model`'s has_one associations as they were when this version was
     # superseded by the next (because that's what the user was looking at when they
     # made the change).
-    #
-    # The `lookback` sets how many seconds before the model's change we go.
-    def reify_has_ones(model, lookback)
+    def reify_has_ones(model, options = {})
+      version_table_name = model.class.paper_trail_version_class.table_name
       model.class.reflect_on_all_associations(:has_one).each do |assoc|
-        child = model.send assoc.name
-        if child.respond_to? :version_at
-          # N.B. we use version of the child as it was `lookback` seconds before the parent was updated.
-          # Ideally we want the version of the child as it was just before the parent was updated...
-          # but until PaperTrail knows which updates are "together" (e.g. parent and child being
-          # updated on the same form), it's impossible to tell when the overall update started;
-          # and therefore impossible to know when "just before" was.
-          if (child_as_it_was = child.version_at(send(PaperTrail.timestamp_field) - lookback.seconds))
-            child_as_it_was.attributes.each do |k,v|
-              model.send(assoc.name).send :write_attribute, k.to_sym, v rescue nil
+        if assoc.klass.paper_trail_enabled_for_model?
+          version = model.class.paper_trail_version_class.joins(:version_associations).
+            where("version_associations.foreign_key_name = ?", assoc.foreign_key).
+            where("version_associations.foreign_key_id = ?", model.id).
+            where("#{version_table_name}.item_type = ?", assoc.class_name).
+            where("created_at >= ? OR transaction_id = ?", options[:version_at], transaction_id).
+            order("#{version_table_name}.id ASC").first
+          if version
+            if version.event == 'create'
+              if options[:mark_for_destruction]
+                model.send(assoc.name).mark_for_destruction if model.send(assoc.name, true)
+              else
+                model.appear_as_new_record do
+                  model.send "#{assoc.name}=", nil
+                end
+              end
+            else
+              child = version.reify(options.merge(:has_many => false, :has_one => false))
+              model.appear_as_new_record do
+                model.send "#{assoc.name}=", child
+              end
             end
+          end
+        end
+      end
+    end
+
+    # Restore the `model`'s has_many associations as they were at version_at timestamp
+    # We lookup the first child versions after version_at timestamp or in same transaction.
+    def reify_has_manys(model, options = {})
+      assoc_has_many_through, assoc_has_many_directly =
+          model.class.reflect_on_all_associations(:has_many).partition { |assoc| assoc.options[:through] }
+      reify_has_many_directly(assoc_has_many_directly, model, options)
+      reify_has_many_through(assoc_has_many_through, model, options)
+    end
+
+    # Restore the `model`'s has_many associations not associated through another association
+    def reify_has_many_directly(associations, model, options = {})
+      version_table_name = model.class.paper_trail_version_class.table_name
+      associations.each do |assoc|
+        next unless assoc.klass.paper_trail_enabled_for_model?
+        version_id_subquery = PaperTrail::VersionAssociation.joins(model.class.version_association_name).
+            select("MIN(version_id)").
+            where("foreign_key_name = ?", assoc.foreign_key).
+            where("foreign_key_id = ?", model.id).
+            where("#{version_table_name}.item_type = ?", assoc.class_name).
+            where("created_at >= ? OR transaction_id = ?", options[:version_at], transaction_id).
+            group("item_id").to_sql
+        versions = model.class.paper_trail_version_class.where("id IN (#{version_id_subquery})").inject({}) do |acc, v|
+          acc.merge!(v.item_id => v)
+        end
+
+        # Pass true to force the model to load
+        collection = Array.new model.send(assoc.name, true)
+
+        # Iterate each child to replace it with the previous value if there is a version after the timestamp
+        collection.map! do |c|
+          if (version = versions.delete(c.id)).nil?
+            c
+          elsif version.event == 'create'
+            options[:mark_for_destruction] ? c.tap { |r| r.mark_for_destruction } : nil
+          else
+            version.reify(options.merge(:has_many => false, :has_one => false))
+          end
+        end
+
+        # Reify the rest of the versions and add them to the collection, these versions are for those that
+        # have been removed from the live associations
+        collection += versions.values.map { |version| version.reify(options.merge(:has_many => false, :has_one => false)) }
+
+        model.send(assoc.name).proxy_association.target = collection.compact
+      end
+    end
+
+    # Restore the `model`'s has_many associations through another association
+    # This must be called after the direct has_manys have been reified (reify_has_many_directly)
+    def reify_has_many_through(associations, model, options = {})
+      associations.each do |assoc|
+        next unless assoc.klass.paper_trail_enabled_for_model?
+        through_collection = model.send(assoc.options[:through])
+        collection_keys = through_collection.map { |through_model| through_model.send(assoc.foreign_key) }
+
+        version_id_subquery = assoc.klass.paper_trail_version_class.
+            select("MIN(id)").
+            where("item_type = ?", assoc.class_name).
+            where("item_id IN (?)", collection_keys).
+            where("created_at >= ? OR transaction_id = ?", options[:version_at], transaction_id).
+            group("item_id").to_sql
+        versions = assoc.klass.paper_trail_version_class.where("id IN (#{version_id_subquery})").inject({}) do |acc, v|
+          acc.merge!(v.item_id => v)
+        end
+
+        collection = Array.new assoc.klass.where(assoc.klass.primary_key => collection_keys)
+
+        # Iterate each child to replace it with the previous value if there is a version after the timestamp
+        collection.map! do |c|
+          if (version = versions.delete(c.id)).nil?
+            c
+          elsif version.event == 'create'
+            options[:mark_for_destruction] ? c.tap { |r| r.mark_for_destruction } : nil
           else
-            model.send "#{assoc.name}=", nil
+            version.reify(options.merge(:has_many => false, :has_one => false))
           end
         end
+
+        # Reify the rest of the versions and add them to the collection, these versions are for those that
+        # have been removed from the live associations
+        collection += versions.values.map { |version| version.reify(options.merge(:has_many => false, :has_one => false)) }
+
+        model.send(assoc.name).proxy_association.target = collection.compact
       end
     end
 

data/lib/paper_trail/version_number.rb

@@ -1,9 +1,9 @@
 module PaperTrail
   module VERSION
-    MAJOR = 3
+    MAJOR = 4
     MINOR = 0
-    TINY  = 9
-    PRE   = nil
+    TINY  = 0
+    PRE   = 'beta1'
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
 

data/paper_trail.gemspec

@@ -19,20 +19,27 @@ Gem::Specification.new do |s|
 
   s.required_rubygems_version = '>= 1.3.6'
 
-  s.add_dependency 'activerecord', ['>= 3.0', '< 5.0']
-  s.add_dependency 'activesupport', ['>= 3.0', '< 5.0']
+  s.add_dependency 'activerecord', ['>= 3.0', '< 6.0']
+  s.add_dependency 'activesupport', ['>= 3.0', '< 6.0']
 
   s.add_development_dependency 'rake', '~> 10.1.1'
   s.add_development_dependency 'shoulda', '~> 3.5'
   # s.add_development_dependency 'shoulda-matchers', '~> 1.5' # needed for ActiveRecord < 4
-  s.add_development_dependency 'ffaker', '<= 1.31.0'
+  s.add_development_dependency 'ffaker',  '>= 1.15'
   s.add_development_dependency 'railties', ['>= 3.0', '< 5.0']
   s.add_development_dependency 'sinatra', '~> 1.0'
   s.add_development_dependency 'rack-test', '>= 0.6'
-  s.add_development_dependency 'rspec-rails', '~> 2.14'
+  s.add_development_dependency 'rspec-rails', '~> 3.1.0'
   s.add_development_dependency 'generator_spec'
   s.add_development_dependency 'database_cleaner', '~> 1.2'
 
+  # 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"
+    s.add_development_dependency 'delorean'
+  else
+    s.add_development_dependency 'timecop'
+  end
+
   # JRuby support for the test ENV
   unless defined?(JRUBY_VERSION)
     s.add_development_dependency 'sqlite3', '~> 1.2'

data/spec/generators/install_generator_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 require 'generator_spec/test_case'
 require File.expand_path('../../../lib/generators/paper_trail/install_generator', __FILE__)
 
@@ -15,7 +15,7 @@ describe PaperTrail::InstallGenerator, :type => :generator do
     end
   
     it "generates a migration for creating the 'versions' table" do
-      destination_root.should have_structure {
+      expect(destination_root).to have_structure {
         directory 'db' do
           directory 'migrate' do
             migration 'create_versions' do
@@ -36,7 +36,7 @@ describe PaperTrail::InstallGenerator, :type => :generator do
     end
 
     it "generates a migration for creating the 'versions' table" do
-      destination_root.should have_structure {
+      expect(destination_root).to have_structure {
         directory 'db' do
           directory 'migrate' do
             migration 'create_versions' do
@@ -50,7 +50,7 @@ describe PaperTrail::InstallGenerator, :type => :generator do
     end
 
     it "generates a migration for adding the 'object_changes' column to the 'versions' table" do
-      destination_root.should have_structure {
+      expect(destination_root).to have_structure {
         directory 'db' do
           directory 'migrate' do
             migration 'add_object_changes_to_versions' do

data/spec/models/fluxor_spec.rb

@@ -0,0 +1,19 @@
+require 'rails_helper'
+
+describe Fluxor, :type => :model do
+  describe '`be_versioned` matcher' do
+    it { is_expected.to_not be_versioned }
+  end
+
+  describe "Methods" do
+    describe "Class" do
+      subject { Fluxor }
+
+      describe "#paper_trail_enabled_for_model?" do
+        it { is_expected.to respond_to(:paper_trail_enabled_for_model?) }
+
+        it { expect(subject.paper_trail_enabled_for_model?).to be false }
+      end
+    end
+  end
+end

data/spec/models/gadget_spec.rb

@@ -1,7 +1,7 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Gadget do
-  it { should be_versioned }
+describe Gadget, :type => :model do
+  it { is_expected.to be_versioned }
 
   let(:gadget) { Gadget.create!(:name => 'Wrench', :brand => 'Acme') }
 
@@ -22,16 +22,16 @@ describe Gadget do
   describe "Methods" do
     describe "Instance", :versioning => true do
       describe "private" do
-        describe :changed_notably? do
+        describe '#changed_notably?' do
           subject { Gadget.new(:created_at => Time.now) }
 
           # apparently the private methods list in Ruby18 is different than in Ruby19+
           if RUBY_VERSION.to_f >= 1.9
-            its(:private_methods) { should include(:changed_notably?) }
+            it { expect(subject.private_methods).to include(:changed_notably?) }
           end
 
           context "create events" do
-            it { subject.send(:changed_notably?).should == true }
+            it { expect(subject.send(:changed_notably?)).to be true }
           end
 
           context "update events" do
@@ -40,24 +40,24 @@ describe Gadget do
             context "without update timestamps" do
               it "should only acknowledge non-ignored attrs" do
                 subject.name = 'Wrench'
-                subject.send(:changed_notably?).should == true
+                expect(subject.send(:changed_notably?)).to be true
               end
 
               it "should not acknowledge ignored attrs and timestamps only" do
                 subject.brand = 'Acme'
-                subject.send(:changed_notably?).should == false
+                expect(subject.send(:changed_notably?)).to be false
               end
             end
 
             context "with update timestamps" do
               it "should only acknowledge non-ignored attrs" do
                 subject.name, subject.updated_at = 'Wrench', Time.now
-                subject.send(:changed_notably?).should == true
+                expect(subject.send(:changed_notably?)).to be true
               end
 
               it "should not acknowledge ignored attrs and timestamps only" do
                 subject.brand, subject.updated_at = 'Acme', Time.now
-                subject.send(:changed_notably?).should == false
+                expect(subject.send(:changed_notably?)).to be false
               end
             end
           end

data/spec/models/joined_version_spec.rb

@@ -1,32 +1,32 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe JoinedVersion, :versioning => true do
-  it { JoinedVersion.superclass.should == PaperTrail::Version }
+describe JoinedVersion, :type => :model, :versioning => true do
+  it { expect(JoinedVersion.superclass).to be PaperTrail::Version }
 
   let(:widget) { Widget.create!(:name => Faker::Name.name) }
   let(:version) { JoinedVersion.first }
 
   describe "Scopes" do
     describe "default_scope" do
-      it { JoinedVersion.default_scopes.should_not be_empty }
+      it { expect(JoinedVersion.default_scopes).not_to be_empty }
     end
 
     describe "VersionConcern::ClassMethods" do
       before { widget } # persist a widget
 
-      describe :subsequent do
+      describe '#subsequent' do
         it "shouldn't error out when there is a default_scope that joins" do
           JoinedVersion.subsequent(version).first
         end
       end
 
-      describe :preceding do
+      describe '#preceding' do
         it "shouldn't error out when there is a default scope that joins" do
           JoinedVersion.preceding(version).first
         end
       end
 
-      describe :between do
+      describe '#between' do
         it "shouldn't error out when there is a default scope that joins" do
           JoinedVersion.between(Time.now, 1.minute.from_now).first
         end
@@ -35,8 +35,8 @@ describe JoinedVersion, :versioning => true do
   end
 
   describe "Methods" do
-    describe :index do
-      it { should respond_to(:index) }
+    describe '#index' do
+      it { is_expected.to respond_to(:index) }
 
       it "shouldn't error out when there is a default scope that joins" do
         widget # persist a widget