mongo_trails 10.3.1 → 14.0.1

data/lib/mongo_trails/version_concern.rb

@@ -1,336 +1,47 @@
 # frozen_string_literal: true
 
-require "mongo_trails/attribute_serializers/object_changes_attribute"
-require "mongo_trails/queries/versions/where_object"
-require "mongo_trails/queries/versions/where_object_changes"
-
 module PaperTrail
-  # Originally, PaperTrail did not provide this module, and all of this
-  # functionality was in `PaperTrail::Version`. That model still exists (and is
-  # used by most apps) but by moving the functionality to this module, people
-  # can include this concern instead of sub-classing the `Version` model.
   module VersionConcern
     extend ::ActiveSupport::Concern
 
-    # :nodoc:
     module ClassMethods
-      def item_subtype_column_present?
-        column_names.include?("item_subtype")
-      end
-
       def with_item_keys(item_type, item_id)
-        where(item_type: item_type).and(item_id: item_id)
-      end
-
-      def creates
-        where event: "create"
-      end
-
-      def updates
-        where event: "update"
-      end
-
-      def destroys
-        where event: "destroy"
-      end
-
-      def not_creates
-        where "event <> ?", "create"
+        where(item_type: item_type, item_id: item_id)
       end
 
       def between(start_time, end_time)
-        where(:created_at.gt => start_time).and(:created_at.lt => end_time).order(timestamp_sort_order)
+        where(:created_at.gt => start_time, :created_at.lt => end_time).order(timestamp_sort_order)
       end
 
-      # Defaults to using the primary key as the secondary sort order if
-      # possible.
-      def timestamp_sort_order(direction = "asc")
+      def timestamp_sort_order(direction = 'asc')
         { created_at: direction.downcase }
       end
 
-      # Given a hash of attributes like `name: 'Joan'`, query the
-      # `versions.objects` column.
-      #
-      # ```
-      # SELECT "versions".*
-      # FROM "versions"
-      # WHERE ("versions"."object" LIKE '%
-      # name: Joan
-      # %')
-      # ```
-      #
-      # This is useful for finding versions where a given attribute had a given
-      # value. Imagine, in the example above, that Joan had changed her name
-      # and we wanted to find the versions before that change.
-      #
-      # Based on the data type of the `object` column, the appropriate SQL
-      # operator is used. For example, a text column will use `like`, and a
-      # jsonb column will use `@>`.
-      #
-      # @api public
-      def where_object(args = {})
-        raise ArgumentError, "expected to receive a Hash" unless args.is_a?(Hash)
-        Queries::Versions::WhereObject.new(self, args).execute
-      end
-
-      # Given a hash of attributes like `name: 'Joan'`, query the
-      # `versions.objects_changes` column.
-      #
-      # ```
-      # SELECT "versions".*
-      # FROM "versions"
-      # WHERE .. ("versions"."object_changes" LIKE '%
-      # name:
-      # - Joan
-      # %' OR "versions"."object_changes" LIKE '%
-      # name:
-      # -%
-      # - Joan
-      # %')
-      # ```
-      #
-      # This is useful for finding versions immediately before and after a given
-      # attribute had a given value. Imagine, in the example above, that someone
-      # changed their name to Joan and we wanted to find the versions
-      # immediately before and after that change.
-      #
-      # Based on the data type of the `object` column, the appropriate SQL
-      # operator is used. For example, a text column will use `like`, and a
-      # jsonb column will use `@>`.
-      #
-      # @api public
-      def where_object_changes(args = {})
-        raise ArgumentError, "expected to receive a Hash" unless args.is_a?(Hash)
-        Queries::Versions::WhereObjectChanges.new(self, args).execute
-      end
-
-      def primary_key_is_int?
-        @primary_key_is_int ||= columns_hash[primary_key].type == :integer
-      rescue StandardError # TODO: Rescue something more specific
-        true
-      end
-
-      # Returns whether the `object` column is using the `json` type supported
-      # by PostgreSQL.
       def object_col_is_json?
-        # %i[json jsonb].include?(columns_hash["object"].type)
         true
       end
 
-      # Returns whether the `object_changes` column is using the `json` type
-      # supported by PostgreSQL.
       def object_changes_col_is_json?
-        # %i[json jsonb].include?(columns_hash["object_changes"].try(:type))
         true
       end
 
-      # Returns versions before `obj`.
-      #
-      # @param obj - a `Version` or a timestamp
-      # @param timestamp_arg - boolean - When true, `obj` is a timestamp.
-      #   Default: false.
-      # @return `ActiveRecord::Relation`
-      # @api public
-      def preceding(obj, timestamp_arg = false)
-        if timestamp_arg != true && primary_key_is_int?
-          preceding_by_id(obj)
-        else
-          preceding_by_timestamp(obj)
-        end
-      end
-
-      # Returns versions after `obj`.
-      #
-      # @param obj - a `Version` or a timestamp
-      # @param timestamp_arg - boolean - When true, `obj` is a timestamp.
-      #   Default: false.
-      # @return `ActiveRecord::Relation`
-      # @api public
-      def subsequent(obj, timestamp_arg = false)
-        if timestamp_arg != true && primary_key_is_int?
-          subsequent_by_id(obj)
-        else
-          subsequent_by_timestamp(obj)
-        end
-      end
-
-      private
-
-      # @api private
       def preceding_by_id(obj)
         where(:integer_id.lt => obj.integer_id).order(integer_id: :desc)
       end
 
-      # @api private
       def preceding_by_timestamp(obj)
         obj = obj.send(:created_at) if obj.is_a?(self)
-        where(:created_at.lt => obj).order(timestamp_sort_order("desc"))
+        where(:created_at.lt => obj).order(timestamp_sort_order('desc'))
       end
 
-      # @api private
       def subsequent_by_id(version)
         where(:integer_id.gt => version.integer_id).order(integer_id: :asc)
       end
 
-      # @api private
       def subsequent_by_timestamp(obj)
         obj = obj.send(:created_at) if obj.is_a?(self)
         where(:created_at.gt => obj).order(timestamp_sort_order)
       end
     end
-
-    # @api private
-    def object_deserialized
-      if self.class.object_col_is_json?
-        object
-      else
-        PaperTrail.serializer.load(object)
-      end
-    end
-
-    # Restore the item from this version.
-    #
-    # Options:
-    #
-    # - :mark_for_destruction
-    #   - `true` - Mark the has_one/has_many associations that did not exist in
-    #     the reified version for destruction, instead of removing them.
-    #   - `false` - Default. Useful for persisting the reified version.
-    # - :dup
-    #   - `false` - Default.
-    #   - `true` - Always create a new object instance. Useful for
-    #     comparing two versions of the same object.
-    # - :unversioned_attributes
-    #   - `:nil` - Default. Attributes undefined in version record are set to
-    #     nil in reified record.
-    #   - `:preserve` - Attributes undefined in version record are not modified.
-    #
-    def reify(options = {})
-      unless self.class.fields.keys.include? "object"
-        raise "reify can't be called without an object column"
-      end
-      return nil if object.nil?
-      ::PaperTrail::Reifier.reify(self, options)
-    end
-
-    # 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.fields.keys.include? "object_changes"
-      @changeset ||= load_changeset
-    end
-
-    # Returns who put the item into the state stored in this version.
-    def paper_trail_originator
-      @paper_trail_originator ||= previous.try(:whodunnit)
-    end
-
-    # Returns who changed the item from the state it had in this version. This
-    # is an alias for `whodunnit`.
-    def terminator
-      @terminator ||= whodunnit
-    end
-    alias version_author terminator
-
-    def sibling_versions(reload = false)
-      if reload || !defined?(@sibling_versions) || @sibling_versions.nil?
-        @sibling_versions = self.class.with_item_keys(item_type, item_id)
-      end
-      @sibling_versions
-    end
-
-    def next
-      @next ||= sibling_versions.subsequent(self).first
-    end
-
-    def previous
-      @previous ||= sibling_versions.preceding(self).first
-    end
-
-    # Returns an integer representing the chronological position of the
-    # version among its siblings (see `sibling_versions`). The "create" event,
-    # for example, has an index of 0.
-    # @api public
-    def index
-      @index ||= RecordHistory.new(sibling_versions, self.class).index(self)
-    end
-
-    private
-
-    # @api private
-    def load_changeset
-      if PaperTrail.config.object_changes_adapter&.respond_to?(:load_changeset)
-        return PaperTrail.config.object_changes_adapter.load_changeset(self)
-      end
-
-      # First, deserialize the `object_changes` column.
-      changes = HashWithIndifferentAccess.new(object_changes_deserialized)
-
-      # The next step is, perhaps unfortunately, called "de-serialization",
-      # and appears to be responsible for custom attribute serializers. For an
-      # example of a custom attribute serializer, see
-      # `Person::TimeZoneSerializer` in the test suite.
-      #
-      # Is `item.class` good enough? Does it handle `inheritance_column`
-      # as well as `Reifier#version_reification_class`? We were using
-      # `item_type.constantize`, but that is problematic when the STI parent
-      # is not versioned. (See `Vehicle` and `Car` in the test suite).
-      #
-      # Note: `item` returns nil if `event` is "destroy".
-      unless item.nil?
-        AttributeSerializers::ObjectChangesAttribute.
-          new(item.class).
-          deserialize(changes)
-      end
-
-      # Finally, return a Hash mapping each attribute name to
-      # a two-element array representing before and after.
-      changes
-    end
-
-    # If the `object_changes` column is a Postgres JSON column, then
-    # ActiveRecord will deserialize it for us. Otherwise, it's a string column
-    # and we must deserialize it ourselves.
-    # @api private
-    def object_changes_deserialized
-      if self.class.object_changes_col_is_json?
-        object_changes
-      else
-        begin
-          PaperTrail.serializer.load(object_changes)
-        rescue StandardError # TODO: Rescue something more specific
-          {}
-        end
-      end
-    end
-
-    # Enforces the `version_limit`, if set. Default: no limit.
-    # @api private
-    def enforce_version_limit!
-      limit = version_limit
-      return unless limit.is_a? Numeric
-      previous_versions = sibling_versions.not_creates.
-        order(self.class.timestamp_sort_order("asc"))
-      return unless previous_versions.size > limit
-      excess_versions = previous_versions - previous_versions.last(limit)
-      excess_versions.map(&:destroy)
-    end
-
-    # See docs section 2.e. Limiting the Number of Versions Created.
-    # The version limit can be global or per-model.
-    #
-    # @api private
-    #
-    # TODO: Duplication: similar `constantize` in Reifier#version_reification_class
-    def version_limit
-      if self.class.item_subtype_column_present?
-        klass = (item_subtype || item_type).constantize
-        if klass&.paper_trail_options&.key?(:limit)
-          return klass.paper_trail_options[:limit]
-        end
-      end
-      PaperTrail.config.version_limit
-    end
   end
 end

data/lib/mongo_trails.rb

@@ -1,154 +1,18 @@
 # frozen_string_literal: true
 
-# AR does not require all of AS, but PT does. PT uses core_ext like
-# `String#squish`, so we require `active_support/all`. Instead of eagerly
-# loading all of AS here, we could put specific `require`s in only the various
-# PT files that need them, but this seems easier to troubleshoot, though it may
-# add a few milliseconds to rails boot time. If that becomes a pain point, we
-# can revisit this decision.
-require "active_support/all"
+require 'paper_trail'
+require 'paper_trail/version_concern'
+require 'paper_trail/model_config'
+require 'paper_trail/record_trail'
+
+require 'mongo_trails/version'
+require 'mongo_trails/config'
+require 'mongo_trails/callback_propagation'
+require 'mongo_trails/events/base'
+require 'mongo_trails/model_config'
+require 'mongo_trails/version_concern'
+require 'mongo_trails/record_trail'
 
-# AR is required for, eg. has_paper_trail.rb, so we could put this `require` in
-# all of those files, but it seems easier to troubleshoot if we just make sure
-# AR is loaded here before loading *any* of PT. See discussion of
-# performance/simplicity tradeoff for activesupport above.
-require "active_record"
-
-require "request_store"
-require "mongo_trails/cleaner"
-require "mongo_trails/compatibility"
-require "mongo_trails/config"
-require "mongo_trails/has_paper_trail"
-require "mongo_trails/record_history"
-require "mongo_trails/reifier"
-require "mongo_trails/request"
-require "mongo_trails/version_concern"
-require "mongo_trails/version_number"
-require "mongo_trails/serializers/json"
-require "mongo_trails/serializers/yaml"
-
-# An ActiveRecord extension that tracks changes to your models, for auditing or
-# versioning.
-module PaperTrail
-  E_RAILS_NOT_LOADED = <<-EOS.squish.freeze
-    PaperTrail has been loaded too early, before rails is loaded. This can
-    happen when another gem defines the ::Rails namespace, then PT is loaded,
-    all before rails is loaded. You may want to reorder your Gemfile, or defer
-    the loading of PT by using `require: false` and a manual require elsewhere.
-  EOS
-  E_TIMESTAMP_FIELD_CONFIG = <<-EOS.squish.freeze
-    PaperTrail.timestamp_field= has been removed, without replacement. It is no
-    longer configurable. The timestamp column in the versions table must now be
-    named created_at.
-  EOS
-
-  extend PaperTrail::Cleaner
-
-  class << self
-    # Switches PaperTrail on or off, for all threads.
-    # @api public
-    def enabled=(value)
-      PaperTrail.config.enabled = value
-    end
-
-    # Returns `true` if PaperTrail is on, `false` otherwise. This is the
-    # on/off switch that affects all threads. Enabled by default.
-    # @api public
-    def enabled?
-      !!PaperTrail.config.enabled
-    end
-
-    # Returns PaperTrail's `::Gem::Version`, convenient for comparisons. This is
-    # recommended over `::PaperTrail::VERSION::STRING`.
-    #
-    # Added in 7.0.0
-    #
-    # @api public
-    def gem_version
-      ::Gem::Version.new(VERSION::STRING)
-    end
-
-    # Set variables for the current request, eg. whodunnit.
-    #
-    # All request-level variables are now managed here, as of PT 9. Having the
-    # word "request" right there in your application code will remind you that
-    # these variables only affect the current request, not all threads.
-    #
-    # Given a block, temporarily sets the given `options`, executes the block,
-    # and returns the value of the block.
-    #
-    # Without a block, this currently just returns `PaperTrail::Request`.
-    # However, please do not use `PaperTrail::Request` directly. 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 public
-    def request(options = nil, &block)
-      if options.nil? && !block_given?
-        Request
-      else
-        Request.with(options, &block)
-      end
-    end
-
-    # Set the field which records when a version was created.
-    # @api public
-    def timestamp_field=(_field_name)
-      raise(E_TIMESTAMP_FIELD_CONFIG)
-    end
-
-    # Set the PaperTrail serializer. This setting affects all threads.
-    # @api public
-    def serializer=(value)
-      PaperTrail.config.serializer = value
-    end
-
-    # Get the PaperTrail serializer used by all threads.
-    # @api public
-    def serializer
-      PaperTrail.config.serializer
-    end
-
-    # Returns PaperTrail's global configuration object, a singleton. These
-    # settings affect all threads.
-    # @api private
-    def config
-      @config ||= PaperTrail::Config.instance
-      yield @config if block_given?
-      @config
-    end
-    alias configure config
-
-    def version
-      VERSION::STRING
-    end
-  end
-end
-
-# We use the `on_load` "hook" instead of `ActiveRecord::Base.include` because we
-# don't want to cause all of AR to be autloaded yet. See
-# https://guides.rubyonrails.org/engines.html#what-are-on-load-hooks-questionmark
-# to learn more about `on_load`.
 ActiveSupport.on_load(:active_record) do
-  include PaperTrail::Model
-  require "mongo_trails/mongo_support/version"
-end
-
-# require "mongo_trails/mongo_support/config"
-
-# Require frameworks
-if defined?(::Rails)
-  # Rails module is sometimes defined by gems like rails-html-sanitizer
-  # so we check for presence of Rails.application.
-
-  if defined?(::Rails.application)
-    require "mongo_trails/frameworks/rails"
-  else
-    ::Kernel.warn(::PaperTrail::E_RAILS_NOT_LOADED)
-  end
-end
-
-if defined?(::ActiveRecord)
-  ::PaperTrail::Compatibility.check_activerecord(::ActiveRecord.gem_version)
+  require 'mongo_trails/mongo_support/version'
 end

data/mongo_trails.gemspec

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
-$LOAD_PATH.unshift File.expand_path("lib", __dir__)
-
-require "mongo_trails/compatibility"
-require "mongo_trails/version_number"
+$LOAD_PATH.unshift File.expand_path('lib', __dir__)
+require 'mongo_trails/version'
 
 Gem::Specification.new do |s|
-  s.name = "mongo_trails"
-  s.version = PaperTrail::VERSION::STRING
+  s.name = 'mongo_trails'
+  s.version = MongoTrails::VERSION
   s.platform = Gem::Platform::RUBY
-  s.summary = "PaperTrail DropIn replacement to store versions in MongoDB"
-  s.description = <<-EOS
-PaperTrail DropIn replacement to store version in MongoDB
-  EOS
-  s.homepage = "https://github.com/noma4i/mongo_trails"
+  s.summary = 'PaperTrail addon to store versions in MongoDB'
+  s.description = <<~DSC
+    PaperTrail addon to store versions in MongoDB
+  DSC
+  s.homepage = 'https://github.com/noma4i/mongo_trails'
   s.metadata['homepage_uri'] = s.homepage
   s.metadata['source_code_uri'] = s.homepage
-  s.authors = ["Alex Tsirel","Ivan Romanyuk"]
-  s.email = ["noma4i@gmail.com"]
-  s.license = "MIT"
+  s.metadata['allowed_push_host'] = 'https://rubygems.org'
+  s.metadata['rubygems_mfa_required'] = 'true'
+  s.authors = ['Alex Tsirel', 'Ivan Romanyuk']
+  s.email = ['noma4i@gmail.com']
+  s.license = 'MIT'
 
   s.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
@@ -28,11 +28,10 @@ PaperTrail DropIn replacement to store version in MongoDB
   s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
   s.require_paths = ['lib']
 
-  s.add_dependency "activerecord", ::PaperTrail::Compatibility::ACTIVERECORD_GTE
-  s.add_dependency "request_store", "~> 1.1"
-  s.add_dependency "mongoid", "< 8"
-  s.add_dependency "mongoid-autoinc", "< 7"
+  s.add_dependency 'mongoid', '>= 7', '< 10'
+  s.add_dependency 'ostruct'
+  s.add_dependency 'paper_trail', '~> 16'
+  s.add_dependency 'sidekiq', '>= 6.5', '< 9'
 
-  s.add_development_dependency 'sqlite3', '~> 1.4'
-  s.add_development_dependency 'appraisal', '~> 2.3'
+  s.required_ruby_version = '>= 3.2'
 end