mongoid 5.4.1 → 6.0.0.beta

data/lib/mongoid/contextual/none.rb

@@ -57,7 +57,7 @@ module Mongoid
       # @example Allow pluck for null context.
       #   context.pluck(:name)
       #
-      # @param [ String, Symbol, Array ] args Field or fields to pluck.
+      # @param [ String, Symbol, Array ] field or fields to pluck.
       #
       # @return [ Array ] Emtpy Array
       def pluck(*args)
@@ -69,7 +69,7 @@ module Mongoid
       # @example Create the new context.
       #   Null.new(criteria)
       #
-      # @param [ Criteria ] criteria The criteria.
+      # @param [ Criteria ] The criteria.
       #
       # @since 4.0.0
       def initialize(criteria)

data/lib/mongoid/copyable.rb

@@ -14,17 +14,26 @@ module Mongoid
     # @example Clone the document.
     #   document.clone
     #
+    # @param [ Document ] other The document getting cloned.
+    #
     # @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.
       attrs = clone_document.except("_id", "id")
-      begin
-        self.class.new(attrs)
-      rescue Errors::UnknownAttribute
-        self.class.send(:include, Attributes::Dynamic)
-        self.class.new(attrs)
+      dynamic_attrs = {}
+      attrs.reject! do |attr_name, value|
+        dynamic_attrs[attr_name] = value unless self.attribute_names.include?(attr_name)
+      end
+      self.class.new(attrs).tap do |object|
+        dynamic_attrs.each do |attr_name, value|
+          if object.respond_to?("#{attr_name}=")
+            object.send("#{attr_name}=", value)
+          else
+            object.attributes[attr_name] = value
+          end
+        end
       end
     end
     alias :dup :clone
@@ -38,10 +47,12 @@ module Mongoid
     # @example clone document
     #   model.clone_document
     #
+    # @param [ Hash ] dcoument The document with hash format
+    #
     # @since 3.0.22
     def clone_document
       attrs = as_document.__deep_copy__
-      process_localized_attributes(self, attrs)
+      process_localized_attributes(attrs)
       attrs
     end
 
@@ -56,23 +67,12 @@ module Mongoid
     # @param [ Hash ] attrs The attributes.
     #
     # @since 3.0.20
-    def process_localized_attributes(klass, attrs)
-      klass.localized_fields.keys.each do |name|
+    def process_localized_attributes(attrs)
+      localized_fields.keys.each do |name|
         if value = attrs.delete(name)
           attrs["#{name}_translations"] = value
         end
       end
-      klass.embedded_relations.each do |_, metadata|
-        next unless attrs.present? && attrs[metadata.key].present?
-
-        if metadata.macro == :embeds_many
-          attrs[metadata.key].each do |attr|
-            process_localized_attributes(metadata.klass, attr)
-          end
-        else
-          process_localized_attributes(metadata.klass, attrs[metadata.key])
-        end
-      end
     end
   end
 end

data/lib/mongoid/criteria.rb

@@ -4,7 +4,9 @@ require "mongoid/criteria/includable"
 require "mongoid/criteria/inspectable"
 require "mongoid/criteria/marshalable"
 require "mongoid/criteria/modifiable"
+require "mongoid/criteria/queryable"
 require "mongoid/criteria/scopable"
+require "mongoid/criteria/options"
 
 module Mongoid
 
@@ -17,7 +19,7 @@ module Mongoid
   class Criteria
     include Enumerable
     include Contextual
-    include Origin::Queryable
+    include Queryable
     include Findable
     include Inspectable
     include Includable
@@ -25,6 +27,7 @@ module Mongoid
     include Modifiable
     include Scopable
     include Clients::Options
+    include Options
 
     # Static array used to check with method missing - we only need to ever
     # instantiate once.
@@ -193,8 +196,6 @@ module Mongoid
     # @since 1.0.0
     def initialize(klass)
       @klass = klass
-      @embedded = nil
-      @none = nil
       klass ? super(klass.aliased_fields, klass.fields) : super({}, {})
     end
 
@@ -386,7 +387,7 @@ module Mongoid
     # @example Add a javascript selection.
     #   criteria.where("this.name == 'syd'")
     #
-    # @param [ String, Hash ] expression The javascript or standard selection.
+    # @param [ String, Hash ] criterion The javascript or standard selection.
     #
     # @raise [ UnsupportedJavascript ] If provided a string and the criteria
     #   is embedded.

data/lib/mongoid/criteria/findable.rb

@@ -8,8 +8,7 @@ module Mongoid
       # @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.
+      # @param [ Object ] args The arguments passed.
       #
       # @raise [ Errors::DocumentNotFound ] If nothing returned.
       #
@@ -67,7 +66,7 @@ module Mongoid
       # @example Get the documents from the map or criteria.
       #   criteria.multiple_from_map_or_db(ids)
       #
-      # @param [ Array<Object> ] ids The searched ids.
+      # @param [ ids ] The searched ids.
       #
       # @return [ Array<Document> ] The found documents.
       def multiple_from_db(ids)

data/lib/mongoid/criteria/includable.rb

@@ -27,7 +27,13 @@ module Mongoid
       #
       # @since 2.2.0
       def includes(*relations)
-        extract_includes_list(klass, relations)
+        relations.flatten.each do |relation|
+          if relation.is_a?(Hash)
+            extract_nested_inclusion(klass, relation)
+          else
+            add_inclusion(klass, relation)
+          end
+        end
         clone
       end
 
@@ -48,7 +54,7 @@ module Mongoid
       # @example Set the inclusions.
       #   criteria.inclusions = [ meta ]
       #
-      # @param [ Array<Metadata> ] value The inclusions.
+      # @param [ Array<Metadata> ] The inclusions.
       #
       # @return [ Array<Metadata> ] The new inclusions.
       #
@@ -65,31 +71,72 @@ module Mongoid
       #   criteria.add_inclusion(Person, :posts)
       #
       # @param [ Class, String, Symbol ] _klass The class or string/symbol of the class name.
-      # @param [ Symbol ] metadata The relation.
+      # @param [ Symbol ] relation The relation.
       #
       # @raise [ Errors::InvalidIncludes ] If no relation is found.
       #
       # @since 5.1.0
-      def add_inclusion(_klass, metadata)
+      def add_inclusion(_klass, relation)
+        metadata = get_inclusion_metadata(_klass, relation)
+        raise Errors::InvalidIncludes.new(_klass, [ relation ]) unless metadata
         inclusions.push(metadata) unless inclusions.include?(metadata)
       end
 
-      def extract_includes_list(_parent_class, *relations_list)
-        relations_list.flatten.each do |relation_object|
-          if relation_object.is_a?(Hash)
-            relation_object.each do |relation, _includes|
-              metadata = _parent_class.reflect_on_association(relation)
-              raise Errors::InvalidIncludes.new(_klass, [ relation ]) unless metadata
-              add_inclusion(_parent_class, metadata)
-              extract_includes_list(metadata.klass, _includes)
-            end
+      # Extract inclusion definitions from a list.
+      #
+      # @example Extract the inclusions from a list.
+      #   criteria.extract_relations_list(:posts, [{ :alerts => :items }])
+      #
+      # @param [ Symbol ] association The name of the association.
+      # @param [ Array ] relations A list of associations.
+      #
+      # @since 5.1.0
+      def extract_relations_list(association, relations)
+        relations.each do |relation|
+          if relation.is_a?(Hash)
+            extract_nested_inclusion(association, relation)
           else
-            metadata = _parent_class.reflect_on_association(relation_object)
-            raise Errors::InvalidIncludes.new(_parent_class, [ relation_object ]) unless metadata
-            add_inclusion(_parent_class, metadata)
+            add_inclusion(association, relation)
           end
         end
       end
+
+      # Extract nested inclusion.
+      #
+      # @example Extract the inclusions from a nested definition.
+      #   criteria.extract_nested_inclusion(User, { :posts => [:alerts] })
+      #
+      # @param [ Class, Symbol ] _klass The class for which the inclusion should be added.
+      # @param [ Hash ] relation The nested inclusion.
+      #
+      # @since 5.1.0
+      def extract_nested_inclusion(_klass, relation)
+        relation.each do |association, _inclusion|
+          add_inclusion(_klass, association)
+          if _inclusion.is_a?(Array)
+            extract_relations_list(association, _inclusion)
+          else
+            add_inclusion(association, _inclusion)
+          end
+        end
+      end
+
+      # Get the metadata for an inclusion.
+      #
+      # @example Get the metadata for an inclusion definition.
+      #   criteria.get_inclusion_metadata(User, :posts)
+      #
+      # @param [ Class, Symbol, String ] _klass The class for determining the association metadata
+      # @param [ Symbol  ] association The name of the association.
+      #
+      # @since 5.1.0
+      def get_inclusion_metadata(_klass, association)
+        if _klass.is_a?(Class)
+          _klass.reflect_on_association(association)
+        else
+          _klass.to_s.classify.constantize.reflect_on_association(association)
+        end
+      end
     end
   end
 end

data/lib/mongoid/criteria/marshalable.rb

@@ -27,8 +27,8 @@ module Mongoid
       def marshal_load(data)
         @scoping_options, raw_selector, raw_options = data.pop(3)
         @klass, @driver, @inclusions, @documents, @strategy, @negating = data
-        @selector = load_hash(Origin::Selector, raw_selector)
-        @options = load_hash(Origin::Options, raw_options)
+        @selector = load_hash(Queryable::Selector, raw_selector)
+        @options = load_hash(Queryable::Options, raw_options)
       end
 
       private

data/lib/mongoid/criteria/modifiable.rb

@@ -173,7 +173,7 @@ module Mongoid
       # @since 3.0.0
       def create_document(method, attrs = nil, &block)
         attributes = selector.reduce(attrs ? attrs.dup : {}) do |hash, (key, value)|
-          unless key.to_s =~ /\$/ || value.is_a?(Hash)
+          unless invalid_key?(hash, key) || invalid_embedded_doc?(value)
             hash[key] = value
           end
           hash
@@ -216,6 +216,22 @@ module Mongoid
       def first_or(method, attrs = {}, &block)
         first || create_document(method, attrs, &block)
       end
+
+      private
+
+      def invalid_key?(hash, key)
+        # @todo Change this to BSON::String::ILLEGAL_KEY when ruby driver 2.3.0 is
+        # released and mongoid is updated to depend on driver >= 2.3.0
+        key.to_s =~ Mongoid::Document::ILLEGAL_KEY || hash.key?(key.to_sym) || hash.key?(key)
+      end
+
+      def invalid_embedded_doc?(value)
+        # @todo Change this to BSON::String::ILLEGAL_KEY when ruby driver 2.3.0 is
+        # released and mongoid is updated to depend on driver >= 2.3.0
+        value.is_a?(Hash) && value.any? do |key, v|
+          key.to_s =~ Mongoid::Document::ILLEGAL_KEY || invalid_embedded_doc?(v)
+        end
+      end
     end
   end
 end

data/lib/mongoid/criteria/options.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module Mongoid
+  class Criteria
+
+    # Module containing functionality for getting options on a Criteria object.
+    #
+    # @since 6.0.0
+    module Options
+
+      private
+
+      def persistence_context
+        klass.persistence_context
+      end
+
+      def set_persistence_context(options)
+        PersistenceContext.set(klass, options)
+      end
+
+      def clear_persistence_context(original_cluster)
+        PersistenceContext.clear(klass, original_cluster)
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/queryable.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+require "mongoid/criteria/queryable/extensions"
+require "mongoid/criteria/queryable/forwardable"
+require "mongoid/criteria/queryable/key"
+require "mongoid/criteria/queryable/macroable"
+require "mongoid/criteria/queryable/mergeable"
+require "mongoid/criteria/queryable/smash"
+require "mongoid/criteria/queryable/aggregable"
+require "mongoid/criteria/queryable/pipeline"
+require "mongoid/criteria/queryable/optional"
+require "mongoid/criteria/queryable/options"
+require "mongoid/criteria/queryable/selectable"
+require "mongoid/criteria/queryable/selector"
+
+module Mongoid
+  class Criteria
+
+    # A queryable is any object that needs queryable's dsl injected into it to build
+    # MongoDB queries. For example, a Mongoid::Criteria is an Queryable.
+    #
+    # @example Include queryable functionality.
+    #   class Criteria
+    #     include Queryable
+    #   end
+    module Queryable
+      include Mergeable
+      include Aggregable
+      include Selectable
+      include Optional
+
+      # @attribute [r] aliases The aliases.
+      # @attribute [r] driver The Mongo driver being used.
+      # @attribute [r] serializers The serializers.
+      attr_reader :aliases, :driver, :serializers
+
+      # Is this queryable equal to another object? Is true if the selector and
+      # options are equal.
+      #
+      # @example Are the objects equal?
+      #   queryable == criteria
+      #
+      # @param [ Object ] other The object to compare against.
+      #
+      # @return [ true, false ] If the objects are equal.
+      #
+      # @since 1.0.0
+      def ==(other)
+        return false unless other.is_a?(Queryable)
+        selector == other.selector && options == other.options
+      end
+
+      # Initialize the new queryable. Will yield itself to the block if a block
+      # is provided for objects that need additional behaviour.
+      #
+      # @example Initialize the queryable.
+      #   Queryable.new
+      #
+      # @param [ Hash ] aliases The optional field aliases.
+      # @param [ Hash ] serializers The optional field serializers.
+      # @param [ Symbol ] driver The driver being used.
+      #
+      # @since 1.0.0
+      def initialize(aliases = {}, serializers = {}, driver = :mongo)
+        @aliases, @driver, @serializers = aliases, driver.to_sym, serializers
+        @options = Options.new(aliases, serializers)
+        @selector = Selector.new(aliases, serializers)
+        @pipeline = Pipeline.new(aliases)
+        yield(self) if block_given?
+      end
+
+      # Handle the creation of a copy via #clone or #dup.
+      #
+      # @example Handle copy initialization.
+      #   queryable.initialize_copy(criteria)
+      #
+      # @param [ Queryable ] other The original copy.
+      #
+      # @since 1.0.0
+      def initialize_copy(other)
+        @options = other.options.__deep_copy__
+        @selector = other.selector.__deep_copy__
+        @pipeline = other.pipeline.__deep_copy__
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/queryable/aggregable.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+module Mongoid
+  class Criteria
+    module Queryable
+
+      # Provides a DSL around crafting aggregation framework commands.
+      #
+      # @since 2.0.0
+      module Aggregable
+        extend Macroable
+
+        # @attribute [r] pipeline The aggregation pipeline.
+        attr_reader :pipeline
+
+        # @attribute [rw] aggregating Flag for whether or not we are aggregating.
+        attr_writer :aggregating
+
+        # Has the aggregable enter an aggregation state. Ie, are only aggregation
+        # operations allowed at this point on.
+        #
+        # @example Is the aggregable aggregating?
+        #   aggregable.aggregating?
+        #
+        # @return [ true, false ] If the aggregable is aggregating.
+        #
+        # @since 2.0.0
+        def aggregating?
+          !!@aggregating
+        end
+
+        # Add a group ($group) operation to the aggregation pipeline.
+        #
+        # @example Add a group operation being verbose.
+        #   aggregable.group(count: { "$sum" => 1 }, max: { "$max" => "likes" })
+        #
+        # @example Add a group operation using symbol shortcuts.
+        #   aggregable.group(:count.sum => 1, :max.max => "likes")
+        #
+        # @param [ Hash ] operation The group operation.
+        #
+        # @return [ Aggregable ] The aggregable.
+        #
+        # @since 2.0.0
+        def group(operation)
+          aggregation(operation) do |pipeline|
+            pipeline.group(operation)
+          end
+        end
+        key :avg, :override, "$avg"
+        key :max, :override, "$max"
+        key :min, :override, "$min"
+        key :sum, :override, "$sum"
+        key :last, :override, "$last"
+        key :push, :override, "$push"
+        key :first, :override, "$first"
+        key :add_to_set, :override, "$addToSet"
+
+        # Add a projection ($project) to the aggregation pipeline.
+        #
+        # @example Add a projection to the pipeline.
+        #   aggregable.project(author: 1, name: 0)
+        #
+        # @param [ Hash ] criterion The projection to make.
+        #
+        # @return [ Aggregable ] The aggregable.
+        #
+        # @since 2.0.0
+        def project(operation = nil)
+          aggregation(operation) do |pipeline|
+            pipeline.project(operation)
+          end
+        end
+
+        # Add an unwind ($unwind) to the aggregation pipeline.
+        #
+        # @example Add an unwind to the pipeline.
+        #   aggregable.unwind(:field)
+        #
+        # @param [ String, Symbol ] field The name of the field to unwind.
+        #
+        # @return [ Aggregable ] The aggregable.
+        #
+        # @since 2.0.0
+        def unwind(field)
+          aggregation(field) do |pipeline|
+            pipeline.unwind(field)
+          end
+        end
+
+        private
+
+        # Add the aggregation operation.
+        #
+        # @api private
+        #
+        # @example Aggregate on the operation.
+        #   aggregation(operation) do |pipeline|
+        #     pipeline.push("$project" => operation)
+        #   end
+        #
+        # @param [ Hash ] operation The operation for the pipeline.
+        #
+        # @return [ Aggregable ] The cloned aggregable.
+        #
+        # @since 2.0.0
+        def aggregation(operation)
+          return self unless operation
+          clone.tap do |query|
+            unless aggregating?
+              query.pipeline.concat(query.selector.to_pipeline)
+              query.pipeline.concat(query.options.to_pipeline)
+              query.aggregating = true
+            end
+            yield(query.pipeline)
+          end
+        end
+      end
+    end
+  end
+end