mongoid-ultra 9.0.0.0.alpha1

data/lib/mongoid/touchable.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Touchable
+    module InstanceMethods
+
+      # Suppresses the invocation of touch callbacks, for the class that
+      # includes this module, for the duration of the block.
+      #
+      # @example Suppress touch callbacks on Person documents:
+      #   person.suppress_touch_callbacks { ... }
+      #
+      # @api private
+      def suppress_touch_callbacks
+        Touchable.suppress_touch_callbacks(self.class.name) { yield }
+      end
+
+      # Queries whether touch callbacks are being suppressed for the class
+      # that includes this module.
+      #
+      # @return [ true | false ] Whether touch callbacks are suppressed.
+      #
+      # @api private
+      def touch_callbacks_suppressed?
+        Touchable.touch_callbacks_suppressed?(self.class.name)
+      end
+
+      # Touch the document, in effect updating its updated_at timestamp and
+      # optionally the provided field to the current time. If any belongs_to
+      # associations exist with a touch option, they will be updated as well.
+      #
+      # @example Update the updated_at timestamp.
+      #   document.touch
+      #
+      # @example Update the updated_at and provided timestamps.
+      #   document.touch(:audited)
+      #
+      # @note This will not autobuild associations if those options are set.
+      #
+      # @param [ Symbol ] field The name of an additional field to update.
+      #
+      # @return [ true/false ] false if document is new_record otherwise true.
+      def touch(field = nil)
+        return false if _root.new_record?
+
+        begin
+          touches = _gather_touch_updates(Time.configured.now, field)
+          _root.send(:persist_atomic_operations, '$set' => touches) if touches.present?
+          _run_touch_callbacks_from_root
+        ensure
+          _clear_touch_updates(field)
+        end
+
+        true
+      end
+
+      # Recursively sets touchable fields on the current document and each of its
+      # parents, including the root node. Returns the combined atomic $set
+      # operations to be performed on the root document.
+      #
+      # @param [ Time ] now The timestamp used for synchronizing the touched time.
+      # @param [ Symbol ] field The name of an additional field to update.
+      #
+      # @return [ Hash<String, Time> ] The touch operations to perform as an atomic $set.
+      #
+      # @api private
+      def _gather_touch_updates(now, field = nil)
+        return if touch_callbacks_suppressed?
+
+        field = database_field_name(field)
+
+        write_attribute(:updated_at, now) if respond_to?("updated_at=")
+        write_attribute(field, now) if field
+
+        touches = _extract_touches_from_atomic_sets(field) || {}
+        touches.merge!(_parent._gather_touch_updates(now) || {}) if _touchable_parent?
+        touches
+      end
+
+      # Clears changes for the model caused by touch operation.
+      #
+      # @param [ Symbol ] field The name of an additional field to update.
+      #
+      # @api private
+      def _clear_touch_updates(field = nil)
+        remove_change(:updated_at)
+        remove_change(field) if field
+        _parent._clear_touch_updates if _touchable_parent?
+      end
+
+      # Recursively runs :touch callbacks for the document and its parents,
+      # beginning with the root document and cascading through each successive
+      # child document.
+      #
+      # @api private
+      def _run_touch_callbacks_from_root
+        return if touch_callbacks_suppressed?
+        _parent._run_touch_callbacks_from_root if _touchable_parent?
+        run_callbacks(:touch)
+      end
+
+      # Indicates whether the parent exists and is touchable.
+      #
+      # @api private
+      def _touchable_parent?
+        _parent && _association&.inverse_association&.touchable?
+      end
+
+      private
+
+      # Extract and remove the atomic updates for the touch operation(s)
+      # from the currently enqueued atomic $set operations.
+      #
+      # @param [ Symbol ] field The optional field.
+      #
+      # @return [ Hash ] The field-value pairs to update atomically.
+      #
+      # @api private
+      def _extract_touches_from_atomic_sets(field = nil)
+        updates = atomic_updates['$set']
+        return {} unless updates
+
+        touchable_keys = Set['updated_at', 'u_at']
+        touchable_keys << field.to_s if field.present?
+
+        updates.keys.each_with_object({}) do |key, touches|
+          if touchable_keys.include?(key.split('.').last)
+            touches[key] = updates.delete(key)
+          end
+        end
+      end
+    end
+
+    extend self
+
+    # Add the association to the touchable associations if the touch option was
+    # provided.
+    #
+    # @example Add the touchable.
+    #   Model.define_touchable!(assoc)
+    #
+    # @param [ Mongoid::Association::Relatable ] association The association metadata.
+    #
+    # @return [ Class ] The model class.
+    def define_touchable!(association)
+      name = association.name
+      method_name = define_relation_touch_method(name, association)
+      association.inverse_class.tap do |klass|
+        klass.after_save method_name
+        klass.after_destroy method_name
+
+        # Embedded docs handle touch updates recursively within
+        # the #touch method itself
+        klass.after_touch method_name unless association.embedded?
+      end
+    end
+
+    # Suppresses touch callbacks for the named class, for the duration of
+    # the associated block.
+    #
+    # @api private
+    def suppress_touch_callbacks(name)
+      save, touch_callback_statuses[name] = touch_callback_statuses[name], true
+      yield
+    ensure
+      touch_callback_statuses[name] = save
+    end
+
+    # Queries whether touch callbacks are being suppressed for the named
+    # class.
+    #
+    # @return [ true | false ] Whether touch callbacks are suppressed.
+    #
+    # @api private
+    def touch_callbacks_suppressed?(name)
+      touch_callback_statuses[name]
+    end
+
+    private
+
+    # The key to use to store the active touch callback suppression statuses
+    SUPPRESS_TOUCH_CALLBACKS_KEY = "[mongoid]:suppress-touch-callbacks"
+
+    # Returns a hash to be used to store and query the various touch callback
+    # suppression statuses for different classes.
+    #
+    # @return [ Hash ] The hash that contains touch callback suppression
+    #   statuses
+    def touch_callback_statuses
+      Thread.current[SUPPRESS_TOUCH_CALLBACKS_KEY] ||= {}
+    end
+
+    # Define the method that will get called for touching belongs_to
+    # associations.
+    #
+    # @api private
+    #
+    # @example Define the touch association.
+    #   Model.define_relation_touch_method(:band)
+    #   Model.define_relation_touch_method(:band, :band_updated_at)
+    #
+    # @param [ Symbol ] name The name of the association.
+    # @param [ Mongoid::Association::Relatable ] association The association metadata.
+    #
+    # @return [ Symbol ] The method name.
+    def define_relation_touch_method(name, association)
+      relation_classes = if association.polymorphic?
+                           association.send(:inverse_association_classes)
+                         else
+                           [ association.relation_class ]
+                         end
+
+      method_name = "touch_#{name}_after_create_or_destroy"
+      association.inverse_class.class_eval do
+        define_method(method_name) do
+          without_autobuild do
+            if !touch_callbacks_suppressed? && relation = __send__(name)
+              # This looks up touch_field at runtime, rather than at method definition time.
+              # If touch_field is nil, it will only touch the default field (updated_at).
+              relation.touch(association.touch_field)
+            end
+          end
+        end
+      end
+      method_name.to_sym
+    end
+  end
+end

data/lib/mongoid/traversable.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+require "mongoid/fields/validators/macro"
+
+module Mongoid
+
+  # Provides behavior around traversing the document graph.
+  module Traversable
+    extend ActiveSupport::Concern
+
+    def _parent
+      @__parent ||= nil
+    end
+
+    def _parent=(p)
+      @__parent = p
+    end
+
+    # Module used for prepending to the various discriminator_*= methods
+    #
+    # @api private
+    module DiscriminatorAssignment
+      def discriminator_key=(value)
+        if hereditary?
+          raise Errors::InvalidDiscriminatorKeyTarget.new(self, self.superclass)
+        end
+
+        _mongoid_clear_types
+
+        if value
+          Mongoid::Fields::Validators::Macro.validate_field_name(self, value)
+          value = value.to_s
+          super
+        else
+          # When discriminator key is set to nil, replace the class's definition
+          # of the discriminator key reader (provided by class_attribute earlier)
+          # and re-delegate to Mongoid.
+          class << self
+            delegate :discriminator_key, to: ::Mongoid
+          end
+        end
+
+        # This condition checks if the new discriminator key would overwrite
+        # an existing field.
+        # This condition also checks if the class has any descendants, because
+        # if it doesn't then it doesn't need a discriminator key.
+        if !fields.has_key?(self.discriminator_key) && !descendants.empty?
+          default_proc = lambda { self.class.discriminator_value }
+          field(self.discriminator_key, default: default_proc, type: String)
+        end
+      end
+
+      def discriminator_value=(value)
+        value ||= self.name
+        _mongoid_clear_types
+        add_discriminator_mapping(value)
+        @discriminator_value = value
+      end
+    end
+
+    # Module used for prepending the discriminator_value method.
+    #
+    # A separate module was needed because the subclasses of this class
+    # need to be manually prepended with the discriminator_value and can't
+    # rely on being a class_attribute because the .discriminator_value
+    # method is overridden by every subclass in the inherited method.
+    #
+    # @api private
+    module DiscriminatorRetrieval
+
+      # Get the name on the reading side if the discriminator_value is nil
+      def discriminator_value
+        @discriminator_value || self.name
+      end
+    end
+
+    included do
+      class_attribute :discriminator_key, instance_accessor: false
+
+      class << self
+        delegate :discriminator_key, to: ::Mongoid
+        prepend DiscriminatorAssignment
+        include DiscriminatorRetrieval
+
+        # @api private
+        #
+        # @return [ Hash<String, Class> ] The current mapping of discriminator_values to classes
+        attr_accessor :discriminator_mapping
+      end
+
+      # Add a discriminator mapping to the parent class. This mapping is used when
+      # receiving a document to identify its class.
+      #
+      # @param [ String ] value The discriminator_value that was just set
+      # @param [ Class ] The class the discriminator_value was set on
+      #
+      # @api private
+      def self.add_discriminator_mapping(value, klass=self)
+        self.discriminator_mapping ||= {}
+        self.discriminator_mapping[value] = klass
+        superclass.add_discriminator_mapping(value, klass) if hereditary?
+      end
+
+      # Get the discriminator mapping from the parent class. This method returns nil if there
+      # is no mapping for the given value.
+      #
+      # @param [ String ] value The discriminator_value to retrieve
+      #
+      # @return [ Class | nil ] klass The class corresponding to the given discriminator_value. If
+      #                               the value is not in the mapping, this method returns nil.
+      #
+      # @api private
+      def self.get_discriminator_mapping(value)
+        self.discriminator_mapping[value] if self.discriminator_mapping
+      end
+    end
+
+    # Get all child +Documents+ to this +Document+
+    #
+    # @return [ Array<Document> ] All child documents in the hierarchy.
+    #
+    # @api private
+    def _children
+      @__children ||= collect_children
+    end
+
+    # Get all descendant +Documents+ of this +Document+ recursively.
+    # This is used when calling update persistence operations from
+    # the root document, where changes in the entire tree need to be
+    # determined. Note that persistence from the embedded documents will
+    # always be preferred, since they are optimized calls... This operation
+    # can get expensive in domains with large hierarchies.
+    #
+    # @return [ Array<Document> ] All descendant documents in the hierarchy.
+    #
+    # @api private
+    def _descendants
+      @__descendants ||= collect_descendants
+    end
+
+    # Collect all the children of this document.
+    #
+    # @return [ Array<Document> ] The children.
+    #
+    # @api private
+    def collect_children
+      children = []
+      embedded_relations.each_pair do |name, association|
+        without_autobuild do
+          child = send(name)
+          if child
+            children += Array.wrap(child)
+          end
+        end
+      end
+      children
+    end
+
+    # Collect all the descendants of this document.
+    #
+    # @return [ Array<Document> ] The descendants.
+    #
+    # @api private
+    def collect_descendants
+      children = []
+      to_expand = []
+      expanded = {}
+      embedded_relations.each_pair do |name, association|
+        without_autobuild do
+          child = send(name)
+          if child
+            to_expand += Array.wrap(child)
+          end
+        end
+      end
+      until to_expand.empty?
+        expanding = to_expand
+        to_expand = []
+        expanding.each do |child|
+          next if expanded[child]
+          # Don't mark expanded if _id is nil, since documents are compared by
+          # their _ids, multiple embedded documents with nil ids will compare
+          # equally, and some documents will not be expanded.
+          expanded[child] = true if child._id
+          children << child
+          to_expand += child._children
+        end
+      end
+      children
+    end
+
+    # Marks all descendants as being persisted.
+    #
+    # @return [ Array<Document> ] The flagged descendants.
+    def flag_descendants_persisted
+      _descendants.each do |child|
+        child.new_record = false
+      end
+    end
+
+    # Determines if the document is a subclass of another document.
+    #
+    # @example Check if the document is a subclass
+    #   Square.new.hereditary?
+    #
+    # @return [ true | false ] True if hereditary, false if not.
+    def hereditary?
+      self.class.hereditary?
+    end
+
+    # Sets up a child/parent association. This is used for newly created
+    # objects so they can be properly added to the graph.
+    #
+    # @example Set the parent document.
+    #   document.parentize(parent)
+    #
+    # @param [ Document ] document The parent document.
+    #
+    # @return [ Document ] The parent document.
+    def parentize(document)
+      self._parent = document
+    end
+
+    # Remove a child document from this parent. If an embeds one then set to
+    # nil, otherwise remove from the embeds many.
+    #
+    # This is called from the +RemoveEmbedded+ persistence command.
+    #
+    # @example Remove the child.
+    #   document.remove_child(child)
+    #
+    # @param [ Document ] child The child (embedded) document to remove.
+    def remove_child(child)
+      name = child.association_name
+      if child.embedded_one?
+        self.attributes.delete(child._association.store_as)
+        remove_ivar(name)
+      else
+        relation = send(name)
+        relation.send(:delete_one, child)
+      end
+    end
+
+    # After descendants are persisted we can call this to move all their
+    # changes and flag them as persisted in one call.
+    #
+    # @return [ Array<Document> ] The descendants.
+    def reset_persisted_descendants
+      _descendants.each do |child|
+        child.move_changes
+        child.new_record = false
+      end
+      _reset_memoized_descendants!
+    end
+
+    # Resets the memoized descendants on the object. Called internally when an
+    # embedded array changes size.
+    #
+    # @return [ nil ] nil.
+    #
+    # @api private
+    def _reset_memoized_descendants!
+      _parent._reset_memoized_descendants! if _parent
+      @__children = nil
+      @__descendants = nil
+    end
+
+    # Return the root document in the object graph. If the current document
+    # is the root object in the graph it will return self.
+    #
+    # @example Get the root document in the hierarchy.
+    #   document._root
+    #
+    # @return [ Document ] The root document in the hierarchy.
+    def _root
+      object = self
+      while (object._parent) do object = object._parent; end
+      object
+    end
+
+    # Is this document the root document of the hierarchy?
+    #
+    # @example Is the document the root?
+    #   document._root?
+    #
+    # @return [ true | false ] If the document is the root.
+    def _root?
+      _parent ? false : true
+    end
+
+    module ClassMethods
+
+      # Determines if the document is a subclass of another document.
+      #
+      # @example Check if the document is a subclass.
+      #   Square.hereditary?
+      #
+      # @return [ true | false ] True if hereditary, false if not.
+      def hereditary?
+        !!(Mongoid::Document > superclass)
+      end
+
+      # When inheriting, we want to copy the fields from the parent class and
+      # set the on the child to start, mimicking the behavior of the old
+      # class_inheritable_accessor that was deprecated in Rails edge.
+      #
+      # @example Inherit from this class.
+      #   Person.inherited(Doctor)
+      #
+      # @param [ Class ] subclass The inheriting class.
+      def inherited(subclass)
+        super
+        @_type = nil
+        subclass.aliased_fields = aliased_fields.dup
+        subclass.localized_fields = localized_fields.dup
+        subclass.fields = fields.dup
+        subclass.pre_processed_defaults = pre_processed_defaults.dup
+        subclass.post_processed_defaults = post_processed_defaults.dup
+        subclass._declared_scopes = Hash.new { |hash,key| self._declared_scopes[key] }
+        subclass.discriminator_value = subclass.name
+
+        # We need to do this here because the discriminator_value method is
+        # overridden in the subclass above.
+        class << subclass
+          include DiscriminatorRetrieval
+        end
+
+        # We only need the _type field if inheritance is in play, but need to
+        # add to the root class as well for backwards compatibility.
+        unless fields.has_key?(self.discriminator_key)
+          default_proc = lambda { self.class.discriminator_value }
+          field(self.discriminator_key, default: default_proc, type: String)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/utils.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # @api private
+  module Utils
+
+    # This function should be used if you need to measure time.
+    # @example Calculate elapsed time.
+    #   starting = Utils.monotonic_time
+    #   # do something time consuming
+    #   ending = Utils.monotonic_time
+    #   puts "It took #{(ending - starting).to_i} seconds"
+    #
+    # @see https://blog.dnsimple.com/2018/03/elapsed-time-with-ruby-the-right-way/
+    #
+    # @return [Float] seconds according to monotonic clock
+    module_function def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/mongoid/validatable/associated.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Validatable
+
+    # Validates whether or not an association is valid or not. Will correctly
+    # handle has one and has many associations.
+    #
+    # @example Set up the association validations.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     embeds_one :name
+    #     embeds_many :addresses
+    #
+    #     validates_associated :name, :addresses
+    #   end
+    class AssociatedValidator < ActiveModel::EachValidator
+
+      # Validates that the associations provided are either all nil or all
+      # valid. If neither is true then the appropriate errors will be added to
+      # the parent document.
+      #
+      # @example Validate the association.
+      #   validator.validate_each(document, :name, name)
+      #
+      # @param [ Document ] document The document to validate.
+      # @param [ Symbol ] attribute The association to validate.
+      # @param [ Object ] value The value of the association.
+      def validate_each(document, attribute, value)
+        begin
+          document.begin_validate
+          valid = Array.wrap(value).collect do |doc|
+            if doc.nil? || doc.flagged_for_destroy?
+              true
+            else
+              doc.validated? ? true : doc.valid?
+            end
+          end.all?
+        ensure
+          document.exit_validate
+        end
+        document.errors.add(attribute, :invalid, **options) unless valid
+      end
+    end
+  end
+end

data/lib/mongoid/validatable/format.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Validatable
+
+    # Validates that the specified attributes do or do not match a certain
+    # regular expression.
+    #
+    # @example Set up the format validator.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     field :website
+    #
+    #     validates_format_of :website, :with => URI.regexp
+    #   end
+    class FormatValidator < ActiveModel::Validations::FormatValidator
+      include Localizable
+    end
+  end
+end

data/lib/mongoid/validatable/length.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Validatable
+
+    # Validates that the specified attributes do or do not match a certain
+    # length.
+    #
+    # @example Set up the length validator.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     field :website
+    #
+    #     validates_length_of :website, in: 1..10
+    #   end
+    class LengthValidator < ActiveModel::Validations::LengthValidator
+      include Localizable
+    end
+  end
+end

data/lib/mongoid/validatable/localizable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Validatable
+
+    # Adds localization support to validations.
+    module Localizable
+
+      # Validates each for localized fields.
+      #
+      # @example Validate localized fields.
+      #   validator.validate_each(model, :name, "value")
+      #
+      # @param [ Document ] document The document.
+      # @param [ Symbol | String ] attribute The attribute to validate.
+      # @param [ Object ] value The attribute value.
+      def validate_each(document, attribute, value)
+        field = document.fields[document.database_field_name(attribute)]
+        if field.try(:localized?) && !value.blank?
+          value.values.each do |_value|
+            super(document, attribute, _value)
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end