mongo_trails 10.3.1 → 14.0.1

data/lib/mongo_trails/record_history.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module PaperTrail
-  # Represents the history of a single record.
-  # @api private
-  class RecordHistory
-    # @param versions - ActiveRecord::Relation - All versions of the record.
-    # @param version_class - Class - Usually PaperTrail::Version,
-    #   but it could also be a custom version class.
-    # @api private
-    def initialize(versions, version_class)
-      @versions = versions
-      @version_class = version_class
-    end
-
-    # Returns ordinal position of `version` in `sequence`.
-    # @api private
-    def index(version)
-      sequence.to_a.index(version)
-    end
-
-    private
-
-    # Returns `@versions` in chronological order.
-    # @api private
-    def sequence
-      if @version_class.primary_key_is_int?
-        @versions.select(primary_key).order(primary_key.asc)
-      else
-        @versions.
-          select([table[:created_at], primary_key]).
-          order(@version_class.timestamp_sort_order)
-      end
-    end
-
-    # @return - Arel::Attribute - Attribute representing the primary key
-    #   of the version table. The column's data type is usually a serial
-    #   integer (the rails convention) but not always.
-    # @api private
-    def primary_key
-      table[@version_class.primary_key]
-    end
-
-    # @return - Arel::Table - The version table, usually named `versions`, but
-    #   not always.
-    # @api private
-    def table
-      @version_class.arel_table
-    end
-  end
-end

data/lib/mongo_trails/reifier.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-require "mongo_trails/attribute_serializers/object_attribute"
-
-module PaperTrail
-  # Given a version record and some options, builds a new model object.
-  # @api private
-  module Reifier
-    class << self
-      # See `VersionConcern#reify` for documentation.
-      # @api private
-      def reify(version, options)
-        options = apply_defaults_to(options, version)
-        attrs = version.object_deserialized
-        model = init_model(attrs, options, version)
-        reify_attributes(model, version, attrs)
-        model.send "#{model.class.version_association_name}=", version
-        model
-      end
-
-      private
-
-      # Given a hash of `options` for `.reify`, return a new hash with default
-      # values applied.
-      # @api private
-      def apply_defaults_to(options, version)
-        {
-          version_at: version.created_at,
-          mark_for_destruction: false,
-          has_one: false,
-          has_many: false,
-          belongs_to: false,
-          has_and_belongs_to_many: false,
-          unversioned_attributes: :nil
-        }.merge(options)
-      end
-
-      # Initialize a model object suitable for reifying `version` into. Does
-      # not perform reification, merely instantiates the appropriate model
-      # class and, if specified by `options[:unversioned_attributes]`, sets
-      # unversioned attributes to `nil`.
-      #
-      # Normally a polymorphic belongs_to relationship allows us to get the
-      # object we belong to by calling, in this case, `item`.  However this
-      # returns nil if `item` has been destroyed, and we need to be able to
-      # retrieve destroyed objects.
-      #
-      # In this situation we constantize the `item_type` to get hold of the
-      # class...except when the stored object's attributes include a `type`
-      # key.  If this is the case, the object we belong to is using single
-      # table inheritance (STI) and the `item_type` will be the base class,
-      # not the actual subclass. If `type` is present but empty, the class is
-      # the base class.
-      def init_model(attrs, options, version)
-        klass = version_reification_class(version, attrs)
-
-        # The `dup` option and destroyed version always returns a new object,
-        # otherwise we should attempt to load item or to look for the item
-        # outside of default scope(s).
-        model = if options[:dup] == true || version.event == "destroy"
-                  klass.new
-                else
-                  find_cond = { klass.primary_key => version.item_id }
-
-                  version.item || klass.unscoped.where(find_cond).first || klass.new
-                end
-
-        if options[:unversioned_attributes] == :nil && !model.new_record?
-          init_unversioned_attrs(attrs, model)
-        end
-
-        model
-      end
-
-      # Look for attributes that exist in `model` and not in this version.
-      # These attributes should be set to nil. Modifies `attrs`.
-      # @api private
-      def init_unversioned_attrs(attrs, model)
-        (model.attribute_names - attrs.keys).each { |k| attrs[k] = nil }
-      end
-
-      # Reify onto `model` an attribute named `k` with value `v` from `version`.
-      #
-      # `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.
-      #
-      # @api private
-      def reify_attribute(k, v, model, version)
-        if model.has_attribute?(k)
-          model[k.to_sym] = v
-        elsif model.respond_to?("#{k}=")
-          model.send("#{k}=", v)
-        elsif version.logger
-          version.logger.warn(
-            "Attribute #{k} does not exist on #{version.item_type} (Version id: #{version.id})."
-          )
-        end
-      end
-
-      # Reify onto `model` all the attributes of `version`.
-      # @api private
-      def reify_attributes(model, version, attrs)
-        AttributeSerializers::ObjectAttribute.new(model.class).deserialize(attrs)
-        attrs.each do |k, v|
-          reify_attribute(k, v, model, version)
-        end
-      end
-
-      # Given a `version`, return the class to reify. This method supports
-      # Single Table Inheritance (STI) with custom inheritance columns.
-      #
-      # For example, imagine a `version` whose `item_type` is "Animal". The
-      # `animals` table is an STI table (it has cats and dogs) and it has a
-      # custom inheritance column, `species`. If `attrs["species"]` is "Dog",
-      # this method returns the constant `Dog`. If `attrs["species"]` is blank,
-      # this method returns the constant `Animal`. You can see this particular
-      # example in action in `spec/models/animal_spec.rb`.
-      #
-      # TODO: Duplication: similar `constantize` in VersionConcern#version_limit
-      def version_reification_class(version, attrs)
-        inheritance_column_name = version.item_type.constantize.inheritance_column
-        inher_col_value = attrs[inheritance_column_name]
-        class_name = inher_col_value.blank? ? version.item_type : inher_col_value
-        class_name.constantize
-      end
-    end
-  end
-end

data/lib/mongo_trails/request.rb

@@ -1,166 +0,0 @@
-# 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
-      # 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
-
-      # 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
-          else
-            raise InvalidOption, "Invalid option: #{k}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mongo_trails/serializers/json.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module PaperTrail
-  module Serializers
-    # An alternate serializer for, e.g. `versions.object`.
-    module JSON
-      extend self # makes all instance methods become module methods as well
-
-      def load(string)
-        ActiveSupport::JSON.decode string
-      end
-
-      def dump(object)
-        ActiveSupport::JSON.encode object
-      end
-
-      # 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
-
-        # If the value is a number, we need to ensure that we find the next
-        # character too, which is either `,` or `}`, to ensure that searching
-        # for the value 12 doesn't yield false positives when the value is
-        # 123.
-        if value.is_a? Numeric
-          arel_field.matches("%\"#{field}\":#{json_value},%").
-            or(arel_field.matches("%\"#{field}\":#{json_value}}%"))
-        else
-          arel_field.matches("%\"#{field}\":#{json_value}%")
-        end
-      end
-
-      def where_object_changes_condition(*)
-        raise <<-STR.squish.freeze
-          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
-          discussion at https://github.com/paper-trail-gem/paper_trail/issues/803
-        STR
-      end
-    end
-  end
-end

data/lib/mongo_trails/serializers/yaml.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-
-module PaperTrail
-  module Serializers
-    # The default serializer for, e.g. `versions.object`.
-    module YAML
-      extend self # makes all instance methods become module methods as well
-
-      def load(string)
-        ::YAML.load string
-      end
-
-      # @param object (Hash | HashWithIndifferentAccess) - Coming from
-      # `recordable_object` `object` will be a plain `Hash`. However, due to
-      # recent [memory optimizations](https://git.io/fjeYv), when coming from
-      # `recordable_object_changes`, it will be a `HashWithIndifferentAccess`.
-      def dump(object)
-        object = object.to_hash if object.is_a?(HashWithIndifferentAccess)
-        ::YAML.dump object
-      end
-
-      # 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 LIKE condition to be used to match the given field and
-      # value in the serialized `object_changes`.
-      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/paper-trail-gem/paper_trail/pull/997
-        STR
-      end
-    end
-  end
-end

data/lib/mongo_trails/type_serializers/postgres_array_serializer.rb

@@ -1,48 +0,0 @@
-# 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.gem_version < Gem::Version.new("5.0.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/mongo_trails/version_number.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module PaperTrail
-  # The version number of the paper_trail gem. Not to be confused with
-  # `PaperTrail::Version`. Ruby constants are case-sensitive, apparently,
-  # and they are two different modules! It would be nice to remove `VERSION`,
-  # because of this confusion, but it's not worth the breaking change.
-  # People are encouraged to use `PaperTrail.gem_version` instead.
-  module VERSION
-    MAJOR = 10
-    MINOR = 3
-    TINY = 1
-
-    # Set PRE to nil unless it's a pre-release (beta, rc, etc.)
-    PRE = nil
-
-    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".").freeze
-
-    def self.to_s
-      STRING
-    end
-  end
-end