mongoid-ultra 9.0.0.0.alpha1

data/lib/mongoid/contextual/none.rb

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+require "mongoid/contextual/aggregable/none"
+
+module Mongoid
+  module Contextual
+    class None
+      include Enumerable
+      include Aggregable::None
+      include Queryable
+
+      attr_reader :criteria, :klass
+
+      # Check if the context is equal to the other object.
+      #
+      # @example Check equality.
+      #   context == []
+      #
+      # @param [ Array ] other The other array.
+      #
+      # @return [ true | false ] If the objects are equal.
+      def ==(other)
+        other.is_a?(None)
+      end
+
+      # Get the distinct field values in null context.
+      #
+      # @example Get the distinct values in null context.
+      #   context.distinct(:name)
+      #
+      # @param [ String | Symbol ] _field The name of the field.
+      #
+      # @return [ Array ] An empty Array.
+      def distinct(_field)
+        []
+      end
+
+      # Iterate over the null context. There are no documents to iterate over
+      # in this case.
+      #
+      # @example Iterate over the null context.
+      #   context.each do |doc|
+      #     puts doc.name
+      #   end
+      #
+      # @return [ Enumerator ] The enumerator.
+      def each
+        if block_given?
+          [].each { |doc| yield(doc) }
+          self
+        else
+          to_enum
+        end
+      end
+
+      # Do any documents exist for the context.
+      #
+      # @example Do any documents exist in the null context.
+      #   context.exists?
+      #
+      # @example Do any documents exist for given _id.
+      #   context.exists?(BSON::ObjectId(...))
+      #
+      # @example Do any documents exist for given conditions.
+      #   context.exists?(name: "...")
+      #
+      # @param [ Hash | Object | false ] id_or_conditions an _id to
+      #   search for, a hash of conditions, nil or false.
+      #
+      # @return [ false ] Always false.
+      def exists?(id_or_conditions = :none); false; end
+
+      # Pluck the field values in null context.
+      #
+      # @example Get the values for null context.
+      #   context.pluck(:name)
+      #
+      # @param [ [ String | Symbol ]... ] *_fields Field(s) to pluck.
+      #
+      # @return [ Array ] An empty Array.
+      def pluck(*_fields)
+        []
+      end
+
+      # Pick the field values in null context.
+      #
+      # @example Get the value for null context.
+      #   context.pick(:name)
+      #
+      # @param [ [ String | Symbol ]... ] *_fields Field(s) to pick.
+      #
+      # @return [ nil ] Always return nil.
+      def pick(*_fields)
+        nil
+      end
+
+      # Tally the field values in null context.
+      #
+      # @example Get the values for null context.
+      #   context.tally(:name)
+      #
+      # @param [ String | Symbol ] _field Field to tally.
+      #
+      # @return [ Hash ] An empty Hash.
+      def tally(_field)
+        {}
+      end
+
+      # Create the new null context.
+      #
+      # @example Create the new context.
+      #   Null.new(criteria)
+      #
+      # @param [ Criteria ] criteria The criteria.
+      def initialize(criteria)
+        @criteria, @klass = criteria, criteria.klass
+      end
+
+      # Always returns nil.
+      #
+      # @example Get the first document in null context.
+      #   context.first
+      #
+      # @param [ Integer ] limit The number of documents to return.
+      #
+      # @return [ [] | nil ] Empty array or nil.
+      def first(limit = nil)
+        [] unless limit.nil?
+      end
+
+      # Always raises an error.
+      #
+      # @example Get the first document in null context.
+      #   context.first!
+      #
+      # @raises [ Mongoid::Errors::DocumentNotFound ] always raises.
+      def first!
+        raise_document_not_found_error
+      end
+
+      # Always returns nil.
+      #
+      # @example Get the last document in null context.
+      #   context.last
+      #
+      # @param [ Integer ] limit The number of documents to return.
+      #
+      # @return [ [] | nil ] Empty array or nil.
+      def last(limit = nil)
+        [] unless limit.nil?
+      end
+
+      # Always raises an error.
+      #
+      # @example Get the last document in null context.
+      #   context.last!
+      #
+      # @raises [ Mongoid::Errors::DocumentNotFound ] always raises.
+      def last!
+        raise_document_not_found_error
+      end
+
+      # Returns nil or empty array.
+      #
+      # @example Take a document in null context.
+      #   context.take
+      #
+      # @param [ Integer | nil ] limit The number of documents to take or nil.
+      #
+      # @return [ [] | nil ] Empty array or nil.
+      def take(limit = nil)
+        limit ? [] : nil
+      end
+
+      # Always raises an error.
+      #
+      # @example Take a document in null context.
+      #   context.take!
+      #
+      # @raises [ Mongoid::Errors::DocumentNotFound ] always raises.
+      def take!
+        raise_document_not_found_error
+      end
+
+      # Always returns nil.
+      #
+      # @example Get the second document in null context.
+      #   context.second
+      #
+      # @return [ nil ] Always nil.
+      def second
+        nil
+      end
+
+      # Always raises an error.
+      #
+      # @example Get the second document in null context.
+      #   context.second!
+      #
+      # @raises [ Mongoid::Errors::DocumentNotFound ] always raises.
+      def second!
+        raise_document_not_found_error
+      end
+
+      # Always returns nil.
+      #
+      # @example Get the third document in null context.
+      #   context.third
+      #
+      # @return [ nil ] Always nil.
+      def third
+        nil
+      end
+
+      # Always raises an error.
+      #
+      # @example Get the third document in null context.
+      #   context.third!
+      #
+      # @raises [ Mongoid::Errors::DocumentNotFound ] always raises.
+      def third!
+        raise_document_not_found_error
+      end
+
+      # Always returns nil.
+      #
+      # @example Get the fourth document in null context.
+      #   context.fourth
+      #
+      # @return [ nil ] Always nil.
+      def fourth
+        nil
+      end
+
+      # Always raises an error.
+      #
+      # @example Get the fourth document in null context.
+      #   context.fourth!
+      #
+      # @raises [ Mongoid::Errors::DocumentNotFound ] always raises.
+      def fourth!
+        raise_document_not_found_error
+      end
+
+      # Always returns nil.
+      #
+      # @example Get the fifth document in null context.
+      #   context.fifth
+      #
+      # @return [ nil ] Always nil.
+      def fifth
+        nil
+      end
+
+      # Always raises an error.
+      #
+      # @example Get the fifth document in null context.
+      #   context.fifth!
+      #
+      # @raises [ Mongoid::Errors::DocumentNotFound ] always raises.
+      def fifth!
+        raise_document_not_found_error
+      end
+
+      # Always returns nil.
+      #
+      # @example Get the second to last document in null context.
+      #   context.second_to_last
+      #
+      # @return [ nil ] Always nil.
+      def second_to_last
+        nil
+      end
+
+      # Always raises an error.
+      #
+      # @example Get the second to last document in null context.
+      #   context.second_to_last!
+      #
+      # @raises [ Mongoid::Errors::DocumentNotFound ] always raises.
+      def second_to_last!
+        raise_document_not_found_error
+      end
+
+      # Always returns nil.
+      #
+      # @example Get the third to last document in null context.
+      #   context.third_to_last
+      #
+      # @return [ nil ] Always nil.
+      def third_to_last
+        nil
+      end
+
+      # Always raises an error.
+      #
+      # @example Get the third to last document in null context.
+      #   context.third_to_last!
+      #
+      # @raises [ Mongoid::Errors::DocumentNotFound ] always raises.
+      def third_to_last!
+        raise_document_not_found_error
+      end
+
+      # Always returns zero.
+      #
+      # @example Get the length of null context.
+      #   context.length
+      #
+      # @return [ Integer ] Always zero.
+      def length
+        entries.length
+      end
+      alias :size :length
+
+      alias :find_first :first
+      alias :one :first
+
+      private
+
+      def raise_document_not_found_error
+        raise Errors::DocumentNotFound.new(klass, nil, nil)
+      end
+    end
+  end
+end

data/lib/mongoid/contextual/queryable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Contextual
+    module Queryable
+
+      # @attribute [r] collection The collection to query against.
+      # @attribute [r] criteria The criteria for the context.
+      # @attribute [r] klass The klass for the criteria.
+      attr_reader :collection, :criteria, :klass
+
+      # Is the enumerable of matching documents empty?
+      #
+      # @example Is the context empty?
+      #   context.blank?
+      #
+      # @return [ true | false ] If the context is empty.
+      def blank?
+        !exists?
+      end
+      alias :empty? :blank?
+    end
+  end
+end

data/lib/mongoid/contextual.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "mongoid/contextual/queryable"
+require "mongoid/contextual/mongo"
+require "mongoid/contextual/memory"
+require "mongoid/contextual/none"
+
+module Mongoid
+  module Contextual
+    extend Forwardable
+
+    # The aggregate operations provided in the aggregate module get delegated
+    # through to the context from the criteria.
+    def_delegators :context, *Aggregable::Mongo.public_instance_methods(false)
+
+    # The atomic operations provided in the atomic context get delegated
+    # through to the context from the criteria.
+    def_delegators :context, *Atomic.public_instance_methods(false)
+
+    # The methods in the contexts themselves should all get delegated to,
+    # including destructive, modification, and optional methods.
+    def_delegators :context, *(Mongo.public_instance_methods(false) - [ :skip, :limit ])
+
+    # This gets blank and empty included.
+    def_delegators :context, *Queryable.public_instance_methods(false)
+
+    # Get the context in which criteria queries should execute. This is either
+    # in memory (for embedded documents) or mongo (for root level documents.)
+    #
+    # @example Get the context.
+    #   criteria.context
+    #
+    # @return [ Memory | Mongo ] The context.
+    def context
+      @context ||= create_context
+    end
+
+    # Instructs the context to schedule an asynchronous loading of documents
+    # specified by the criteria.
+    #
+    # Note that depending on the context and on the Mongoid configuration,
+    # documents can be loaded synchronously on the caller's thread.
+    #
+    # @return [ Criteria ] Returns self.
+    def load_async
+      context.load_async if context.respond_to?(:load_async)
+      self
+    end
+
+    private
+
+    # Create the context for the queries to execute. Will be memory for
+    # embedded documents and mongo for root documents.
+    #
+    # @api private
+    #
+    # @example Create the context.
+    #   contextual.create_context
+    #
+    # @return [ Mongo | Memory ] The context.
+    def create_context
+      return None.new(self) if empty_and_chainable?
+      embedded ? Memory.new(self) : Mongo.new(self)
+    end
+  end
+end

data/lib/mongoid/copyable.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # This module contains the behavior of Mongoid's clone/dup of documents.
+  module Copyable
+    extend ActiveSupport::Concern
+
+    # Clone or dup the current +Document+. This will return all attributes with
+    # the exception of the document's id, and will reset all the
+    # instance variables.
+    #
+    # This clone also includes embedded documents. If there is an _id field in
+    # the embedded document, it will be maintained, unlike the root's _id.
+    #
+    # If cloning an embedded child, the embedded parent is not cloned and the
+    # embedded_in association is not set.
+    #
+    # @example Clone the document.
+    #   document.clone
+    #
+    # @return [ Document ] The new document.
+    def clone
+      # @note This next line is here to address #2704, even though having an
+      # _id and id field in the document would cause problems with Mongoid
+      # elsewhere. Note this is only done on the root document as we want
+      # to maintain the same _id on the embedded documents.
+      attrs = clone_document.except(*self.class.id_fields)
+      Copyable.clone_with_hash(self.class, attrs)
+    end
+    alias :dup :clone
+
+    private
+
+    # Create clone of a document of the given klass with the given attributes
+    # hash. This is used recursively so that embedded associations are cloned
+    # safely.
+    #
+    # @param klass [ Class ] The class of the document to create.
+    # @param attrs [ Hash ] The hash of the attributes.
+    #
+    # @return [ Document ] The new document.
+    def self.clone_with_hash(klass, attrs)
+      dynamic_attrs = {}
+      _attribute_names = klass.attribute_names
+      attrs.reject! do |attr_name, value|
+        unless _attribute_names.include?(attr_name)
+          dynamic_attrs[attr_name] = value
+          true
+        end
+      end
+
+      Factory.build(klass, attrs).tap do |object|
+        dynamic_attrs.each do |attr_name, value|
+          assoc = object.embedded_relations[attr_name]
+          if assoc&.one? && Hash === value
+            object.send("#{attr_name}=", clone_with_hash(assoc.klass, value))
+          elsif assoc&.many? && Array === value
+            docs = value.map { |h| clone_with_hash(assoc.klass, h) }
+            object.send("#{attr_name}=", docs)
+          elsif object.respond_to?("#{attr_name}=")
+            object.send("#{attr_name}=", value)
+          else
+            object.attributes[attr_name] = value
+          end
+        end
+      end
+    end
+
+    # Clone the document attributes
+    #
+    # @api private
+    #
+    # @example clone document
+    #   model.clone_document
+    def clone_document
+      attrs = as_attributes.__deep_copy__
+      process_localized_attributes(self, attrs)
+      attrs
+    end
+
+    # When cloning, if the document has localized fields we need to ensure they
+    # are properly processed in the clone.
+    #
+    # @api private
+    #
+    # @example Process localized attributes.
+    #   model.process_localized_attributes(attributes)
+    #
+    # @param [ Hash ] attrs The attributes.
+    def process_localized_attributes(klass, attrs)
+      klass.localized_fields.keys.each do |name|
+        if value = attrs.delete(name)
+          attrs["#{name}_translations"] = value
+        end
+      end
+      klass.embedded_relations.each do |_, association|
+        next unless attrs.present? && attrs[association.key].present?
+
+        if association.is_a?(Association::Embedded::EmbedsMany)
+          attrs[association.key].each do |attr|
+            embedded_klass = if type = attr[self.class.discriminator_key]
+              association.relation_class.get_discriminator_mapping(type) || association.relation_class
+            else
+              association.relation_class
+            end
+            process_localized_attributes(embedded_klass, attr)
+          end
+        else
+          process_localized_attributes(association.klass, attrs[association.key])
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/findable.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Mongoid
+  class Criteria
+    module Findable
+
+      # Execute the criteria or raise an error if no documents found.
+      #
+      # @example Execute or raise
+      #   criteria.execute_or_raise(id)
+      #
+      # @param [ Object ] ids The arguments passed.
+      # @param [ true | false ] multi Whether there arguments were a list.
+      #
+      # @raise [ Errors::DocumentNotFound ] If nothing returned.
+      #
+      # @return [ Document | Array<Document> ] The document(s).
+      def execute_or_raise(ids, multi)
+        result = multiple_from_db(ids)
+        check_for_missing_documents!(result, ids)
+        multi ? result : result.first
+      end
+
+      # Find the matching document(s) in the criteria for the provided id(s).
+      #
+      # @note Each argument can be an individual id, an array of ids or
+      #   a nested array. Each array will be flattened.
+      #
+      # @example Find by an id.
+      #   criteria.find(BSON::ObjectId.new)
+      #
+      # @example Find by multiple ids.
+      #   criteria.find([ BSON::ObjectId.new, BSON::ObjectId.new ])
+      #
+      # @param [ [ Object | Array<Object> ]... ] *args The id(s) to find.
+      #
+      # @return [ Document | Array<Document> ] The matching document(s).
+      def find(*args)
+        ids = args.__find_args__
+        raise_invalid if ids.any?(&:nil?)
+        for_ids(ids).execute_or_raise(ids, args.multi_arged?)
+      end
+
+      # Adds a criterion to the +Criteria+ that specifies an id that must be matched.
+      #
+      # @example Add a single id criteria.
+      #   criteria.for_ids([ 1 ])
+      #
+      # @example Add multiple id criteria.
+      #   criteria.for_ids([ 1, 2 ])
+      #
+      # @param [ Array ] ids The array of ids.
+      #
+      # @return [ Criteria ] The cloned criteria.
+      def for_ids(ids)
+        ids = mongoize_ids(ids)
+        if ids.size > 1
+          send(id_finder, { _id: { "$in" => ids }})
+        else
+          send(id_finder, { _id: ids.first })
+        end
+      end
+
+      # Get the documents from the identity map, and if not found hit the
+      # database.
+      #
+      # @example Get the documents from the map or criteria.
+      #   criteria.multiple_from_map_or_db(ids)
+      #
+      # @param [ Array<Object> ] ids The searched ids.
+      #
+      # @return [ Array<Document> ] The found documents.
+      def multiple_from_db(ids)
+        return entries if embedded?
+        ids = mongoize_ids(ids)
+        ids.empty? ? [] : from_database(ids)
+      end
+
+      private
+
+      # Get the finder used to generate the id query.
+      #
+      # @api private
+      #
+      # @example Get the id finder.
+      #   criteria.id_finder
+      #
+      # @return [ Symbol ] The name of the finder method.
+      def id_finder
+        @id_finder ||= extract_id ? :all_of : :where
+      end
+
+      # Get documents from the database only.
+      #
+      # @api private
+      #
+      # @example Get documents from the database.
+      #   criteria.from_database(ids)
+      #
+      # @param [ Array<Object> ] ids The ids to fetch with.
+      #
+      # @return [ Array<Document> ] The matching documents.
+      def from_database(ids)
+        from_database_selector(ids).entries
+      end
+
+      private def from_database_selector(ids)
+        if ids.size > 1
+          any_in(_id: ids)
+        else
+          where(_id: ids.first)
+        end
+      end
+
+      # Convert all the ids to their proper types.
+      #
+      # @api private
+      #
+      # @example Convert the ids.
+      #   criteria.mongoize_ids(ids)
+      #
+      # @param [ Array<Object> ] ids The ids to convert.
+      #
+      # @return [ Array<Object> ] The converted ids.
+      def mongoize_ids(ids)
+        ids.map do |id|
+          id = id[:_id] if id.respond_to?(:keys) && id[:_id]
+          klass.fields["_id"].mongoize(id)
+        end
+      end
+
+      # Convenience method of raising an invalid options error.
+      #
+      # @example Raise the error.
+      #   criteria.raise_invalid
+      #
+      # @raise [ Errors::InvalidOptions ] The error.
+      def raise_invalid
+        raise Errors::InvalidFind.new
+      end
+    end
+  end
+end