mongoid 7.0.13 → 7.1.0.rc0

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

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Queryable
@@ -92,12 +94,43 @@ module Mongoid
         # @return [ Array<Hash> ] The serialized values.
         #
         # @since 1.0.0
-        def evolve_multi(value)
-          value.map do |val|
-            Hash[val.map do |key, _value|
-              _value = evolve_multi(_value) if multi_selection?(key)
+        def evolve_multi(specs)
+          unless specs.is_a?(Array)
+            raise ArgumentError, "specs is not an array: #{specs.inspect}"
+          end
+          specs.map do |spec|
+            Hash[spec.map do |key, value|
+              # If an application nests conditionals, e.g.
+              # {'$or' => [{'$or' => {...}}]},
+              # when evolve_multi is called for the top level hash,
+              # this call recursively transforms the bottom level $or.
+              if multi_selection?(key)
+                value = evolve_multi(value)
+              end
+
+              # storage_pair handles field aliases but not localization for
+              # some reason, although per its documentation Smash supposedly
+              # owns both.
               name, serializer = storage_pair(key)
-              [ localized_key(name, serializer), evolve(serializer, _value) ]
+              final_key = localized_key(name, serializer)
+              # This performs type conversions on the value and transformations
+              # that depend on the type of the field that the value is stored
+              # in, but not transformations that have to do with query shape.
+              evolved_value = evolve(serializer, value)
+
+              # This builds a query shape around the value, when the query
+              # involves complex keys. For example, {:foo.lt => 5} produces
+              # {'foo' => {'$lt' => 5}}. This step should be done after all
+              # value-based processing is complete.
+              if key.is_a?(Key)
+                if serializer && evolved_value != value
+                  raise NotImplementedError, "This method is not prepared to handle key being a Key and serializer being not nil"
+                end
+
+                evolved_value = key.transform_value(evolved_value)
+              end
+
+              [ final_key, evolved_value ]
             end]
           end.uniq
         end

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

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Queryable

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

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Mongoid
+  class Criteria
+    module Queryable
+      # This module encapsulates methods that write query expressions into
+      # the Criteria's selector.
+      #
+      # The query expressions must have already been expanded as necessary.
+      # The methods of this module do not perform processing on expression
+      # values.
+      #
+      # Methods in this module do not handle negation - if negation is needed,
+      # it must have already been handled upstream of these methods.
+      #
+      # @api private
+      module Storable
+
+        # Adds an operator expression to the selector.
+        #
+        # This method takes the operator and the operator value expression
+        # separately for callers' convenience. It can be considered to
+        # handle storing the hash `{operator => op_expr}`.
+        #
+        # If the selector already has the specified operator in it (on the
+        # top level), the new condition given in op_expr is added to the
+        # existing conditions for the specified operator. This is
+        # straightforward for $and; for other logical operators, the behavior
+        # of this method is to add the new conditions to the existing operator.
+        # For example, if the selector is currently:
+        #
+        #     {'foo' => 'bar', '$or' => [{'hello' => 'world'}]}
+        #
+        # ... and operator is '$or' and op_expr is `{'test' => 123'}`,
+        # the resulting selector will be:
+        #
+        #     {'foo' => 'bar', '$or' => [{'hello' => 'world'}, {'test' => 123}]}
+        #
+        # This does not implement an OR between the existing selector and the
+        # new operator expression - handling this is the job of upstream
+        # methods. This method simply stores op_expr into the selector on the
+        # assumption that the existing selector is the correct left hand side
+        # of the operation already.
+        #
+        # For non-logical query-level operators like $where and $text, if
+        # there already is a top-level operator with the same name, the
+        # op_expr is added to the selector via a top-level $and operator,
+        # thus producing a selector having both operator values.
+        #
+        # This method does not simplify values (i.e. if the selector is
+        # currently empty and operator is $and, op_expr is written to the
+        # selector with $and even if the $and can in principle be elided).
+        #
+        # This method mutates the receiver.
+        #
+        # @param [ String ] operator The operator to add.
+        # @param [ Hash ] op_expr Operator value to add.
+        #
+        # @return [ Storable ] self.
+        def add_operator_expression(operator, op_expr)
+          unless operator.is_a?(String)
+            raise ArgumentError, "Operator must be a string: #{operator}"
+          end
+
+          unless operator[0] == ?$
+            raise ArgumentError, "Operator must begin with $: #{operator}"
+          end
+
+          if %w($and $nor $or).include?(operator)
+            return add_logical_operator_expression(operator, op_expr)
+          end
+
+          # For other operators, if the operator already exists in the
+          # query, add the new condition with $and, otherwise add the
+          # new condition to the top level.
+          if selector[operator]
+            add_logical_operator_expression('$and', [{operator => op_expr}])
+          else
+            selector.store(operator, op_expr)
+          end
+
+          self
+        end
+
+        # Adds a logical operator expression to the selector.
+        #
+        # This method only handles logical operators ($and, $nor and $or).
+        # It raises ArgumentError if called with another operator. Note that
+        # in MongoDB, $not is a field-level operator and not a query-level one
+        # $not is not handled by this method as a result.
+        #
+        # This method takes the operator and the operator value expression
+        # separately for callers' convenience. It can be considered to
+        # handle storing the hash `{operator => op_expr}`.
+        #
+        # If the selector already has the specified operator in it (on the
+        # top level), the new condition given in op_expr is added to the
+        # existing conditions for the specified operator. This is
+        # straightforward for $and; for other logical operators, the behavior
+        # of this method is to add the new conditions to the existing operator.
+        # For example, if the selector is currently:
+        #
+        #     {'foo' => 'bar', '$or' => [{'hello' => 'world'}]}
+        #
+        # ... and operator is '$or' and op_expr is `{'test' => 123'}`,
+        # the resulting selector will be:
+        #
+        #     {'foo' => 'bar', '$or' => [{'hello' => 'world'}, {'test' => 123}]}
+        #
+        # This does not implement an OR between the existing selector and the
+        # new operator expression - handling this is the job of upstream
+        # methods. This method simply stores op_expr into the selector on the
+        # assumption that the existing selector is the correct left hand side
+        # of the operation already.
+        #
+        # This method does not simplify values (i.e. if the selector is
+        # currently empty and operator is $and, op_expr is written to the
+        # selector with $and even if the $and can in principle be elided).
+        #
+        # This method mutates the receiver.
+        #
+        # @param [ String ] operator The operator to add.
+        # @param [ Hash ] op_expr Operator value to add.
+        #
+        # @return [ Storable ] self.
+        def add_logical_operator_expression(operator, op_expr)
+          unless operator.is_a?(String)
+            raise ArgumentError, "Operator must be a string: #{operator}"
+          end
+
+          unless %w($and $nor $or).include?(operator)
+            raise ArgumentError, "This method only handles logical operators ($and, $nor, $or). Operator given: #{operator}"
+          end
+
+          unless op_expr.is_a?(Array)
+            raise ArgumentError, "Operator value expression must be an array: #{op_expr}"
+          end
+
+          if selector.length == 1 && selector.keys.first == operator
+            new_value = selector.values.first + op_expr
+            selector.store(operator, new_value)
+          elsif operator == '$and' || selector.empty?
+            # $and can always be added to top level and it will be combined
+            # with whatever other conditions exist.
+            selector.store(operator, op_expr)
+          else
+            # Other operators need to operate explicitly on the previous
+            # conditions and the new condition.
+            new_value = [selector.to_hash.dup] + op_expr
+            selector.replace(operator => new_value)
+          end
+
+          self
+        end
+
+        # Adds a field expression to the query.
+        #
+        # field must be a field name, and it must be a string. The upstream
+        # code must have converted other field/key types to the simple string
+        # form by the time this method is invoked.
+        #
+        # This method performs no processing on the provided field value.
+        #
+        # Mutates the receiver.
+        #
+        # @param [ String ] field The field name.
+        # @param [ Object ] value The field value.
+        #
+        # @return [ Storable ] self.
+        def add_field_expression(field, value)
+          unless field.is_a?(String)
+            raise ArgumentError, "Field must be a string: #{field}"
+          end
+
+          if field[0] == ?$
+            raise ArgumentError, "Field cannot be an operator (i.e. begin with $): #{field}"
+          end
+
+          if selector[field]
+            # We already have a restriction by the field we are trying
+            # to restrict, combine the restrictions.
+            if value.is_a?(Hash) && selector[field].is_a?(Hash) &&
+              value.keys.all? { |key|
+                key_s = key.to_s
+                key_s[0] == ?$ && !selector[field].key?(key_s)
+              }
+            then
+              # Multiple operators can be combined on the same field by
+              # adding them to the existing hash.
+              new_value = selector[field].merge(value)
+              selector.store(field, new_value)
+            else
+              add_operator_expression('$and', [{field => value}])
+            end
+          else
+            selector.store(field, value)
+          end
+
+          self
+        end
+
+        # Adds an arbitrary expression to the query.
+        #
+        # Field can either be a field name or an operator.
+        #
+        # Mutates the receiver.
+        #
+        # @param [ String ] field Field name or operator name.
+        # @param [ Object ] value Field value or operator expression.
+        #
+        # @return [ Storable ] self.
+        def add_one_expression(field, value)
+          unless field.is_a?(String)
+            raise ArgumentError, "Field must be a string: #{field}"
+          end
+
+          if field[0] == ?$
+            add_operator_expression(field, value)
+          else
+            add_field_expression(field, value)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/scopable.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   class Criteria
     module Scopable

data/lib/mongoid/document.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 require "mongoid/positional"
 require "mongoid/evolvable"
 require "mongoid/extensions"
@@ -227,9 +229,8 @@ module Mongoid
       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(:@errors, ActiveModel::Errors.new(became))
+      became.errors.instance_variable_set(:@messages, errors.instance_variable_get(:@messages))
       became.instance_variable_set(:@new_record, new_record?)
       became.instance_variable_set(:@destroyed, destroyed?)
       became.changed_attributes["_type"] = self.class.to_s

data/lib/mongoid/equality.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
 
-  # This module contains the behaviour of Mongoid's clone/dup of documents.
+  # This module contains the behavior of Mongoid's clone/dup of documents.
   module Equality
 
     # Default comparison is via the string version of the id.
@@ -63,4 +65,3 @@ module Mongoid
     end
   end
 end
-

data/lib/mongoid/errors.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 require "mongoid/errors/mongoid_error"
 require "mongoid/errors/ambiguous_relationship"
 require "mongoid/errors/callback"
+require "mongoid/errors/criteria_argument_required"
 require "mongoid/errors/document_not_destroyed"
 require "mongoid/errors/document_not_found"
 require "mongoid/errors/eager_load"

data/lib/mongoid/errors/ambiguous_relationship.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Errors
 
-    # This error is raised in case of an ambigous relationship.
+    # This error is raised in case of an ambigous association.
     #
-    # @example An ambigous relationship.
+    # @example An ambigous association.
     #   class Person
     #     include Mongoid::Document
     #

data/lib/mongoid/errors/callback.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Errors
 

data/lib/mongoid/errors/criteria_argument_required.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+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

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Errors
 
@@ -12,7 +14,7 @@ module Mongoid
       #   Callbacks.new(Post, :create!)
       #
       # @param [ Class ] document
-      # @param [ Symbol ] relation
+      # @param [ Symbol ] association
       #
       # @since 3.0.0
       def initialize(document, relation)
@@ -26,4 +28,3 @@ module Mongoid
     end
   end
 end
-

data/lib/mongoid/errors/document_not_destroyed.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Errors
 

data/lib/mongoid/errors/document_not_found.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Errors
 

data/lib/mongoid/errors/eager_load.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
 # encoding: utf-8
+
 module Mongoid
   module Errors
 
     # This error is raised when attempting to eager load a many to many
-    # relation.
+    # association.
     class EagerLoad < MongoidError
 
       # Create the new eager load error.
@@ -11,7 +13,7 @@ module Mongoid
       # @example Create the new eager load error.
       #   EagerLoad.new(:preferences)
       #
-      # @param [ Symbol ] name The name of the relation.
+      # @param [ Symbol ] name The name of the association.
       #
       # @since 2.2.0
       def initialize(name)