paper_trail 8.0.0 → 9.0.0

data/lib/paper_trail/reifier.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "paper_trail/attribute_serializers/object_attribute"
 require "paper_trail/reifiers/belongs_to"
 require "paper_trail/reifiers/has_and_belongs_to_many"
@@ -54,7 +56,7 @@ module PaperTrail
       # @api private
       def each_enabled_association(associations)
         associations.each do |assoc|
-          next unless assoc.klass.paper_trail.enabled?
+          next unless ::PaperTrail.request.enabled_for_model?(assoc.klass)
           yield assoc
         end
       end
@@ -192,7 +194,7 @@ module PaperTrail
       # @api private
       def reify_habtm_associations(transaction_id, model, options = {})
         model.class.reflect_on_all_associations(:has_and_belongs_to_many).each do |assoc|
-          pt_enabled = assoc.klass.paper_trail.enabled?
+          pt_enabled = ::PaperTrail.request.enabled_for_model?(assoc.klass)
           next unless model.class.paper_trail_save_join_tables.include?(assoc.name) || pt_enabled
           Reifiers::HasAndBelongsToMany.reify(pt_enabled, assoc, model, options, transaction_id)
         end

data/lib/paper_trail/reifiers/belongs_to.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PaperTrail
   module Reifiers
     # Reify a single `belongs_to` association of `model`.
@@ -37,7 +39,7 @@ module PaperTrail
         # @api private
         def load_version(assoc, id, transaction_id, version_at)
           assoc.klass.paper_trail.version_class.
-            where("item_type = ?", assoc.klass.name).
+            where("item_type = ?", assoc.klass.base_class.name).
             where("item_id = ?", id).
             where("created_at >= ? OR transaction_id = ?", version_at, transaction_id).
             order("id").limit(1).first

data/lib/paper_trail/reifiers/has_and_belongs_to_many.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PaperTrail
   module Reifiers
     # Reify a single HABTM association of `model`.
@@ -37,7 +39,7 @@ module PaperTrail
         # @api private
         def load_version(assoc, id, transaction_id, version_at)
           assoc.klass.paper_trail.version_class.
-            where("item_type = ?", assoc.klass.name).
+            where("item_type = ?", assoc.klass.base_class.name).
             where("item_id = ?", id).
             where("created_at >= ? OR transaction_id = ?", version_at, transaction_id).
             order("id").

data/lib/paper_trail/reifiers/has_many.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PaperTrail
   module Reifiers
     # Reify a single, direct (not `through`) `has_many` association of `model`.
@@ -98,7 +100,7 @@ module PaperTrail
             select("MIN(version_id)").
             where("foreign_key_name = ?", assoc.foreign_key).
             where("foreign_key_id = ?", model.id).
-            where("#{version_table}.item_type = ?", assoc.klass.name).
+            where("#{version_table}.item_type = ?", assoc.klass.base_class.name).
             where("created_at >= ? OR transaction_id = ?", version_at, tx_id).
             group("item_id").
             to_sql

data/lib/paper_trail/reifiers/has_many_through.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PaperTrail
   module Reifiers
     # Reify a single HMT association of `model`.
@@ -73,7 +75,7 @@ module PaperTrail
         def load_versions_for_hmt_association(assoc, ids, tx_id, version_at)
           version_id_subquery = assoc.klass.paper_trail.version_class.
             select("MIN(id)").
-            where("item_type = ?", assoc.klass.name).
+            where("item_type = ?", assoc.klass.base_class.name).
             where("item_id IN (?)", ids).
             where(
               "created_at >= ? OR transaction_id = ?",

data/lib/paper_trail/reifiers/has_one.rb

@@ -1,12 +1,46 @@
+# frozen_string_literal: true
+
 module PaperTrail
   module Reifiers
     # Reify a single `has_one` association of `model`.
     # @api private
     module HasOne
+      # A more helpful error message, instead of the AssociationTypeMismatch
+      # you would get if, eg. we were to try to assign a Bicycle to the :car
+      # association (before, if there were multiple records we would just take
+      # the first and hope for the best).
+      # @api private
+      class FoundMoreThanOne < RuntimeError
+        MESSAGE_FMT = <<~STR
+          Unable to reify has_one association. Expected to find one %s,
+          but found %d.
+
+          This is a known issue, and a good example of why association tracking
+          is an experimental feature that should not be used in production.
+
+          That said, this is a rare error. In spec/models/person_spec.rb we
+          reproduce it by having two STI models with the same foreign_key (Car
+          and Bicycle are both Vehicles and the FK for both is owner_id)
+
+          If you'd like to help fix this error, please read
+          https://github.com/airblade/paper_trail/issues/594
+          and see spec/models/person_spec.rb
+        STR
+
+        def initialize(base_class_name, num_records_found)
+          @base_class_name = base_class_name.to_s
+          @num_records_found = num_records_found.to_i
+        end
+
+        def message
+          format(MESSAGE_FMT, @base_class_name, @num_records_found)
+        end
+      end
+
       class << self
         # @api private
         def reify(assoc, model, options, transaction_id)
-          version = load_version_for_has_one(assoc, model, transaction_id, options[:version_at])
+          version = load_version(assoc, model, transaction_id, options[:version_at])
           return unless version
           if version.event == "create"
             create_event(assoc, model, options)
@@ -31,15 +65,29 @@ module PaperTrail
         # Given a has-one association `assoc` on `model`, return the version
         # record from the point in time identified by `transaction_id` or `version_at`.
         # @api private
-        def load_version_for_has_one(assoc, model, transaction_id, version_at)
+        def load_version(assoc, model, transaction_id, version_at)
+          base_class_name = assoc.klass.base_class.name
+          versions = load_versions(assoc, model, transaction_id, version_at, base_class_name)
+          case versions.length
+          when 0
+            nil
+          when 1
+            versions.first
+          else
+            raise FoundMoreThanOne.new(base_class_name, versions.length)
+          end
+        end
+
+        # @api private
+        def load_versions(assoc, model, transaction_id, version_at, base_class_name)
           version_table_name = model.class.paper_trail.version_class.table_name
           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.klass.name).
+            where("#{version_table_name}.item_type = ?", base_class_name).
             where("created_at >= ? OR transaction_id = ?", version_at, transaction_id).
             order("#{version_table_name}.id ASC").
-            first
+            load
         end
 
         # @api private

data/lib/paper_trail/request.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "request_store"
+
+module PaperTrail
+  # Manages variables that affect the current HTTP request, such as `whodunnit`.
+  #
+  # Please do not use `PaperTrail::Request` directly, use `PaperTrail.request`.
+  # Currently, `Request` is a `Module`, but in the future it is quite possible
+  # we may make it a `Class`. If we make such a choice, we will not provide any
+  # warning and will not treat it as a breaking change. You've been warned :)
+  #
+  # @api private
+  module Request
+    class InvalidOption < RuntimeError
+    end
+
+    class << self
+      # @api private
+      def clear_transaction_id
+        self.transaction_id = nil
+      end
+
+      # Sets any data from the controller that you want PaperTrail to store.
+      # See also `PaperTrail::Rails::Controller#info_for_paper_trail`.
+      #
+      #   PaperTrail.request.controller_info = { ip: request_user_ip }
+      #   PaperTrail.request.controller_info # => { ip: '127.0.0.1' }
+      #
+      # @api public
+      def controller_info=(value)
+        store[:controller_info] = value
+      end
+
+      # Returns the data from the controller that you want PaperTrail to store.
+      # See also `PaperTrail::Rails::Controller#info_for_paper_trail`.
+      #
+      #   PaperTrail.request.controller_info = { ip: request_user_ip }
+      #   PaperTrail.request.controller_info # => { ip: '127.0.0.1' }
+      #
+      # @api public
+      def controller_info
+        store[:controller_info]
+      end
+
+      # Switches PaperTrail off for the given model.
+      # @api public
+      def disable_model(model_class)
+        enabled_for_model(model_class, false)
+      end
+
+      # Switches PaperTrail on for the given model.
+      # @api public
+      def enable_model(model_class)
+        enabled_for_model(model_class, true)
+      end
+
+      # Sets whether PaperTrail is enabled or disabled for the current request.
+      # @api public
+      def enabled=(value)
+        store[:enabled] = value
+      end
+
+      # Returns `true` if PaperTrail is enabled for the request, `false` otherwise.
+      # See `PaperTrail::Rails::Controller#paper_trail_enabled_for_controller`.
+      # @api public
+      def enabled?
+        !!store[:enabled]
+      end
+
+      # Sets whether PaperTrail is enabled or disabled for this model in the
+      # current request.
+      # @api public
+      def enabled_for_model(model, value)
+        store[:"enabled_for_#{model}"] = value
+      end
+
+      # Returns `true` if PaperTrail is enabled for this model in the current
+      # request, `false` otherwise.
+      # @api public
+      def enabled_for_model?(model)
+        model.include?(::PaperTrail::Model::InstanceMethods) &&
+          !!store.fetch(:"enabled_for_#{model}", true)
+      end
+
+      # @api private
+      def merge(options)
+        options.to_h.each do |k, v|
+          store[k] = v
+        end
+      end
+
+      # @api private
+      def set(options)
+        store.clear
+        merge(options)
+      end
+
+      # Returns a deep copy of the internal hash from our RequestStore. Keys are
+      # all symbols. Values are mostly primitives, but whodunnit can be a Proc.
+      # We cannot use Marshal.dump here because it doesn't support Proc. It is
+      # unclear exactly how `deep_dup` handles a Proc, but it doesn't complain.
+      # @api private
+      def to_h
+        store.deep_dup
+      end
+
+      # @api private
+      def transaction_id
+        store[:transaction_id]
+      end
+
+      # @api private
+      def transaction_id=(id)
+        store[:transaction_id] = id
+      end
+
+      # Temporarily set `options` and execute a block.
+      # @api private
+      def with(options)
+        return unless block_given?
+        validate_public_options(options)
+        before = to_h
+        merge(options)
+        yield
+      ensure
+        set(before)
+      end
+
+      # Sets who is responsible for any changes that occur during request. You
+      # would normally use this in a migration or on the console, when working
+      # with models directly.
+      #
+      # `value` is usually a string, the name of a person, but you can set
+      # anything that responds to `to_s`. You can also set a Proc, which will
+      # not be evaluated until `whodunnit` is called later, usually right before
+      # inserting a `Version` record.
+      #
+      # @api public
+      def whodunnit=(value)
+        store[:whodunnit] = value
+      end
+
+      # Returns who is reponsible for any changes that occur during request.
+      #
+      # @api public
+      def whodunnit
+        who = store[:whodunnit]
+        who.respond_to?(:call) ? who.call : who
+      end
+
+      private
+
+      # Returns a Hash, initializing with default values if necessary.
+      # @api private
+      def store
+        RequestStore.store[:paper_trail] ||= {
+          enabled: true
+        }
+      end
+
+      # Provide a helpful error message if someone has a typo in one of their
+      # option keys. We don't validate option values here. That's traditionally
+      # been handled with casting (`to_s`, `!!`) in the accessor method.
+      # @api private
+      def validate_public_options(options)
+        options.each do |k, _v|
+          case k
+          when :controller_info,
+              /enabled_for_/,
+              :enabled,
+              :whodunnit
+            next
+          when :transaction_id
+            raise InvalidOption, "Cannot set private option: #{k}"
+          else
+            raise InvalidOption, "Invalid option: #{k}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/paper_trail/serializers/json.rb

@@ -1,4 +1,4 @@
-require "active_support/json"
+# frozen_string_literal: true
 
 module PaperTrail
   module Serializers
@@ -34,7 +34,7 @@ module PaperTrail
 
       def where_object_changes_condition(*)
         raise <<-STR.squish.freeze
-          where_object_changes no longer supports reading json from a text
+          where_object_changes no longer supports reading JSON from a text
           column. The old implementation was inaccurate, returning more records
           than you wanted. This feature was deprecated in 7.1.0 and removed in
           8.0.0. The json and jsonb datatypes are still supported. See the

data/lib/paper_trail/serializers/yaml.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "yaml"
 
 module PaperTrail
@@ -22,11 +24,14 @@ module PaperTrail
 
       # 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 = "%\n#{field}:\n- #{value}\n%"
-        m2 = "%\n#{field}:\n-%\n- #{value}\n%"
-        arel_field.matches(m1).or(arel_field.matches(m2))
+      def where_object_changes_condition(*)
+        raise <<-STR.squish.freeze
+          where_object_changes no longer supports reading YAML from a text
+          column. The old implementation was inaccurate, returning more records
+          than you wanted. This feature was deprecated in 8.1.0 and removed in
+          9.0.0. The json and jsonb datatypes are still supported. See
+          discussion at https://github.com/airblade/paper_trail/pull/997
+        STR
       end
     end
   end

data/lib/paper_trail/type_serializers/postgres_array_serializer.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module PaperTrail
+  module TypeSerializers
+    # Provides an alternative method of serialization
+    # and deserialization of PostgreSQL array columns.
+    class PostgresArraySerializer
+      def initialize(subtype, delimiter)
+        @subtype = subtype
+        @delimiter = delimiter
+      end
+
+      def serialize(array)
+        return serialize_with_ar(array) if active_record_pre_502?
+        array
+      end
+
+      def deserialize(array)
+        return deserialize_with_ar(array) if active_record_pre_502?
+
+        case array
+        # Needed for legacy reasons. If serialized array is a string
+        # then it was serialized with Rails < 5.0.2.
+        when ::String then deserialize_with_ar(array)
+        else array
+        end
+      end
+
+      private
+
+      def active_record_pre_502?
+        ::ActiveRecord::VERSION::MAJOR < 5 ||
+          (::ActiveRecord::VERSION::MINOR.zero? && ::ActiveRecord::VERSION::TINY < 2)
+      end
+
+      def serialize_with_ar(array)
+        ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.
+          new(@subtype, @delimiter).
+          serialize(array)
+      end
+
+      def deserialize_with_ar(array)
+        ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.
+          new(@subtype, @delimiter).
+          deserialize(array)
+      end
+    end
+  end
+end

data/lib/paper_trail/version_association_concern.rb

@@ -1,4 +1,4 @@
-require "active_support/concern"
+# frozen_string_literal: true
 
 module PaperTrail
   # Functionality for `PaperTrail::VersionAssociation`. Exists in a module

data/lib/paper_trail/version_concern.rb

@@ -1,4 +1,5 @@
-require "active_support/concern"
+# frozen_string_literal: true
+
 require "paper_trail/attribute_serializers/object_changes_attribute"
 require "paper_trail/queries/versions/where_object"
 require "paper_trail/queries/versions/where_object_changes"
@@ -230,11 +231,6 @@ module PaperTrail
       @paper_trail_originator ||= previous.try(:whodunnit)
     end
 
-    def originator
-      ::ActiveSupport::Deprecation.warn "Use paper_trail_originator instead of originator."
-      paper_trail_originator
-    end
-
     # Returns who changed the item from the state it had in this version. This
     # is an alias for `whodunnit`.
     def terminator