mongoid-ultra 9.0.0.0.alpha1

data/lib/mongoid/document.rb

@@ -0,0 +1,389 @@
+# frozen_string_literal: true
+
+require "mongoid/positional"
+require "mongoid/evolvable"
+require "mongoid/extensions"
+require "mongoid/errors"
+require "mongoid/threaded"
+require "mongoid/atomic"
+require "mongoid/attributes"
+require "mongoid/contextual"
+require "mongoid/copyable"
+require "mongoid/equality"
+require "mongoid/criteria"
+require "mongoid/factory"
+require "mongoid/fields"
+require "mongoid/timestamps"
+require "mongoid/association"
+require "mongoid/composable"
+require "mongoid/touchable"
+
+module Mongoid
+
+  # This is the base module for all domain objects that need to be persisted to
+  # the database as documents.
+  module Document
+    extend ActiveSupport::Concern
+    include Composable
+    include Mongoid::Touchable::InstanceMethods
+
+    attr_accessor :__selected_fields
+    attr_reader :new_record
+
+    included do
+      Mongoid.register_model(self)
+    end
+
+    # Regex for matching illegal BSON keys.
+    # Note that bson 4.1 has the constant BSON::String::ILLEGAL_KEY
+    # that should be used instead.
+    # When ruby driver 2.3.0 is released and Mongoid can be updated
+    # to require >= 2.3.0, the BSON constant can be used.
+    ILLEGAL_KEY = /(\A[$])|(\.)/.freeze
+
+    # Freezes the internal attributes of the document.
+    #
+    # @example Freeze the document
+    #   document.freeze
+    #
+    # @return [ Document ] The document.
+    def freeze
+      as_attributes.freeze and self
+    end
+
+    # Checks if the document is frozen
+    #
+    # @example Check if frozen
+    #   document.frozen?
+    #
+    # @return [ true | false ] True if frozen, else false.
+    def frozen?
+      attributes.frozen?
+    end
+
+    # Delegates to identity in order to allow two records of the same identity
+    # to work with something like:
+    #
+    #   [ Person.find(1), Person.find(2), Person.find(3) ] &
+    #   [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
+    #
+    # @example Get the hash.
+    #   document.hash
+    #
+    # @return [ Integer ] The hash of the document's identity.
+    def hash
+      identity.hash
+    end
+
+    # A Document's is identified absolutely by its class and database id:
+    #
+    # Person.first.identity #=> [Person, BSON::ObjectId('4f775130a04745933a000003')]
+    #
+    # @example Get the identity
+    #   document.identity
+    #
+    # @return [ Array ] An array containing [document.class, document._id]
+    def identity
+      [ self.class, self._id ]
+    end
+
+    # Instantiate a new +Document+, setting the Document's attributes if
+    # given. If no attributes are provided, they will be initialized with
+    # an empty +Hash+.
+    #
+    # If a primary key is defined, the document's id will be set to that key,
+    # otherwise it will be set to a fresh +BSON::ObjectId+ string.
+    #
+    # @example Create a new document.
+    #   Person.new(:title => "Sir")
+    #
+    # @param [ Hash ] attrs The attributes to set up the document with.
+    #
+    # @return [ Document ] A new document.
+    def initialize(attrs = nil, &block)
+      construct_document(attrs, execute_callbacks: true, &block)
+    end
+
+    # Return the model name of the document.
+    #
+    # @example Return the model name.
+    #   document.model_name
+    #
+    # @return [ String ] The model name.
+    def model_name
+      self.class.model_name
+    end
+
+    # Return the key value for the document.
+    #
+    # @example Return the key.
+    #   document.to_key
+    #
+    # @return [ String ] The id of the document or nil if new.
+    def to_key
+      (persisted? || destroyed?) ? [ _id.to_s ] : nil
+    end
+
+    # Return a hash of the entire document hierarchy from this document and
+    # below. Used when the attributes are needed for everything and not just
+    # the current document.
+    #
+    # @example Get the full hierarchy.
+    #   person.as_document
+    #
+    # @return [ Hash ] A hash of all attributes in the hierarchy.
+    def as_document
+      BSON::Document.new(as_attributes)
+    end
+
+    # Calls #as_json on the document with additional, Mongoid-specific options.
+    #
+    # @note Rails 6 changes return value of as_json for non-primitive types
+    #   such as BSON::ObjectId. In Rails <= 5, as_json returned these as
+    #   instances of the class. In Rails 6, these are returned serialized to
+    #   primitive types (e.g. {"$oid"=>"5bcfc40bde340b37feda98e9"}).
+    #   See https://github.com/rails/rails/commit/2e5cb980a448e7f4ab00df6e9ad4c1cc456616aa
+    #   for more information.
+    #
+    # @example Get the document as json.
+    #   document.as_json(compact: true)
+    #
+    # @param [ Hash ] options The options.
+    #
+    # @option options [ true | false ] :compact (Deprecated) Whether to include fields
+    #   with nil values in the json document.
+    #
+    # @return [ Hash ] The document as json.
+    def as_json(options = nil)
+      rv = super
+      if options && options[:compact]
+        Mongoid::Warnings.warn_as_json_compact_deprecated
+        rv = rv.compact
+      end
+      rv
+    end
+
+    # Returns an instance of the specified class with the attributes,
+    # errors, and embedded documents of the current document.
+    #
+    # @example Return a subclass document as a superclass instance.
+    #   manager.becomes(Person)
+    #
+    # @raise [ ArgumentError ] If the class doesn't include Mongoid::Document
+    #
+    # @param [ Class ] klass The class to become.
+    #
+    # @return [ Document ] An instance of the specified class.
+    def becomes(klass)
+      unless klass.include?(Mongoid::Document)
+        raise ArgumentError, "A class which includes Mongoid::Document is expected"
+      end
+
+      became = klass.new(clone_document)
+      became._id = _id
+      became.instance_variable_set(:@changed_attributes, changed_attributes)
+      new_errors = ActiveModel::Errors.new(became)
+      new_errors.copy!(errors)
+      became.instance_variable_set(:@errors, new_errors)
+      became.instance_variable_set(:@new_record, new_record?)
+      became.instance_variable_set(:@destroyed, destroyed?)
+      became.changed_attributes[klass.discriminator_key] = self.class.discriminator_value
+      became[klass.discriminator_key] = klass.discriminator_value
+
+      # mark embedded docs as persisted
+      embedded_relations.each_pair do |name, meta|
+        without_autobuild do
+          relation = became.__send__(name)
+          Array.wrap(relation).each do |r|
+            r.instance_variable_set(:@new_record, new_record?)
+          end
+        end
+      end
+
+      became
+    end
+
+    private
+
+    # Does the construction of a document.
+    #
+    # @param [ Hash ] attrs The attributes to set up the document with.
+    # @param [ true | false ] execute_callbacks Flag specifies whether callbacks
+    #   should be run.
+    #
+    # @return [ Document ] A new document.
+    #
+    # @api private
+    def construct_document(attrs = nil, execute_callbacks: true)
+      @__parent = nil
+      _building do
+        @new_record = true
+        @attributes ||= {}
+        apply_pre_processed_defaults
+        apply_default_scoping
+        process_attributes(attrs) do
+          yield(self) if block_given?
+        end
+        @attributes_before_type_cast = @attributes.merge(attributes_before_type_cast)
+
+        if execute_callbacks
+          apply_post_processed_defaults
+          run_callbacks(:initialize) unless _initialize_callbacks.empty?
+        else
+          pending_callbacks << :apply_post_processed_defaults
+          pending_callbacks << :initialize
+        end
+      end
+      self
+    end
+
+    # Returns the logger
+    #
+    # @return [ Logger ] The configured logger or a default Logger instance.
+    def logger
+      Mongoid.logger
+    end
+
+    # Get the name of the model used in caching.
+    #
+    # @example Get the model key.
+    #   model.model_key
+    #
+    # @return [ String ] The model key.
+    def model_key
+      @model_cache_key ||= self.class.model_name.cache_key
+    end
+
+    # Returns a hash of the attributes.
+    #
+    # Note this method modifies the attributes hash that already exists on the
+    # class and returns it. This means that the hash returned by this method
+    # refers to the same hash as calling #attributes on the instance. See
+    # MONGOID-4476 for an explanation on how this is used.
+    #
+    # @return [ Hash ] The attributes hash.
+    def as_attributes
+      return attributes if frozen?
+      embedded_relations.each_pair do |name, meta|
+        without_autobuild do
+          relation, stored = send(name), meta.store_as
+          if attributes.key?(stored) || !relation.blank?
+            if !relation.nil?
+              attributes[stored] = relation.send(:as_attributes)
+            else
+              attributes.delete(stored)
+            end
+          end
+        end
+      end
+      attributes
+    end
+
+    module ClassMethods
+
+      # Instantiate a new object, only when loaded from the database or when
+      # the attributes have already been typecast.
+      #
+      # @example Create the document.
+      #   Person.instantiate(:title => "Sir", :age => 30)
+      #
+      # @param [ Hash ] attrs The hash of attributes to instantiate with.
+      # @param [ Integer ] selected_fields The selected fields from the
+      #   criteria.
+      # @param [ true | false ] execute_callbacks Flag specifies whether callbacks
+      #   should be run.
+      #
+      # @return [ Document ] A new document.
+      def instantiate(attrs = nil, selected_fields = nil, &block)
+        instantiate_document(attrs, selected_fields, execute_callbacks: true, &block)
+      end
+
+      # Instantiate the document.
+      #
+      # @param [ Hash ] attrs The hash of attributes to instantiate with.
+      # @param [ Integer ] selected_fields The selected fields from the
+      #   criteria.
+      # @param [ true | false ] execute_callbacks Flag specifies whether callbacks
+      #   should be run.
+      #
+      # @return [ Document ] A new document.
+      #
+      # @api private
+      def instantiate_document(attrs = nil, selected_fields = nil, execute_callbacks: true)
+        attributes = attrs&.to_h || {}
+
+        doc = allocate
+        doc.__selected_fields = selected_fields
+        doc.instance_variable_set(:@attributes, attributes)
+        doc.instance_variable_set(:@attributes_before_type_cast, attributes.dup)
+
+        if execute_callbacks
+          doc.apply_defaults
+          yield(doc) if block_given?
+          doc.run_callbacks(:find) unless doc._find_callbacks.empty?
+          doc.run_callbacks(:initialize) unless doc._initialize_callbacks.empty?
+        else
+          yield(doc) if block_given?
+          doc.pending_callbacks += [:apply_defaults, :find, :initialize]
+        end
+
+        doc
+      end
+
+      # Allocates and constructs a document.
+      #
+      # @param [ Hash ] attrs The attributes to set up the document with.
+      # @param [ true | false ] execute_callbacks Flag specifies whether callbacks
+      #   should be run.
+      #
+      # @return [ Document ] A new document.
+      #
+      # @api private
+      def construct_document(attrs = nil, execute_callbacks: true)
+        doc = allocate
+        doc.send(:construct_document, attrs, execute_callbacks: execute_callbacks)
+      end
+
+      # Returns all types to query for when using this class as the base.
+      #
+      # @example Get the types.
+      #   document._types
+      #
+      # @return [ Array<Class> ] All subclasses of the current document.
+      def _types
+        @_type ||= (descendants + [ self ]).uniq.map(&:discriminator_value)
+      end
+
+      # Clear the @_type cache. This is generally called when changing the discriminator
+      # key/value on a class.
+      #
+      # @example Get the types.
+      #   document._mongoid_clear_types
+      #
+      # @api private
+      def _mongoid_clear_types
+        @_type = nil
+        superclass._mongoid_clear_types if hereditary?
+      end
+
+      # Set the i18n scope to overwrite ActiveModel.
+      #
+      # @return [ Symbol ] :mongoid
+      def i18n_scope
+        :mongoid
+      end
+
+      # Returns the logger
+      #
+      # @example Get the logger.
+      #   Person.logger
+      #
+      # @return [ Logger ] The configured logger or a default Logger instance.
+      def logger
+        Mongoid.logger
+      end
+    end
+  end
+end
+
+ActiveSupport.run_load_hooks(:mongoid, Mongoid::Document)

data/lib/mongoid/encryptable.rb

@@ -0,0 +1,49 @@
+module Mongoid
+  # This module is used to extend Mongoid::Document
+  # to add encryption functionality.
+  module Encryptable
+    extend ActiveSupport::Concern
+
+    included do
+      # @return [Hash] The encryption metadata for the model.
+      class_attribute :encrypt_metadata
+      self.encrypt_metadata = {}
+    end
+
+    module ClassMethods
+      # Set the encryption metadata for the model. Parameters set here will be
+      # used to encrypt the fields of the model, unless overridden on the
+      # field itself.
+      #
+      # @param [ Hash ] options The encryption metadata.
+      # @option options [ String ] :key_id The base64-encoded UUID of the key
+      #   used to encrypt fields.
+      # @option options [ true | false ] :deterministic Whether the encryption
+      # is deterministic or not.
+      def encrypt_with(options = {})
+        self.encrypt_metadata = options
+      end
+
+      # Whether the model is encrypted. It means that either the encrypt_with
+      # method was called on the model, or at least one of the fields
+      # is encrypted.
+      #
+      # @return [ true | false ] Whether the model is encrypted.
+      def encrypted?
+        !encrypt_metadata.empty? || fields.any? { |_, field| field.is_a?(Mongoid::Fields::Encrypted) }
+      end
+
+      # Override the key_id for the model.
+      #
+      # This method is solely for testing purposes and should not be used in
+      # the application code. The schema_map is generated very early in the
+      # application lifecycle, and overriding the key_id after that will not
+      # have any effect.
+      #
+      # @api private
+      def set_key_id(key_id)
+        self.encrypt_metadata[:key_id] = key_id
+      end
+    end
+  end
+end

data/lib/mongoid/equality.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # This module contains the behavior of Mongoid's clone/dup of documents.
+  module Equality
+    # Leave the current contents of this module outside of InstanceMethods
+    # to prevent cherry picking conflicts. For now...
+    extend ActiveSupport::Concern
+
+    # Default comparison is via the string version of the id.
+    #
+    # @example Compare two documents.
+    #   person <=> other_person
+    #
+    # @param [ Document ] other The document to compare with.
+    #
+    # @return [ Integer ] -1, 0, 1.
+    def <=>(other)
+      attributes["_id"].to_s <=> other.attributes["_id"].to_s
+    end
+
+    # Performs equality checking on the document ids. For more robust
+    # equality checking please override this method.
+    #
+    # @example Compare for equality.
+    #   document == other
+    #
+    # @param [ Document | Object ] other The other object to compare with.
+    #
+    # @return [ true | false ] True if the ids are equal, false if not.
+    def ==(other)
+      self.class == other.class &&
+          attributes["_id"] == other.attributes["_id"]
+    end
+
+    # Delegates to ==. Used when needing checks in hashes.
+    #
+    # @example Perform equality checking.
+    #   document.eql?(other)
+    #
+    # @param [ Document | Object ] other The object to check against.
+    #
+    # @return [ true | false ] True if equal, false if not.
+    def eql?(other)
+      self == (other)
+    end
+
+    module ClassMethods
+      # Performs class equality checking.
+      #
+      # @example Compare the classes.
+      #   document === other
+      #
+      # @param [ Document | Object ] other The other object to compare with.
+      #
+      # @return [ true | false ] True if the classes are equal, false if not.
+      def ===(other)
+        other.is_a?(self)
+      end
+    end
+  end
+end

data/lib/mongoid/errors/ambiguous_relationship.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Errors
+
+    # This error is raised in case of an ambiguous association.
+    #
+    # @example An ambiguous association.
+    #   class Person
+    #     include Mongoid::Document
+    #
+    #     has_many :invitations, inverse_of: :person
+    #     has_many :referred_invitations, class_name: "Invitation", inverse_of: :referred_by
+    #   end
+    #
+    #   class Invitation
+    #     include Mongoid::Document
+    #
+    #     belongs_to :person
+    #     belongs_to :referred_by, class_name: "Person"
+    #   end
+    class AmbiguousRelationship < MongoidError
+
+      # Create the new error.
+      #
+      # @example Create the error.
+      #   AmbiguousRelationship.new(
+      #     Person, Drug, :person, [ :drugs, :evil_drugs ]
+      #   )
+      #
+      # @param [ Class ] klass The base class.
+      # @param [ Class ] inverse The inverse class.
+      # @param [ Symbol ] name The relation name.
+      # @param [ Array<Symbol> ] candidates The potential inverses.
+      def initialize(klass, inverse, name, candidates)
+        super(
+          compose_message(
+            "ambiguous_relationship",
+            {
+              klass: klass,
+              inverse: inverse,
+              name: name.inspect,
+              candidates: candidates.map(&:inspect).join(", ")
+            }
+          )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/attribute_not_loaded.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Errors
+
+    # Raised when attempting to read or write an attribute which has
+    # not been loaded. This can occur when using `.only` or `.without`
+    # query projection methods.
+    #
+    # @example Getting a field which has not been loaded.
+    #   Band.only(:name).first.label
+    #   #=> raises Mongoid::Errors::AttributeNotLoaded
+    #
+    # @example Setting a field which has not been loaded.
+    #   Band.without(:label).first.label = 'Sub Pop Records'
+    #   #=> raises Mongoid::Errors::AttributeNotLoaded
+    class AttributeNotLoaded < MongoidError
+
+      # Create the new error.
+      #
+      # @example Instantiate the error.
+      #   AttributeNotLoaded.new(Person, "title")
+      #
+      # @param [ Class ] klass The model class.
+      # @param [ String | Symbol ] name The name of the attribute.
+      def initialize(klass, name)
+        super(
+          compose_message("attribute_not_loaded", { klass: klass.name, name: name })
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/callback.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Errors
+
+    # This error is raised when calling #save! or .create! on a model when one
+    # of the callbacks returns false.
+    class Callback < MongoidError
+
+      # Create the new callbacks error.
+      #
+      # @example Create the new callbacks error.
+      #   Callbacks.new(Post, :create!)
+      #
+      # @param [ Class ] klass The class of the document.
+      # @param [ Symbol ] method The name of the method.
+      def initialize(klass, method)
+        super(
+          compose_message("callbacks", { klass: klass, method: method })
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/create_collection_failure.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Errors
+
+    # Raised when an attempt to create a collection failed.
+    class CreateCollectionFailure < MongoidError
+
+      # Instantiate the create collection error.
+      #
+      # @param [ String ] collection_name The name of the collection that
+      #   Mongoid failed to create.
+      # @param [ Hash ] collection_options The options that were used when
+      #   tried to create the collection.
+      # @param [ Mongo::Error::OperationFailure ] error The error raised when
+      #   tried to create the collection.
+      #
+      # @api private
+      def initialize(collection_name, collection_options, error)
+        super(
+            compose_message(
+                "create_collection_failure",
+                {
+                  collection_name: collection_name,
+                  collection_options: collection_options,
+                  error: "#{error.class}: #{error.message}"
+                }
+            )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/criteria_argument_required.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Errors
+
+    # This error is raised when a method on Criteria is given a nil argument.
+    class CriteriaArgumentRequired < MongoidError
+
+      # Creates the new exception instance.
+      #
+      # @api private
+      def initialize(query_method)
+        super(compose_message("criteria_argument_required",
+          query_method: query_method))
+      end
+    end
+  end
+end

data/lib/mongoid/errors/delete_restriction.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Errors
+
+    # This error is raised when attempting to destroy a model which has
+    # an association with dependency option set to restrict.
+    class DeleteRestriction < MongoidError
+
+      # Create the new callbacks error.
+      #
+      # @param [ Document ] document The document that was attempted to be
+      #   destroyed.
+      # @param [ Symbol ] association_name The name of the dependent
+      #   association that prevents the document from being deleted.
+      def initialize(document, association_name)
+        super(
+          compose_message(
+            "delete_restriction",
+            { document: document.class, relation: association_name }
+          )
+        )
+      end
+    end
+  end
+end