mongo_trails 10.3.1 → 14.0.0

data/lib/mongo_trails/has_paper_trail.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require "mongo_trails/attribute_serializers/object_attribute"
-require "mongo_trails/attribute_serializers/object_changes_attribute"
-require "mongo_trails/model_config"
-require "mongo_trails/record_trail"
-
-module PaperTrail
-  # Extensions to `ActiveRecord::Base`.  See `frameworks/active_record.rb`.
-  # It is our goal to have the smallest possible footprint here, because
-  # `ActiveRecord::Base` is a very crowded namespace! That is why we introduced
-  # `.paper_trail` and `#paper_trail`.
-  module Model
-    def self.included(base)
-      base.send :extend, ClassMethods
-    end
-
-    # :nodoc:
-    module ClassMethods
-      # Declare this in your model to track every create, update, and destroy.
-      # Each version of the model is available in the `versions` association.
-      #
-      # Options:
-      #
-      # - :on - The events to track (optional; defaults to all of them). Set
-      #   to an array of `:create`, `:update`, `:destroy` and `:touch` as desired.
-      # - :class_name (deprecated) - The name of a custom Version class that
-      #   includes `PaperTrail::VersionConcern`.
-      # - :ignore - An array of attributes for which a new `Version` will not be
-      #   created if only they change. It can also accept a Hash as an
-      #   argument where the key is the attribute to ignore (a `String` or
-      #   `Symbol`), which will only be ignored if the value is a `Proc` which
-      #   returns truthily.
-      # - :if, :unless - Procs that allow to specify conditions when to save
-      #   versions for an object.
-      # - :only - Inverse of `ignore`. A new `Version` will be created only
-      #   for these attributes if supplied it can also accept a Hash as an
-      #   argument where the key is the attribute to track (a `String` or
-      #   `Symbol`), which will only be counted if the value is a `Proc` which
-      #   returns truthily.
-      # - :skip - Fields to ignore completely.  As with `ignore`, updates to
-      #   these fields will not create a new `Version`.  In addition, these
-      #   fields will not be included in the serialized versions of the object
-      #   whenever a new `Version` is created.
-      # - :meta - A hash of extra data to store. You must add a column to the
-      #   `versions` table for each key. Values are objects or procs (which
-      #   are called with `self`, i.e. the model with the paper trail).  See
-      #   `PaperTrail::Controller.info_for_paper_trail` for how to store data
-      #   from the controller.
-      # - :versions - Either,
-      #   - A String (deprecated) - The name to use for the versions
-      #     association.  Default is `:versions`.
-      #   - A Hash - options passed to `has_many`, plus `name:` and `scope:`.
-      # - :version - The name to use for the method which returns the version
-      #   the instance was reified from. Default is `:version`.
-      #
-      # Plugins like the experimental `paper_trail-association_tracking` gem
-      # may accept additional options.
-      #
-      # You can define a default set of options via the configurable
-      # `PaperTrail.config.has_paper_trail_defaults` hash in your applications
-      # initializer. The hash can contain any of the following options and will
-      # provide an overridable default for all models.
-      #
-      # @api public
-      def has_paper_trail(options = {})
-        defaults = PaperTrail.config.has_paper_trail_defaults
-        paper_trail.setup(defaults.merge(options))
-      end
-
-      # @api public
-      def paper_trail
-        ::PaperTrail::ModelConfig.new(self)
-      end
-    end
-
-    # Wrap the following methods in a module so we can include them only in the
-    # ActiveRecord models that declare `has_paper_trail`.
-    module InstanceMethods
-      # @api public
-      def paper_trail
-        ::PaperTrail::RecordTrail.new(self)
-      end
-    end
-  end
-end

data/lib/mongo_trails/queries/versions/where_object.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module PaperTrail
-  module Queries
-    module Versions
-      # For public API documentation, see `where_object` in
-      # `mongo_trails/version_concern.rb`.
-      # @api private
-      class WhereObject
-        # - version_model_class - The class that VersionConcern was mixed into.
-        # - attributes - A `Hash` of attributes and values. See the public API
-        #   documentation for details.
-        # @api private
-        def initialize(version_model_class, attributes)
-          @version_model_class = version_model_class
-          @attributes = attributes
-        end
-
-        # @api private
-        def execute
-          column = @version_model_class.columns_hash["object"]
-          raise "where_object can't be called without an object column" unless column
-
-          case column.type
-          when :jsonb
-            jsonb
-          when :json
-            json
-          else
-            text
-          end
-        end
-
-        private
-
-        # @api private
-        def json
-          predicates = []
-          values = []
-          @attributes.each do |field, value|
-            predicates.push "object->>? = ?"
-            values.concat([field, value.to_s])
-          end
-          sql = predicates.join(" and ")
-          @version_model_class.where(sql, *values)
-        end
-
-        # @api private
-        def jsonb
-          @version_model_class.where("object @> ?", @attributes.to_json)
-        end
-
-        # @api private
-        def text
-          arel_field = @version_model_class.arel_table[:object]
-          where_conditions = @attributes.map { |field, value|
-            ::PaperTrail.serializer.where_object_condition(arel_field, field, value)
-          }
-          where_conditions = where_conditions.reduce { |a, e| a.and(e) }
-          @version_model_class.where(where_conditions)
-        end
-      end
-    end
-  end
-end

data/lib/mongo_trails/queries/versions/where_object_changes.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module PaperTrail
-  module Queries
-    module Versions
-      # For public API documentation, see `where_object_changes` in
-      # `mongo_trails/version_concern.rb`.
-      # @api private
-      class WhereObjectChanges
-        # - version_model_class - The class that VersionConcern was mixed into.
-        # - attributes - A `Hash` of attributes and values. See the public API
-        #   documentation for details.
-        # @api private
-        def initialize(version_model_class, attributes)
-          @version_model_class = version_model_class
-
-          # Currently, this `deep_dup` is necessary because the `jsonb` branch
-          # modifies `@attributes`, and that would be a nasty suprise for
-          # consumers of this class.
-          # TODO: Stop modifying `@attributes`, then remove `deep_dup`.
-          @attributes = attributes.deep_dup
-        end
-
-        # @api private
-        def execute
-          if PaperTrail.config.object_changes_adapter&.respond_to?(:where_object_changes)
-            return PaperTrail.config.object_changes_adapter.where_object_changes(
-              @version_model_class, @attributes
-            )
-          end
-          case @version_model_class.columns_hash["object_changes"].type
-          when :jsonb
-            jsonb
-          when :json
-            json
-          else
-            text
-          end
-        end
-
-        private
-
-        # @api private
-        def json
-          predicates = []
-          values = []
-          @attributes.each do |field, value|
-            predicates.push(
-              "((object_changes->>? ILIKE ?) OR (object_changes->>? ILIKE ?))"
-            )
-            values.concat([field, "[#{value.to_json},%", field, "[%,#{value.to_json}]%"])
-          end
-          sql = predicates.join(" and ")
-          @version_model_class.where(sql, *values)
-        end
-
-        # @api private
-        def jsonb
-          @attributes.each { |field, value| @attributes[field] = [value] }
-          @version_model_class.where("object_changes @> ?", @attributes.to_json)
-        end
-
-        # @api private
-        def text
-          arel_field = @version_model_class.arel_table[:object_changes]
-          where_conditions = @attributes.map { |field, value|
-            ::PaperTrail.serializer.where_object_changes_condition(arel_field, field, value)
-          }
-          where_conditions = where_conditions.reduce { |a, e| a.and(e) }
-          @version_model_class.where(where_conditions)
-        end
-      end
-    end
-  end
-end

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