mongoid-ultra 9.0.0.0.alpha1

data/lib/mongoid/criteria/includable.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Mongoid
+  class Criteria
+
+    # Module providing functionality for parsing (nested) inclusion definitions.
+    module Includable
+
+      # Eager loads all the provided associations. Will load all the documents
+      # into the identity map whose ids match based on the extra query for the
+      # ids.
+      #
+      # @note This will work for embedded associations that reference another
+      #   collection via belongs_to as well.
+      #
+      # @note Eager loading brings all the documents into memory, so there is a
+      #   sweet spot on the performance gains. Internal benchmarks show that
+      #   eager loading becomes slower around 100k documents, but this will
+      #   naturally depend on the specific application.
+      #
+      # @example Eager load the provided associations.
+      #   Person.includes(:posts, :game)
+      #
+      # @param [ [ Symbol | Hash ]... ] *relations The names of the association(s)
+      #   to eager load.
+      #
+      # @return [ Criteria ] The cloned criteria.
+      def includes(*relations)
+        extract_includes_list(klass, nil, relations)
+        clone
+      end
+
+      # Get a list of criteria that are to be executed for eager loading.
+      #
+      # @return [ Array<Mongoid::Association::Relatable> ] The inclusions.
+      def inclusions
+        @inclusions ||= []
+      end
+
+      # Set the inclusions for the criteria.
+      #
+      # @param [ Array<Mongoid::Association::Relatable> ] value The inclusions.
+      #
+      # @return [ Array<Mongoid::Association::Relatable> ] The new inclusions.
+      def inclusions=(value)
+        @inclusions = value
+      end
+
+      private
+
+      # Add an inclusion definition to the list of inclusions for the criteria.
+      #
+      # @param [ Mongoid::Association::Relatable ] association The association metadata.
+      # @param [ String ] parent The name of the association above this one in
+      #   the inclusion tree, if it is a nested inclusion.
+      def add_inclusion(association, parent = nil)
+        if assoc = inclusions.detect { |a| a == association }
+          assoc.parent_inclusions.push(parent) if parent
+        else
+          assoc = association.dup
+          assoc.parent_inclusions = []
+          assoc.parent_inclusions.push(parent) if parent
+          inclusions.push(assoc)
+        end
+      end
+
+      # Iterate through the list of relations and create the inclusions list.
+      #
+      # @param [ Class | String | Symbol ] _parent_class The class from which the
+      #   association originates.
+      # @param [ String ] parent The name of the association above this one in
+      #   the inclusion tree, if it is a nested inclusion.
+      # @param [ [ Symbol | Hash | Array<Symbol | Hash> ]... ] *relations_list
+      #   The names of the association(s) to eager load.
+      def extract_includes_list(_parent_class, parent, *relations_list)
+        relations_list.flatten.each do |relation_object|
+          if relation_object.is_a?(Hash)
+            relation_object.each do |relation, _includes|
+              association = _parent_class.reflect_on_association(relation)
+              raise Errors::InvalidIncludes.new(_klass, [ relation ]) unless association
+              add_inclusion(association, parent)
+              extract_includes_list(association.klass, association.name, _includes)
+            end
+          else
+            association = _parent_class.reflect_on_association(relation_object)
+            raise Errors::InvalidIncludes.new(_parent_class, [ relation_object ]) unless association
+            add_inclusion(association, parent)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/inspectable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Mongoid
+  class Criteria
+    module Inspectable
+
+      # Get a pretty string representation of the criteria, including the
+      # selector, options, matching count and documents for inspection.
+      #
+      # @example Inspect the criteria.
+      #   criteria.inspect
+      #
+      # @return [ String ] The inspection string.
+      def inspect
+%Q{#<Mongoid::Criteria
+  selector: #{selector.inspect}
+  options:  #{options.inspect}
+  class:    #{klass}
+  embedded: #{embedded?}>
+}
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/marshalable.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Mongoid
+  class Criteria
+    module Marshalable
+
+      # Provides the data needed to Marshal.dump a criteria.
+      #
+      # @example Dump the criteria.
+      #   Marshal.dump(criteria)
+      #
+      # Note :mongo is written here for backwards compatibility with Mongoid 7
+      # and earlier.
+      #
+      # @return [ Array<Object> ] The dumped data.
+      def marshal_dump
+        data = [ klass, :mongo, inclusions, documents, strategy, negating ]
+        data.push(scoping_options).push(dump_hash(:selector)).push(dump_hash(:options))
+      end
+
+      # Resets the criteria object after a Marshal.load
+      #
+      # @example Load the criteria.
+      #   Marshal.load(criteria)
+      #
+      # @param [ Array ] data The raw data.
+      def marshal_load(data)
+        @scoping_options, raw_selector, raw_options = data.pop(3)
+        @klass, driver, @inclusions, @documents, @strategy, @negating = data
+
+        if driver == :mongo1x
+          raise NotImplementedError, "Mongoid no longer supports marshalling with driver version 1.x."
+        end
+
+        @selector = load_hash(Queryable::Selector, raw_selector)
+        @options = load_hash(Queryable::Options, raw_options)
+      end
+
+      private
+
+      def dump_hash(name)
+        send(name).inject({}) do |raw, (key, value)|
+          raw[key] = value
+          raw
+        end
+      end
+
+      def load_hash(hash_class, raw)
+        hash = hash_class.new(klass.aliased_fields, klass.fields)
+        hash.merge!(raw)
+        hash
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/modifiable.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module Mongoid
+  class Criteria
+    module Modifiable
+
+      # @attribute [r] create_attrs Additional attributes to add to the Document upon creation.
+      # @api private
+      attr_reader :create_attrs
+
+      # Build a document given the selector and return it.
+      # Complex criteria, such as $in and $or operations will get ignored.
+      #
+      # @example build the document.
+      #   Person.where(:title => "Sir").build
+      #
+      # @example Build with selectors getting ignored.
+      #   Person.where(:age.gt => 5).build
+      #
+      # @return [ Document ] A non-persisted document.
+      def build(attrs = {}, &block)
+        create_document(:new, attrs, &block)
+      end
+      alias :new :build
+
+      # Create a document in the database given the selector and return it.
+      # Complex criteria, such as $in and $or operations will get ignored.
+      #
+      # @example Create the document.
+      #   Person.where(:title => "Sir").create
+      #
+      # @example Create with selectors getting ignored.
+      #   Person.where(:age.gt => 5).create
+      #
+      # @return [ Document ] A newly created document.
+      def create(attrs = {}, &block)
+        create_document(:create, attrs, &block)
+      end
+
+      # Create a document in the database given the selector and return it.
+      # Complex criteria, such as $in and $or operations will get ignored.
+      # If validation fails, an error will be raised.
+      #
+      # @example Create the document.
+      #   Person.where(:title => "Sir").create
+      #
+      # @example Create with selectors getting ignored.
+      #   Person.where(:age.gt => 5).create
+      #
+      # @raise [ Errors::Validations ] on a validation error.
+      #
+      # @return [ Document ] A newly created document.
+      def create!(attrs = {}, &block)
+        create_document(:create!, attrs, &block)
+      end
+
+      # Define attributes with which new documents will be created.
+      #
+      # Note that if `find_or_create_by` is called after this in a method chain, the attributes in
+      # the query will override those from this method.
+      #
+      # @example Define attributes to be used when a new document is created.
+      #   Person.create_with(job: 'Engineer').find_or_create_by(employer: 'MongoDB')
+      #
+      # @return [ Mongoid::Criteria ] A criteria.
+      def create_with(attrs = {})
+        tap do
+          @create_attrs ||= {}
+          @create_attrs.update(attrs)
+        end
+      end
+
+      # Find the first +Document+ given the conditions, or creates a new document
+      # with the conditions that were supplied.
+      #
+      # @example Find or create the document.
+      #   Person.find_or_create_by(:attribute => "value")
+      #
+      # @param [ Hash ] attrs The attributes to check.
+      #
+      # @return [ Document ] A matching or newly created document.
+      def find_or_create_by(attrs = {}, &block)
+        find_or(:create, attrs, &block)
+      end
+
+      # Find the first +Document+ given the conditions, or creates a new document
+      # with the conditions that were supplied. If validation fails an
+      # exception will be raised.
+      #
+      # @example Find or create the document.
+      #   Person.find_or_create_by!(:attribute => "value")
+      #
+      # @param [ Hash ] attrs The attributes to check.
+      #
+      # @raise [ Errors::Validations ] on validation error.
+      #
+      # @return [ Document ] A matching or newly created document.
+      def find_or_create_by!(attrs = {}, &block)
+        find_or(:create!, attrs, &block)
+      end
+
+      # Find the first +Document+ given the conditions, or initializes a new document
+      # with the conditions that were supplied.
+      #
+      # @example Find or initialize the document.
+      #   Person.find_or_initialize_by(:attribute => "value")
+      #
+      # @param [ Hash ] attrs The attributes to check.
+      #
+      # @return [ Document ] A matching or newly initialized document.
+      def find_or_initialize_by(attrs = {}, &block)
+        find_or(:new, attrs, &block)
+      end
+
+      # Find the first +Document+, or creates a new document
+      # with the conditions that were supplied plus attributes.
+      #
+      # @example First or create the document.
+      #   Person.where(name: "Jon").first_or_create(attribute: "value")
+      #
+      # @param [ Hash ] attrs The additional attributes to add.
+      #
+      # @return [ Document ] A matching or newly created document.
+      def first_or_create(attrs = nil, &block)
+        first_or(:create, attrs, &block)
+      end
+
+      # Find the first +Document+, or creates a new document
+      # with the conditions that were supplied plus attributes and will
+      # raise an error if validation fails.
+      #
+      # @example First or create the document.
+      #   Person.where(name: "Jon").first_or_create!(attribute: "value")
+      #
+      # @param [ Hash ] attrs The additional attributes to add.
+      #
+      # @return [ Document ] A matching or newly created document.
+      def first_or_create!(attrs = nil, &block)
+        first_or(:create!, attrs, &block)
+      end
+
+      # Find the first +Document+, or initializes a new document
+      # with the conditions that were supplied plus attributes.
+      #
+      # @example First or initialize the document.
+      #   Person.where(name: "Jon").first_or_initialize(attribute: "value")
+      #
+      # @param [ Hash ] attrs The additional attributes to add.
+      #
+      # @return [ Document ] A matching or newly initialized document.
+      def first_or_initialize(attrs = nil, &block)
+        first_or(:new, attrs, &block)
+      end
+
+      private
+
+      # Create a document given the provided method and attributes from the
+      # existing selector.
+      #
+      # @api private
+      #
+      # @example Create a new document.
+      #   criteria.create_document(:new, {})
+      #
+      # @param [ Symbol ] method Either :new or :create.
+      # @param [ Hash ] attrs Additional attributes to use.
+      #
+      # @return [ Document ] The new or saved document.
+      def create_document(method, attrs = nil, &block)
+        attrs = (create_attrs || {}).merge(attrs || {})
+        attributes = selector.reduce(attrs) do |hash, (key, value)|
+          unless invalid_key?(hash, key) || invalid_embedded_doc?(value)
+            hash[key] = value
+          end
+          hash
+        end
+        if embedded?
+          attributes[:_parent] = parent_document
+          attributes[:_association] = association
+        end
+        if polymorphic? && @criterion
+          klass.__send__(method, attributes.merge(@criterion), &block)
+        else
+          klass.__send__(method, attributes, &block)
+        end
+      end
+
+      # Find the first object or create/initialize it.
+      #
+      # @api private
+      #
+      # @example Find or perform an action.
+      #   Person.find_or(:create, :name => "Dev")
+      #
+      # @param [ Symbol ] method The method to invoke.
+      # @param [ Hash ] attrs The attributes to query or set.
+      #
+      # @return [ Document ] The first or new document.
+      def find_or(method, attrs = {}, &block)
+        where(attrs).first || send(method, attrs, &block)
+      end
+
+      # Find the first document or create/initialize it.
+      #
+      # @api private
+      #
+      # @example First or perform an action.
+      #   Person.first_or(:create, :name => "Dev")
+      #
+      # @param [ Symbol ] method The method to invoke.
+      # @param [ Hash ] attrs The attributes to query or set.
+      #
+      # @return [ Document ] The first or new document.
+      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,24 @@
+# frozen_string_literal: true
+
+module Mongoid
+  class Criteria
+
+    # Module containing functionality for getting options on a Criteria object.
+    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, original_context)
+        PersistenceContext.clear(klass, original_cluster, original_context)
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/permission.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Mongoid
+  class Criteria
+    module Permission
+
+      [:all,
+       :all_in,
+       :and,
+       :all_of,
+       :between,
+       :elem_match,
+       :exists,
+       :gt,
+       :gte,
+       :in,
+       :any_in,
+       :lt,
+       :lte,
+       :max_distance,
+       :mod,
+       :ne,
+       :excludes,
+       :near,
+       :near_sphere,
+       :nin,
+       :not_in,
+       :nor,
+       :negating?,
+       :not,
+       :or,
+       :any_of,
+       :with_size,
+       :with_type,
+       :where,
+       :within_box,
+       :within_circle,
+       :within_polygon,
+       :within_spherical_circle
+      ].each do |method|
+        define_method(method) do |*criteria|
+          raise Errors::CriteriaNotPermitted.new(klass, method, criteria) unless should_permit?(criteria)
+          super(*criteria)
+        end
+      end
+
+      private
+
+      # Ensure that the criteria are permitted.
+      #
+      # @example Ignoring ActionController::Parameters
+      #   should_permit?({_id: ActionController::Parameters.new("$size" => 1)})
+      #
+      # @api private
+      #
+      # @param [ Object ] criteria
+      # @return [ true | false ] if should permit
+      def should_permit?(criteria)
+        if criteria.respond_to?(:permitted?)
+          return criteria.permitted?
+        elsif criteria.respond_to?(:each)
+          criteria.each do |criterion|
+            return false unless should_permit?(criterion)
+          end
+        end
+
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Mongoid
+  class Criteria
+    module Queryable
+
+      # Provides a DSL around crafting aggregation framework commands.
+      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.
+        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.
+        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 ] operation The projection to make.
+        #
+        # @return [ Aggregable ] The aggregable.
+        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.
+        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.
+        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

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Mongoid
+  class Criteria
+    module Queryable
+      # This module encapsulates methods that expand various high level
+      # query forms to the MongoDB hash condition selector syntax.
+      #
+      # @example Example high level form.
+      #   Band.where(:foo.gt => 5)
+      #
+      # @api private
+      module Expandable
+
+        private
+
+        # Expands the specified condition to MongoDB syntax.
+        #
+        # This method is meant to be called when processing the items of
+        # a condition hash and the key and the value of each item are
+        # already available separately.
+        #
+        # The following parameter forms are accepted:
+        #
+        # - field is a string or symbol; value is the field query expresision
+        # - field is a Key instance; value is the field query expression
+        # - field is a string corresponding to a MongoDB operator; value is
+        #   the operator value expression.
+        #
+        # This method expands the field-value combination to the MongoDB
+        # selector syntax and returns an array of
+        # [expanded key, expanded value]. The expanded key is converted to
+        # a string if it wasn't already a string.
+        #
+        # @param [ String | Symbol | Key ] field The field to expand.
+        # @param [ Object ] value The field's value.
+        #
+        # @return [ Array<String, Object> ] The expanded field and value.
+        def expand_one_condition(field, value)
+          kv = field.__expr_part__(value.__expand_complex__, negating?)
+          [kv.keys.first.to_s, kv.values.first]
+        end
+
+        # Expand criterion values to arrays, to be used with operators that
+        # take an array as argument such as $in.
+        #
+        # @example Convert all the values to arrays.
+        #   selectable.with_array_values({ key: 1...4 })
+        #
+        # @param [ Hash ] criterion The criterion.
+        #
+        # @return [ Hash ] The $in friendly criterion with array values.
+        #
+        # @api private
+        def expand_condition_to_array_values(criterion)
+          if criterion.nil?
+            raise ArgumentError, 'Criterion cannot be nil here'
+          end
+
+          Hash[criterion.map do |key, value|
+            [key, value.__array__]
+          end]
+        end
+
+      end
+    end
+  end
+end