piko-smart-pkg 0.0.1

data/paper_trail-17.0.0/lib/paper_trail/record_trail.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+require "paper_trail/events/create"
+require "paper_trail/events/destroy"
+require "paper_trail/events/update"
+
+module PaperTrail
+  # Represents the "paper trail" for a single record.
+  class RecordTrail
+    def initialize(record)
+      @record = record
+    end
+
+    # Invoked after rollbacks to ensure versions records are not created for
+    # changes that never actually took place. Optimization: Use lazy `reset`
+    # instead of eager `reload` because, in many use cases, the association will
+    # not be used.
+    def clear_rolled_back_versions
+      versions.reset
+    end
+
+    # Invoked via`after_update` callback for when a previous version is
+    # reified and then saved.
+    def clear_version_instance
+      @record.send(:"#{@record.class.version_association_name}=", nil)
+    end
+
+    # Returns true if this instance is the current, live one;
+    # returns false if this instance came from a previous version.
+    def live?
+      source_version.nil?
+    end
+
+    # Returns the object (not a Version) as it became next.
+    # NOTE: if self (the item) was not reified from a version, i.e. it is the
+    #  "live" item, we return nil.  Perhaps we should return self instead?
+    def next_version
+      subsequent_version = source_version.next
+      subsequent_version ? subsequent_version.reify : @record.class.find(@record.id)
+    rescue StandardError # TODO: Rescue something more specific
+      nil
+    end
+
+    # Returns who put `@record` into its current state.
+    #
+    # @api public
+    def originator
+      (source_version || versions.last).try(:whodunnit)
+    end
+
+    # Returns the object (not a Version) as it was most recently.
+    #
+    # @api public
+    def previous_version
+      (source_version ? source_version.previous : versions.last).try(:reify)
+    end
+
+    def record_create
+      return unless enabled?
+
+      build_version_on_create(in_after_callback: true).tap do |version|
+        version.save!
+        # Because the version object was created using version_class.new instead
+        # of versions_assoc.build?, the association cache is unaware. So, we
+        # invalidate the `versions` association cache with `reset`.
+        versions.reset
+      rescue StandardError => e
+        handle_version_errors e, version, :create
+      end
+    end
+
+    # `recording_order` is "after" or "before". See ModelConfig#on_destroy.
+    #
+    # @api private
+    # @return - The created version object, so that plugins can use it, e.g.
+    # paper_trail-association_tracking
+    def record_destroy(recording_order)
+      return unless enabled? && !@record.new_record?
+      in_after_callback = recording_order == "after"
+      event = Events::Destroy.new(@record, in_after_callback)
+
+      # Merge data from `Event` with data from PT-AT. We no longer use
+      # `data_for_destroy` but PT-AT still does.
+      data = event.data.merge(data_for_destroy)
+
+      version = @record.class.paper_trail.version_class.new(data)
+      begin
+        version.save!
+        assign_and_reset_version_association(version)
+        version
+      rescue StandardError => e
+        handle_version_errors e, version, :destroy
+      end
+    end
+
+    # @api private
+    # @param force [boolean] Insert a `Version` even if `@record` has not
+    #   `changed_notably?`.
+    # @param in_after_callback [boolean] True when called from an `after_update`
+    #   or `after_touch` callback.
+    # @param is_touch [boolean] True when called from an `after_touch` callback.
+    # @return - The created version object, so that plugins can use it, e.g.
+    # paper_trail-association_tracking
+    def record_update(force:, in_after_callback:, is_touch:)
+      return unless enabled?
+
+      version = build_version_on_update(
+        force: force,
+        in_after_callback: in_after_callback,
+        is_touch: is_touch
+      )
+      return unless version
+
+      begin
+        version.save!
+        # Because the version object was created using version_class.new instead
+        # of versions_assoc.build?, the association cache is unaware. So, we
+        # invalidate the `versions` association cache with `reset`.
+        versions.reset
+        version
+      rescue StandardError => e
+        handle_version_errors e, version, :update
+      end
+    end
+
+    # Invoked via callback when a user attempts to persist a reified
+    # `Version`.
+    def reset_timestamp_attrs_for_update_if_needed
+      return if live?
+      @record.send(:timestamp_attributes_for_update_in_model).each do |column|
+        @record.send(:"restore_#{column}!")
+      end
+    end
+
+    # AR callback.
+    # @api private
+    def save_version?
+      if_condition = @record.paper_trail_options[:if]
+      unless_condition = @record.paper_trail_options[:unless]
+      (if_condition.blank? || if_condition.call(@record)) && !unless_condition.try(:call, @record)
+    end
+
+    def source_version
+      version
+    end
+
+    # Save, and create a version record regardless of options such as `:on`,
+    # `:if`, or `:unless`.
+    #
+    # `in_after_callback`: Indicates if this method is being called within an
+    #                      `after` callback. Defaults to `false`.
+    # `options`: Optional arguments passed to `save`.
+    #
+    # This is an "update" event. That is, we record the same data we would in
+    # the case of a normal AR `update`.
+    def save_with_version(in_after_callback: false, **options)
+      ::PaperTrail.request(enabled: false) do
+        @record.save(**options)
+      end
+      record_update(force: true, in_after_callback: in_after_callback, is_touch: false)
+    end
+
+    # Like the `update_column` method from `ActiveRecord::Persistence`, but also
+    # creates a version to record those changes.
+    # @api public
+    def update_column(name, value)
+      update_columns(name => value)
+    end
+
+    # Like the `update_columns` method from `ActiveRecord::Persistence`, but also
+    # creates a version to record those changes.
+    # @api public
+    def update_columns(attributes)
+      # `@record.update_columns` skips dirty-tracking, so we can't just use
+      # `@record.changes` or @record.saved_changes` from `ActiveModel::Dirty`.
+      # We need to build our own hash with the changes that will be made
+      # directly to the database.
+      changes = {}
+      attributes.each do |k, v|
+        changes[k] = [@record[k], v]
+      end
+      @record.update_columns(attributes)
+      record_update_columns(changes)
+    end
+
+    # Returns the object (not a Version) as it was at the given timestamp.
+    def version_at(timestamp, reify_options = {})
+      # Because a version stores how its object looked *before* the change,
+      # we need to look for the first version created *after* the timestamp.
+      v = versions.subsequent(timestamp, true).first
+      return v.reify(reify_options) if v
+      @record unless @record.destroyed?
+    end
+
+    # Returns the objects (not Versions) as they were between the given times.
+    def versions_between(start_time, end_time)
+      versions = send(@record.class.versions_association_name).between(start_time, end_time)
+      versions.collect { |version| version_at(version.created_at) }
+    end
+
+    private
+
+    # @api private
+    def assign_and_reset_version_association(version)
+      @record.send(:"#{@record.class.version_association_name}=", version)
+      @record.send(@record.class.versions_association_name).reset
+    end
+
+    # @api private
+    def build_version_on_create(in_after_callback:)
+      event = Events::Create.new(@record, in_after_callback)
+
+      # Merge data from `Event` with data from PT-AT. We no longer use
+      # `data_for_create` but PT-AT still does.
+      data = event.data.merge!(data_for_create)
+
+      # Pure `version_class.new` reduces memory usage compared to `versions_assoc.build`
+      @record.class.paper_trail.version_class.new(data)
+    end
+
+    # @api private
+    def build_version_on_update(force:, in_after_callback:, is_touch:)
+      event = Events::Update.new(@record, in_after_callback, is_touch, nil)
+      return unless force || event.changed_notably?
+      data = event.data
+
+      # Copy the (recently set) `updated_at` from the record to the `created_at`
+      # of the `Version`. Without this feature, these two timestamps would
+      # differ by a few milliseconds. To some people, it seems a little
+      # unnatural to tamper with creation timestamps in this way. But, this
+      # feature has existed for a long time, almost a decade now, and some users
+      # may rely on it now.
+      if @record.respond_to?(:updated_at) &&
+          @record.paper_trail_options[:synchronize_version_creation_timestamp] != false
+        data[:created_at] = @record.updated_at
+      end
+
+      # Merge data from `Event` with data from PT-AT. We no longer use
+      # `data_for_update` but PT-AT still does. To save memory, we use `merge!`
+      # instead of `merge`.
+      data.merge!(data_for_update)
+
+      # Using `version_class.new` reduces memory usage compared to
+      # `versions_assoc.build`. It's a trade-off though. We have to clear
+      # the association cache (see `versions.reset`) and that could cause an
+      # additional query in certain applications.
+      @record.class.paper_trail.version_class.new(data)
+    end
+
+    # PT-AT extends this method to add its transaction id.
+    #
+    # @api public
+    def data_for_create
+      {}
+    end
+
+    # PT-AT extends this method to add its transaction id.
+    #
+    # @api public
+    def data_for_destroy
+      {}
+    end
+
+    # PT-AT extends this method to add its transaction id.
+    #
+    # @api public
+    def data_for_update
+      {}
+    end
+
+    # PT-AT extends this method to add its transaction id.
+    #
+    # @api public
+    def data_for_update_columns
+      {}
+    end
+
+    # Is PT enabled for this particular record?
+    # @api private
+    def enabled?
+      PaperTrail.enabled? &&
+        PaperTrail.request.enabled? &&
+        PaperTrail.request.enabled_for_model?(@record.class)
+    end
+
+    def log_version_errors(version, action)
+      version.logger&.warn(
+        "Unable to create version for #{action} of #{@record.class.name}" \
+        "##{@record.id}: " + version.errors.full_messages.join(", ")
+      )
+    end
+
+    # Centralized handler for version errors
+    # @api private
+    def handle_version_errors(e, version, action)
+      case PaperTrail.config.version_error_behavior
+      when :legacy
+        # legacy behavior was to raise on create and log on update/delete
+        if action == :create
+          raise e
+        else
+          log_version_errors(version, action)
+        end
+      when :log
+        log_version_errors(version, action)
+      when :exception
+        raise e
+      when :silent
+        # noop
+      end
+    end
+
+    # @api private
+    # @return - The created version object, so that plugins can use it, e.g.
+    # paper_trail-association_tracking
+    def record_update_columns(changes)
+      return unless enabled?
+      data = Events::Update.new(@record, false, false, changes).data
+
+      # Merge data from `Event` with data from PT-AT. We no longer use
+      # `data_for_update_columns` but PT-AT still does.
+      data.merge!(data_for_update_columns)
+
+      versions_assoc = @record.send(@record.class.versions_association_name)
+      version = versions_assoc.new(data)
+      begin
+        version.save!
+        version
+      rescue StandardError => e
+        handle_version_errors e, version, :update
+      end
+    end
+
+    def version
+      @record.public_send(@record.class.version_association_name)
+    end
+
+    def versions
+      @record.public_send(@record.class.versions_association_name)
+    end
+  end
+end

data/paper_trail-17.0.0/lib/paper_trail/reifier.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "paper_trail/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
+                  version.item || init_model_by_finding_item_id(klass, version) || klass.new
+                end
+
+        if options[:unversioned_attributes] == :nil && !model.new_record?
+          init_unversioned_attrs(attrs, model)
+        end
+
+        model
+      end
+
+      # @api private
+      def init_model_by_finding_item_id(klass, version)
+        klass.unscoped.where(klass.primary_key => version.item_id).first
+      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 and
+      # custom inheritance column values.
+      #
+      # 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`.
+      #
+      # The values contained in the inheritance columns may be non-camelized
+      # strings (e.g. 'dog' instead of 'Dog'). To reify classes in this case
+      # we need to call the parents class `sti_class_for` method to retrieve
+      # the correct record class.
+      #
+      # You can see these particular examples in action in
+      # `spec/models/animal_spec.rb` and `spec/models/plant_spec.rb`
+      def version_reification_class(version, attrs)
+        clazz = version.item_type.constantize
+        inheritance_column_name = clazz.inheritance_column
+        inher_col_value = attrs[inheritance_column_name]
+        return clazz if inher_col_value.blank?
+
+        # Rails 6.1 adds a public method for clients to use to customize STI classes. If that
+        # method is not available, fall back to using the private one
+        if clazz.public_methods.include?(:sti_class_for)
+          return clazz.sti_class_for(inher_col_value)
+        end
+
+        clazz.send(:find_sti_class, inher_col_value)
+      end
+    end
+  end
+end

data/paper_trail-17.0.0/lib/paper_trail/request.rb

@@ -0,0 +1,163 @@
+# 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 << 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
+
+      # 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
+
+      # @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 Hash, initializing with default values if necessary.
+      # @api private
+      def store
+        RequestStore.store[:paper_trail] ||= {
+          enabled: true
+        }
+      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
+
+      # 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/paper_trail-17.0.0/lib/paper_trail/serializers/json.rb

@@ -0,0 +1,36 @@
+# 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
+    end
+  end
+end