paper_trail 5.0.1 → 5.1.0

data/doc/warning_about_not_setting_whodunnit.md

@@ -0,0 +1,32 @@
+# The warning about not setting whodunnit
+
+After upgrading to PaperTrail 5, you see this warning:
+
+> user_for_paper_trail is present, but whodunnit has not been set. PaperTrail no
+> longer adds the set_paper_trail_whodunnit before_filter for you. Please add this
+> before_filter to your ApplicationController to continue recording whodunnit.
+
+## You want to track whodunnit
+
+Add the set_paper_trail_whodunnit before_filter to your ApplicationController.
+See the PaperTrail readme for an example (https://git.io/vrsbt).
+
+## You don't want to track whodunnit
+
+If you no longer want to track whodunnit, you may disable this
+warning by overriding user_for_paper_trail to return nil.
+
+```
+# in application_controller.rb
+def user_for_paper_trail
+  nil # disable whodunnit tracking
+end
+```
+
+## You just want the warning to go away
+
+To disable this warning for any other reason, use `skip_after_action`.
+
+```
+skip_after_action :warn_about_not_setting_whodunnit
+```

data/lib/paper_trail.rb

@@ -1,5 +1,4 @@
 require "request_store"
-require "paper_trail/attributes_serialization"
 require "paper_trail/cleaner"
 require "paper_trail/config"
 require "paper_trail/has_paper_trail"

data/lib/paper_trail/attribute_serializers/README.md

@@ -0,0 +1,10 @@
+Attribute Serializers
+=====================
+
+"Serialization" here refers to the preparation of data for insertion into a
+database, particularly the `object` and `object_changes` columns in the
+`versions` table.
+
+Likewise, "deserialization" refers to any processing of data after they
+have been read from the database, for example preparing the result of
+`VersionConcern#changeset`.

data/lib/paper_trail/attribute_serializers/cast_attribute_serializer.rb

@@ -0,0 +1,58 @@
+module PaperTrail
+  # :nodoc:
+  module AttributeSerializers
+    # The `CastAttributeSerializer` (de)serializes model attribute values. For
+    # example, the string "1.99" serializes into the integer `1` when assigned
+    # to an attribute of type `ActiveRecord::Type::Integer`.
+    #
+    # This implementation depends on the `type_for_attribute` method, which was
+    # introduced in rails 4.2. In older versions of rails, we shim this method
+    # with `LegacyActiveRecordShim`.
+    if ::ActiveRecord::VERSION::MAJOR >= 5
+      # This implementation uses AR 5's `serialize` and `deserialize`.
+      class CastAttributeSerializer
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def serialize(attr, val)
+          @klass.type_for_attribute(attr).serialize(val)
+        end
+
+        def deserialize(attr, val)
+          @klass.type_for_attribute(attr).deserialize(val)
+        end
+      end
+    else
+      # This implementation uses AR 4.2's `type_cast_for_database`. For
+      # versions of AR < 4.2 we provide an implementation of
+      # `type_cast_for_database` in our shim attribute type classes,
+      # `NoOpAttribute` and `SerializedAttribute`.
+      class CastAttributeSerializer
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def serialize(attr, val)
+          val = defined_enums[attr][val] if defined_enums[attr]
+          @klass.type_for_attribute(attr).type_cast_for_database(val)
+        end
+
+        def deserialize(attr, val)
+          val = @klass.type_for_attribute(attr).type_cast_from_database(val)
+          if defined_enums[attr]
+            defined_enums[attr].key(val)
+          else
+            val
+          end
+        end
+
+        private
+
+        def defined_enums
+          @defined_enums ||= (@klass.respond_to?(:defined_enums) ? @klass.defined_enums : {})
+        end
+      end
+    end
+  end
+end

data/lib/paper_trail/attribute_serializers/legacy_active_record_shim.rb

@@ -0,0 +1,48 @@
+module PaperTrail
+  module AttributeSerializers
+    # Included into model if AR version is < 4.2. Backport Rails 4.2 and later's
+    # `type_for_attribute` so we can build on a common interface.
+    module LegacyActiveRecordShim
+      # An attribute which needs no processing. It is part of our backport (shim)
+      # of rails 4.2's attribute API. See `type_for_attribute` below.
+      class NoOpAttribute
+        def type_cast_for_database(value)
+          value
+        end
+
+        def type_cast_from_database(data)
+          data
+        end
+      end
+      NO_OP_ATTRIBUTE = NoOpAttribute.new
+
+      # An attribute which requires manual (de)serialization to/from what we get
+      # from the database. It is part of our backport (shim) of rails 4.2's
+      # attribute API. See `type_for_attribute` below.
+      class SerializedAttribute
+        def initialize(coder)
+          @coder = coder.respond_to?(:dump) ? coder : PaperTrail.serializer
+        end
+
+        def type_cast_for_database(value)
+          @coder.dump(value)
+        end
+
+        def type_cast_from_database(data)
+          @coder.load(data)
+        end
+      end
+
+      def type_for_attribute(attr_name)
+        serialized_attribute_types[attr_name.to_s] || NO_OP_ATTRIBUTE
+      end
+
+      def serialized_attribute_types
+        @attribute_types ||= Hash[serialized_attributes.map do |attr_name, coder|
+          [attr_name, SerializedAttribute.new(coder)]
+        end]
+      end
+      private :serialized_attribute_types
+    end
+  end
+end

data/lib/paper_trail/attribute_serializers/object_attribute.rb

@@ -0,0 +1,39 @@
+require "paper_trail/attribute_serializers/cast_attribute_serializer"
+
+module PaperTrail
+  module AttributeSerializers
+    # Serialize or deserialize the `version.object` column.
+    class ObjectAttribute
+      def initialize(model_class)
+        @model_class = model_class
+      end
+
+      def serialize(attributes)
+        alter(attributes, :serialize)
+      end
+
+      def deserialize(attributes)
+        alter(attributes, :deserialize)
+      end
+
+      private
+
+      # Modifies `attributes` in place.
+      # TODO: Return a new hash instead.
+      def alter(attributes, serialization_method)
+        # Don't serialize before values before inserting into columns of type
+        # `JSON` on `PostgreSQL` databases.
+        return attributes if object_col_is_json?
+
+        serializer = CastAttributeSerializer.new(@model_class)
+        attributes.each do |key, value|
+          attributes[key] = serializer.send(serialization_method, key, value)
+        end
+      end
+
+      def object_col_is_json?
+        @model_class.paper_trail_version_class.object_col_is_json?
+      end
+    end
+  end
+end

data/lib/paper_trail/attribute_serializers/object_changes_attribute.rb

@@ -0,0 +1,42 @@
+require "paper_trail/attribute_serializers/cast_attribute_serializer"
+
+module PaperTrail
+  module AttributeSerializers
+    # Serialize or deserialize the `version.object_changes` column.
+    class ObjectChangesAttribute
+      def initialize(item_class)
+        @item_class = item_class
+      end
+
+      def serialize(changes)
+        alter(changes, :serialize)
+      end
+
+      def deserialize(changes)
+        alter(changes, :deserialize)
+      end
+
+      private
+
+      # Modifies `changes` in place.
+      # TODO: Return a new hash instead.
+      def alter(changes, serialization_method)
+        # Don't serialize before values before inserting into columns of type
+        # `JSON` on `PostgreSQL` databases.
+        return changes if object_changes_col_is_json?
+
+        serializer = CastAttributeSerializer.new(@item_class)
+        changes.clone.each do |key, change|
+          # `change` is an Array with two elements, representing before and after.
+          changes[key] = Array(change).map do |value|
+            serializer.send(serialization_method, key, value)
+          end
+        end
+      end
+
+      def object_changes_col_is_json?
+        @item_class.paper_trail_version_class.object_changes_col_is_json?
+      end
+    end
+  end
+end

data/lib/paper_trail/frameworks/rails/controller.rb

@@ -96,10 +96,10 @@ module PaperTrail
         if enabled && user_present && whodunnit_blank && !@set_paper_trail_whodunnit_called
           ::Kernel.warn <<-EOS.strip_heredoc
             user_for_paper_trail is present, but whodunnit has not been set.
-            PaperTrail no longer adds the set_paper_trail_whodunnit
-            before_filter for you. Please add this before_filter to your
-            ApplicationController to continue recording whodunnit. See the
-            PaperTrail readme for an example.
+            PaperTrail no longer adds the set_paper_trail_whodunnit callback for
+            you. To continue recording whodunnit, please add this before_action
+            callback to your ApplicationController . For more information,
+            please see https://git.io/vrTsk
           EOS
         end
       end

data/lib/paper_trail/has_paper_trail.rb

@@ -1,5 +1,7 @@
 require "active_support/core_ext/object" # provides the `try` method
-require "paper_trail/attributes_serialization"
+require "paper_trail/attribute_serializers/legacy_active_record_shim"
+require "paper_trail/attribute_serializers/object_attribute"
+require "paper_trail/attribute_serializers/object_changes_attribute"
 
 module PaperTrail
   # Extensions to `ActiveRecord::Base`.  See `frameworks/active_record.rb`.
@@ -110,7 +112,10 @@ module PaperTrail
         # Lazily include the instance methods so we don't clutter up
         # any more ActiveRecord models than we have to.
         send :include, InstanceMethods
-        send :extend, AttributesSerialization
+
+        if ::ActiveRecord::VERSION::STRING < "4.2"
+          send :extend, AttributeSerializers::LegacyActiveRecordShim
+        end
 
         class_attribute :version_association_name
         self.version_association_name = options[:version] || :version
@@ -309,7 +314,6 @@ module PaperTrail
 
       # Utility method for reifying. Anything executed inside the block will
       # appear like a new record.
-      # rubocop: disable Style/Alias
       def appear_as_new_record
         instance_eval {
           alias :old_new_record? :new_record?
@@ -318,7 +322,6 @@ module PaperTrail
         yield
         instance_eval { alias :new_record? :old_new_record? }
       end
-      # rubocop: enable Style/Alias
 
       # Temporarily overwrites the value of whodunnit and then executes the
       # provided block.
@@ -377,9 +380,7 @@ module PaperTrail
           if pt_record_object_changes? && changed_notably?
             data[:object_changes] = pt_recordable_object_changes
           end
-          if self.class.paper_trail_version_class.column_names.include?("transaction_id")
-            data[:transaction_id] = PaperTrail.transaction_id
-          end
+          add_transaction_id_to(data)
           version = send(self.class.versions_association_name).create! merge_metadata(data)
           update_transaction_id(version)
           save_associations(version)
@@ -399,12 +400,14 @@ module PaperTrail
           if pt_record_object_changes?
             data[:object_changes] = pt_recordable_object_changes
           end
-          if self.class.paper_trail_version_class.column_names.include?("transaction_id")
-            data[:transaction_id] = PaperTrail.transaction_id
-          end
+          add_transaction_id_to(data)
           version = send(self.class.versions_association_name).create merge_metadata(data)
-          update_transaction_id(version)
-          save_associations(version)
+          if version.errors.any?
+            log_version_errors(version, :update)
+          else
+            update_transaction_id(version)
+            save_associations(version)
+          end
         end
       end
 
@@ -446,7 +449,9 @@ module PaperTrail
 
       def changes_for_paper_trail
         notable_changes = changes.delete_if { |k, _v| !notably_changed.include?(k) }
-        self.class.serialize_attribute_changes_for_paper_trail!(notable_changes)
+        AttributeSerializers::ObjectChangesAttribute.
+          new(self.class).
+          serialize(notable_changes)
         notable_changes.to_hash
       end
 
@@ -480,14 +485,16 @@ module PaperTrail
             object: pt_recordable_object,
             whodunnit: PaperTrail.whodunnit
           }
-          if self.class.paper_trail_version_class.column_names.include?("transaction_id")
-            data[:transaction_id] = PaperTrail.transaction_id
-          end
+          add_transaction_id_to(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
-          update_transaction_id(version)
-          save_associations(version)
+          if version.errors.any?
+            log_version_errors(version, :destroy)
+          else
+            send("#{self.class.version_association_name}=", version)
+            send(self.class.versions_association_name).reset
+            update_transaction_id(version)
+            save_associations(version)
+          end
         end
       end
 
@@ -528,7 +535,7 @@ module PaperTrail
             self.class.paper_trail_save_join_tables.include?(a.name) ||
                 a.klass.paper_trail_enabled_for_model?
           assoc_version_args = {
-            version_id: version.id,
+            version_id: version.transaction_id,
             foreign_key_name: a.name
           }
           assoc_ids =
@@ -577,7 +584,7 @@ module PaperTrail
       # ommitting attributes to be skipped.
       def object_attrs_for_paper_trail
         attrs = attributes_before_change.except(*paper_trail_options[:skip])
-        self.class.serialize_attributes_for_paper_trail!(attrs)
+        AttributeSerializers::ObjectAttribute.new(self.class).serialize(attrs)
         attrs
       end
 
@@ -640,6 +647,11 @@ module PaperTrail
         (if_condition.blank? || if_condition.call(self)) && !unless_condition.try(:call, self)
       end
 
+      def add_transaction_id_to(data)
+        return unless self.class.paper_trail_version_class.column_names.include?("transaction_id")
+        data[:transaction_id] = PaperTrail.transaction_id
+      end
+
       # @api private
       def update_transaction_id(version)
         return unless self.class.paper_trail_version_class.column_names.include?("transaction_id")
@@ -649,6 +661,13 @@ module PaperTrail
           version.save
         end
       end
+
+      def log_version_errors(version, action)
+        version.logger.warn(
+          "Unable to create version for #{action} of #{self.class.name}##{id}: " +
+          version.errors.full_messages.join(", ")
+        )
+      end
     end
   end
 end

data/lib/paper_trail/reifier.rb

@@ -1,3 +1,5 @@
+require "paper_trail/attribute_serializers/object_attribute"
+
 module PaperTrail
   # Given a version record and some options, builds a new model object.
   # @api private
@@ -164,10 +166,9 @@ module PaperTrail
       # Set all the attributes in this version on the model.
       def reify_attributes(model, version, attrs)
         enums = model.class.respond_to?(:defined_enums) ? model.class.defined_enums : {}
-        model.class.unserialize_attributes_for_paper_trail! attrs
-
+        AttributeSerializers::ObjectAttribute.new(model.class).deserialize(attrs)
         attrs.each do |k, v|
-          # `unserialize_attributes_for_paper_trail!` will return the mapped enum value
+          # `ObjectAttribute#deserialize` will return the mapped enum value
           # and in Rails < 5, the []= uses the integer type caster from the column
           # definition (in general) and thus will turn a (usually) string to 0 instead
           # of the correct value

data/lib/paper_trail/serializers/json.rb

@@ -14,8 +14,8 @@ module PaperTrail
         ActiveSupport::JSON.encode object
       end
 
-      # Returns a SQL condition to be used to match the given field and value
-      # in the serialized object
+      # Returns a SQL LIKE condition to be used to match the given field and
+      # value in the serialized object.
       def where_object_condition(arel_field, field, value)
         # Convert to JSON to handle strings and nulls correctly.
         json_value = value.to_json
@@ -32,8 +32,8 @@ module PaperTrail
         end
       end
 
-      # Returns a SQL condition to be used to match the given field and value
-      # in the serialized object_changes
+      # Returns a SQL LIKE condition to be used to match the given field and
+      # value in the serialized `object_changes`.
       def where_object_changes_condition(arel_field, field, value)
         # Convert to JSON to handle strings and nulls correctly.
         json_value = value.to_json

data/lib/paper_trail/serializers/yaml.rb

@@ -14,14 +14,14 @@ module PaperTrail
         ::YAML.dump object
       end
 
-      # Returns a SQL condition to be used to match the given field and value
-      # in the serialized object
+      # Returns a SQL LIKE condition to be used to match the given field and
+      # value in the serialized object.
       def where_object_condition(arel_field, field, value)
         arel_field.matches("%\n#{field}: #{value}\n%")
       end
 
-      # Returns a SQL condition to be used to match the given field and value
-      # in the serialized object_changes
+      # Returns a SQL LIKE condition to be used to match the given field and
+      # value in the serialized `object_changes`.
       def where_object_changes_condition(arel_field, field, value)
         # Need to check first (before) and secondary (after) fields
         m1 = nil