mongoid 5.4.1 → 7.4.0

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

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module Mongoid
+  class Criteria
+    module Queryable
+
+      # The selector is a special kind of hash that knows how to serialize values
+      # coming into it as well as being alias and locale aware for key names.
+      class Selector < Smash
+
+        # Merges another selector into this one.
+        #
+        # @example Merge in another selector.
+        #   selector.merge!(name: "test")
+        #
+        # @param [ Hash, Selector ] other The object to merge in.
+        #
+        # @return [ Selector ] The selector.
+        def merge!(other)
+          other.each_pair do |key, value|
+            if value.is_a?(Hash) && self[key.to_s].is_a?(Hash)
+              value = self[key.to_s].merge(value) do |_key, old_val, new_val|
+                case _key
+                when '$in'
+                  new_val & old_val
+                when '$nin'
+                  (old_val + new_val).uniq
+                else
+                  new_val
+                end
+              end
+            end
+            if multi_selection?(key)
+              value = (self[key.to_s] || []).concat(value)
+            end
+            store(key, value)
+          end
+        end
+
+        # Store the value in the selector for the provided key. The selector will
+        # handle all necessary serialization and localization in this step.
+        #
+        # @example Store a value in the selector.
+        #   selector.store(:key, "testing")
+        #
+        # @param [ String, Symbol ] key The name of the attribute.
+        # @param [ Object ] value The value to add.
+        #
+        # @return [ Object ] The stored object.
+        def store(key, value)
+          name, serializer = storage_pair(key)
+          if multi_selection?(name)
+            store_name = name
+            store_value = evolve_multi(value)
+          else
+            store_name = localized_key(name, serializer)
+            store_value = evolve(serializer, value)
+          end
+          super(store_name, store_value)
+        end
+        alias :[]= :store
+
+        # Convert the selector to an aggregation pipeline entry.
+        #
+        # @example Convert the selector to a pipeline.
+        #   selector.to_pipeline
+        #
+        # @return [ Array<Hash> ] The pipeline entry for the selector.
+        def to_pipeline
+          pipeline = []
+          pipeline.push({ "$match" => self }) unless empty?
+          pipeline
+        end
+
+        private
+
+        # Evolves a multi-list selection, like an $and or $or criterion, and
+        # performs the necessary serialization.
+        #
+        # @example Evolve the multi-selection.
+        #   selector.evolve_multi([{ field: "value" }])
+        #
+        # @param [ Array<Hash> ] specs The multi-selection.
+        #
+        # @return [ Array<Hash> ] The serialized values.
+        #
+        # @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)
+              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
+
+        # Evolve a single key selection with various types of values.
+        #
+        # @api private
+        #
+        # @example Evolve a simple selection.
+        #   selector.evolve(field, 5)
+        #
+        # @param [ Object ] serializer The optional serializer for the field.
+        # @param [ Object ] value The value to serialize.
+        #
+        # @return [ Object ] The serialized object.
+        def evolve(serializer, value)
+          case value
+          when Hash
+            evolve_hash(serializer, value)
+          when Array
+            evolve_array(serializer, value)
+          else
+            (serializer || value.class).evolve(value)
+          end
+        end
+
+        # Evolve a single key selection with array values.
+        #
+        # @api private
+        #
+        # @example Evolve a simple selection.
+        #   selector.evolve(field, [ 1, 2, 3 ])
+        #
+        # @param [ Object ] serializer The optional serializer for the field.
+        # @param [ Array<Object> ] value The array to serialize.
+        #
+        # @return [ Object ] The serialized array.
+        def evolve_array(serializer, value)
+          value.map do |_value|
+            evolve(serializer, _value)
+          end
+        end
+
+        # Evolve a single key selection with hash values.
+        #
+        # @api private
+        #
+        # @example Evolve a simple selection.
+        #   selector.evolve(field, { "$gt" => 5 })
+        #
+        # @param [ Object ] serializer The optional serializer for the field.
+        # @param [ Hash ] value The hash to serialize.
+        #
+        # @return [ Object ] The serialized hash.
+        def evolve_hash(serializer, value)
+          value.each_pair do |operator, _value|
+            if operator =~ /exists|type|size/
+              value[operator] = _value
+            else
+              value[operator] = evolve(serializer, _value)
+            end
+          end
+        end
+
+        # Determines if the selection is a multi-select, like an $and or $or or $nor
+        # selection.
+        #
+        # @api private
+        #
+        # @example Is the selection a multi-select?
+        #   selector.multi_selection?("$and")
+        #
+        # @param [ String ] key The key to check.
+        #
+        # @return [ true, false ] If the key is for a multi-select.
+        def multi_selection?(key)
+          %w($and $or $nor).include?(key)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Mongoid
+  class Criteria
+    module Queryable
+
+      # This is a smart hash for use with options and selectors.
+      class Smash < Hash
+
+        # @attribute [r] aliases The aliases.
+        # @attribute [r] serializers The serializers.
+        attr_reader :aliases, :serializers
+
+        # Perform a deep copy of the smash.
+        #
+        # @example Perform a deep copy.
+        #   smash.__deep_copy__
+        #
+        # @return [ Smash ] The copied hash.
+        def __deep_copy__
+          self.class.new(aliases, serializers) do |copy|
+            each_pair do |key, value|
+              copy.store(key, value.__deep_copy__)
+            end
+          end
+        end
+
+        # Initialize the new selector.
+        #
+        # @example Initialize the new selector.
+        #   Queryable::Smash.new(aliases, serializers)
+        #
+        # @param [ Hash ] aliases A hash of mappings from aliases to the actual
+        #   field names in the database.
+        # @param [ Hash ] serializers An optional hash of objects that are
+        #   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).
+        def initialize(aliases = {}, serializers = {})
+          @aliases, @serializers = aliases, serializers
+          yield(self) if block_given?
+        end
+
+        # Get an item from the smart hash by the provided key.
+        #
+        # @example Get an item by the key.
+        #   smash["test"]
+        #
+        # @param [ String ] key The key.
+        #
+        # @return [ Object ] The found object.
+        def [](key)
+          fetch(aliases[key]) { super }
+        end
+
+        private
+
+        # Get the localized value for the key if needed. If the field uses
+        # localization the current locale will be appended to the key in
+        # MongoDB dot notation.
+        #
+        # @api private
+        #
+        # @example Get the normalized key name.
+        #   smash.localized_key("field", serializer)
+        #
+        # @param [ String ] name The name of the field.
+        # @param [ Object ] serializer The optional field serializer.
+        #
+        # @return [ String ] The normalized key.
+        def localized_key(name, serializer)
+          serializer && serializer.localized? ? "#{name}.#{::I18n.locale}" : name
+        end
+
+        # Get the pair of objects needed to store the value in a hash by the
+        # provided key. This is the database field name and the serializer.
+        #
+        # @api private
+        #
+        # @example Get the name and serializer.
+        #   smash.storage_pair("id")
+        #
+        # @param [ Symbol, String ] key The key provided to the selection.
+        #
+        # @return [ Array<String, Object> ] The name of the db field and
+        #   serializer.
+        def storage_pair(key)
+          field = key.to_s
+          name = aliases[field] || field
+          [ name, serializers[name] ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "mongoid/criteria/queryable/expandable"
+require "mongoid/criteria/queryable/extensions"
+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"
+require "mongoid/criteria/queryable/storable"
+
+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 Storable
+      include Expandable
+      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.
+      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 behavior.
+      #
+      # @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.
+      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)
+        @aggregating = nil
+        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.
+      def initialize_copy(other)
+        @options = other.options.__deep_copy__
+        @selector = other.selector.__deep_copy__
+        @pipeline = other.pipeline.__deep_copy__
+      end
+    end
+  end
+end