mongoid 7.0.10 → 7.4.0

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

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
   class Criteria
     module Queryable
@@ -15,8 +16,6 @@ module Mongoid
         # @param [ Hash, Selector ] other The object to merge in.
         #
         # @return [ Selector ] The selector.
-        #
-        # @since 1.0.0
         def merge!(other)
           other.each_pair do |key, value|
             if value.is_a?(Hash) && self[key.to_s].is_a?(Hash)
@@ -48,8 +47,6 @@ module Mongoid
         # @param [ Object ] value The value to add.
         #
         # @return [ Object ] The stored object.
-        #
-        # @since 1.0.0
         def store(key, value)
           name, serializer = storage_pair(key)
           if multi_selection?(name)
@@ -69,8 +66,6 @@ module Mongoid
         #   selector.to_pipeline
         #
         # @return [ Array<Hash> ] The pipeline entry for the selector.
-        #
-        # @since 2.0.0
         def to_pipeline
           pipeline = []
           pipeline.push({ "$match" => self }) unless empty?
@@ -82,22 +77,47 @@ module Mongoid
         # Evolves a multi-list selection, like an $and or $or criterion, and
         # performs the necessary serialization.
         #
-        # @api private
-        #
         # @example Evolve the multi-selection.
         #   selector.evolve_multi([{ field: "value" }])
         #
-        # @param [ Array<Hash> ] value The multi-selection.
+        # @param [ Array<Hash> ] specs The multi-selection.
         #
         # @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)
+        # @api private
+        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)
+                evolved_value = key.transform_value(evolved_value)
+              end
+
+              [ final_key, evolved_value ]
             end]
           end.uniq
         end
@@ -113,8 +133,6 @@ module Mongoid
         # @param [ Object ] value The value to serialize.
         #
         # @return [ Object ] The serialized object.
-        #
-        # @since 1.0.0
         def evolve(serializer, value)
           case value
           when Hash
@@ -137,8 +155,6 @@ module Mongoid
         # @param [ Array<Object> ] value The array to serialize.
         #
         # @return [ Object ] The serialized array.
-        #
-        # @since 1.0.0
         def evolve_array(serializer, value)
           value.map do |_value|
             evolve(serializer, _value)
@@ -156,8 +172,6 @@ module Mongoid
         # @param [ Hash ] value The hash to serialize.
         #
         # @return [ Object ] The serialized hash.
-        #
-        # @since 1.0.0
         def evolve_hash(serializer, value)
           value.each_pair do |operator, _value|
             if operator =~ /exists|type|size/
@@ -179,8 +193,6 @@ module Mongoid
         # @param [ String ] key The key to check.
         #
         # @return [ true, false ] If the key is for a multi-select.
-        #
-        # @since 1.0.0
         def multi_selection?(key)
           %w($and $or $nor).include?(key)
         end

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

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
   class Criteria
     module Queryable
@@ -16,8 +17,6 @@ module Mongoid
         #   smash.__deep_copy__
         #
         # @return [ Smash ] The copied hash.
-        #
-        # @since 1.0.0
         def __deep_copy__
           self.class.new(aliases, serializers) do |copy|
             each_pair do |key, value|
@@ -37,8 +36,6 @@ module Mongoid
         #   responsible for serializing values. The keys of the hash must be
         #   strings that match the field name, and the values must respond to
         #   #localized? and #evolve(object).
-        #
-        # @since 1.0.0
         def initialize(aliases = {}, serializers = {})
           @aliases, @serializers = aliases, serializers
           yield(self) if block_given?
@@ -52,8 +49,6 @@ module Mongoid
         # @param [ String ] key The key.
         #
         # @return [ Object ] The found object.
-        #
-        # @since 2.0.0
         def [](key)
           fetch(aliases[key]) { super }
         end
@@ -73,8 +68,6 @@ module Mongoid
         # @param [ Object ] serializer The optional field serializer.
         #
         # @return [ String ] The normalized key.
-        #
-        # @since 1.0.0
         def localized_key(name, serializer)
           serializer && serializer.localized? ? "#{name}.#{::I18n.locale}" : name
         end
@@ -91,8 +84,6 @@ module Mongoid
         #
         # @return [ Array<String, Object> ] The name of the db field and
         #   serializer.
-        #
-        # @since 1.0.0
         def storage_pair(key)
           field = key.to_s
           name = aliases[field] || field

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

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+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 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.
+        #
+        # +value+ can be of any type, it is written into the selector unchanged.
+        #
+        # 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.start_with?('$')
+            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.start_with?('$') && !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)
+            elsif selector[field] != value
+              add_operator_expression('$and', [{field => value}])
+            end
+          else
+            selector.store(field, value)
+          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 MQL, $not is a field-level operator and not a query-level one,
+        # and therefore $not is not handled by this method.
+        #
+        # 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 consists of a single condition which is the specified
+        # operator (on the top level), the new condition given in op_expr is
+        # added to the existing conditions for the specified operator.
+        # For example, if the selector is currently:
+        #
+        #     {'$or' => [{'hello' => 'world'}]}
+        #
+        # ... and operator is '$or' and op_expr is `[{'test' => 123'}]`,
+        # the resulting selector will be:
+        #
+        #     {'$or' => [{'hello' => 'world'}, {'test' => 123}]}
+        #
+        # This method always adds the new conditions as additional requirements;
+        # in other words, it does not implement the ActiveRecord or/nor behavior
+        # where the receiver becomes one of the operands. It is expected that
+        # code upstream of this method implements such behavior.
+        #
+        # 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).
+        # Such simplification is also expected to have already been performed
+        # by the upstream code.
+        #
+        # This method mutates the receiver.
+        #
+        # @param [ String ] operator The operator to add.
+        # @param [ Array<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 Errors::InvalidQuery, "#{operator} argument must be an array: #{Errors::InvalidQuery.truncate_expr(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.
+            if !Mongoid.broken_and && current_value = selector[operator]
+              new_value = current_value + op_expr
+              selector.store(operator, new_value)
+            else
+              selector.store(operator, op_expr)
+            end
+          else
+            # Other operators need to be added separately
+            if selector[operator]
+              add_logical_operator_expression('$and', [operator => op_expr])
+            else
+              selector.store(operator, op_expr)
+            end
+          end
+
+          self
+        end
+
+        # 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}+.
+        #
+        # The operator value can be of any type.
+        #
+        # 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 [ Object ] 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.start_with?('$')
+            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 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.start_with?('$')
+            add_operator_expression(field, value)
+          else
+            add_field_expression(field, value)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/queryable.rb

@@ -1,6 +1,7 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require "mongoid/criteria/queryable/expandable"
 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"
@@ -11,6 +12,7 @@ require "mongoid/criteria/queryable/optional"
 require "mongoid/criteria/queryable/options"
 require "mongoid/criteria/queryable/selectable"
 require "mongoid/criteria/queryable/selector"
+require "mongoid/criteria/queryable/storable"
 
 module Mongoid
   class Criteria
@@ -23,6 +25,8 @@ module Mongoid
     #     include Queryable
     #   end
     module Queryable
+      include Storable
+      include Expandable
       include Mergeable
       include Aggregable
       include Selectable
@@ -42,15 +46,13 @@ module Mongoid
       # @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.
+      # is provided for objects that need additional behavior.
       #
       # @example Initialize the queryable.
       #   Queryable.new
@@ -58,8 +60,6 @@ module Mongoid
       # @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)
@@ -75,8 +75,6 @@ module Mongoid
       #   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__

data/lib/mongoid/criteria/scopable.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
   class Criteria
     module Scopable
@@ -9,8 +10,6 @@ module Mongoid
       #   criteria.apply_default_scope
       #
       # @return [ Criteria ] The criteria.
-      #
-      # @since 3.0.0
       def apply_default_scope
         klass.without_default_scope do
           merge!(klass.default_scoping.call)
@@ -18,6 +17,31 @@ module Mongoid
         self.scoping_options = true, false
       end
 
+      # Applies a scope to the current criteria.
+      #
+      # This method does not modify the receiver but it may return a new
+      # object or the receiver depending on the argument: if the +scope+
+      # argument is nil, the receiver is returned without modification,
+      # otherwise a new criteria object is returned.
+      #
+      # @param [ Proc | Symbol | Criteria | nil ] scope The scope to apply.
+      #
+      # @return [ Criteria ] The criteria with the scope applied.
+      #
+      # @api private
+      def apply_scope(scope)
+        case scope
+        when Proc
+          instance_exec(&scope)
+        when Symbol
+          send(scope)
+        when Criteria
+          merge(scope)
+        else
+          self
+        end
+      end
+
       # Given another criteria, remove the other criteria's scoping from this
       # criteria.
       #
@@ -27,8 +51,6 @@ module Mongoid
       # @param [ Criteria ] other The other criteria.
       #
       # @return [ Criteria ] The criteria with scoping removed.
-      #
-      # @since 3.0.0
       def remove_scoping(other)
         if other
           reject_matching(other, :selector, :options)
@@ -47,8 +69,6 @@ module Mongoid
       # @param [ Hash ] options Additional query options.
       #
       # @return [ Criteria ] The scoped criteria.
-      #
-      # @since 3.0.0
       def scoped(options = nil)
         crit = clone
         crit.options.merge!(options || {})
@@ -64,8 +84,6 @@ module Mongoid
       #   criteria.scoped?
       #
       # @return [ true, false ] If the default scope is applied.
-      #
-      # @since 3.0.0
       def scoped?
         !!(defined?(@scoped) ? @scoped : nil)
       end
@@ -76,8 +94,6 @@ module Mongoid
       #   criteria.unscoped
       #
       # @return [ Criteria ] The unscoped criteria.
-      #
-      # @since 3.0.0
       def unscoped
         crit = clone
         unless unscoped?
@@ -93,8 +109,6 @@ module Mongoid
       #   criteria.unscoped?
       #
       # @return [ true, false ] If the criteria is force unscoped.
-      #
-      # @since 3.0.0
       def unscoped?
         !!(defined?(@unscoped) ? @unscoped : nil)
       end
@@ -105,8 +119,6 @@ module Mongoid
       #   criteria.scoping_options
       #
       # @return [ Array ] Scoped, unscoped.
-      #
-      # @since 3.0.0
       def scoping_options
         [ (defined?(@scoped) ? @scoped : nil), (defined?(@unscoped) ? @unscoped : nil) ]
       end
@@ -119,8 +131,6 @@ module Mongoid
       # @param [ Array ] options Scoped, unscoped.
       #
       # @return [ Array ] The new scoping options.
-      #
-      # @since 3.0.0
       def scoping_options=(options)
         @scoped, @unscoped = options
       end
@@ -134,8 +144,6 @@ module Mongoid
       #   criteria.with_default_scope
       #
       # @return [ Criteria ] The criteria.
-      #
-      # @since 3.0.0
       def with_default_scope
         crit = clone
         if klass.default_scopable? && !unscoped? && !scoped?