mongoid 7.0.3 → 7.0.8

data/lib/mongoid/criteria/queryable/extensions/numeric.rb

@@ -58,7 +58,7 @@ module Mongoid
             #
             # @since 1.0.0
             def __numeric__(object)
-              object.to_s =~ /(^[-+]?[0-9]+$)|(\.0+$)|(\.$)/ ? object.to_i : Float(object)
+              object.to_s =~ /(\A[-+]?[0-9]+\z)|(\.0+\z)|(\.\z)/ ? object.to_i : Float(object)
             end
 
             # Evolve the object to an integer.

data/lib/mongoid/criteria/queryable/extensions/regexp.rb

@@ -10,7 +10,7 @@ module Mongoid
           # Is the object a regexp?
           #
           # @example Is the object a regex?
-          #   /^[123]/.regexp?
+          #   /\A[123]/.regexp?
           #
           # @return [ true ] Always true.
           #
@@ -22,7 +22,7 @@ module Mongoid
             # Evolve the object into a regex.
             #
             # @example Evolve the object to a regex.
-            #   Regexp.evolve("^[123]")
+            #   Regexp.evolve("\A[123]")
             #
             # @param [ Regexp, String ] object The object to evolve.
             #
@@ -53,7 +53,7 @@ module Mongoid
               # Evolve the object into a raw bson regex.
               #
               # @example Evolve the object to a regex.
-              #   BSON::Regexp::Raw.evolve("^[123]")
+              #   BSON::Regexp::Raw.evolve("\\A[123]")
               #
               # @param [ BSON::Regexp::Raw, String ] object The object to evolve.
               #

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

@@ -3,16 +3,75 @@ module Mongoid
   class Criteria
     module Queryable
 
-      # The key is a representation of a field in a queryable, that can be
-      # expanded to special MongoDB selectors.
+      # Key objects represent specifications for building query expressions
+      # utilizing MongoDB selectors.
+      #
+      # Simple key-value conditions are translated directly into expression
+      # hashes by Mongoid without utilizing Key objects. For example, the
+      # following condition:
+      #
+      #   Foo.where(price: 1)
+      #
+      # ... is translated to the following simple expression:
+      #
+      #   {price: 1}
+      #
+      # More complex conditions would start involving Key objects. For example:
+      #
+      #   Foo.where(:price.gt => 1)
+      #
+      # ... causes a Key instance to be created thusly:
+      #
+      #   Key.new(:price, :__override__, '$gt')
+      #
+      # This Key instance utilizes +operator+ but not +expanded+ nor +block+.
+      # The corresponding MongoDB query expression is:
+      #
+      #    {price: {'$gt' => 1}}
+      #
+      # A yet more more complex example is the following condition:
+      #
+      #   Foo.geo_spacial(:boundary.intersects_point => [1, 10])
+      #
+      # Processing this condition will cause a Key instance to be created as
+      # follows:
+      #
+      #   Key.new(:location, :__override__, '$geoIntersects', '$geometry') do |value|
+      #     { "type" => POINT, "coordinates" => value }
+      #   end
+      #
+      # ... eventually producing the following MongoDB query expression:
+      #
+      # {
+      #   boundary: {
+      #     '$geoIntersects' => {
+      #       '$geometry' => {
+      #         type: "Point" ,
+      #         coordinates: [ 1, 10 ]
+      #       }
+      #     }
+      #   }
+      # }
+      #
+      # Key instances can be thought of as procs that map a value to the
+      # MongoDB query expression required to obtain the key's condition,
+      # given the value.
       class Key
 
-        # @attribute [r] name The name of the field.
-        # @attribute [r] block The optional block to transform values.
-        # @attribute [r] operator The MongoDB query operator.
-        # @attribute [r] expanded The MongoDB expanded query operator.
-        # @attribute [r] strategy The name of the merge strategy.
-        attr_reader :block, :name, :operator, :expanded, :strategy
+        # @return [ String | Symbol ] The name of the field.
+        attr_reader :name
+
+        # @return [ String ] The MongoDB query operator.
+        attr_reader :operator
+
+        # @return [ String ] The MongoDB expanded query operator.
+        attr_reader :expanded
+
+        # @return [ Symbol ] The name of the merge strategy.
+        attr_reader :strategy
+
+        # @return [ Proc ] The optional block to transform values.
+        attr_reader :block
 
         # Does the key equal another object?
         #

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

@@ -45,7 +45,7 @@ module Mongoid
           use(:__union__)
         end
 
-        # Reset the stratgies to nil, used after cloning.
+        # Clear the current strategy and negating flag, used after cloning.
         #
         # @example Reset the strategies.
         #   mergeable.reset_strategies!
@@ -54,7 +54,8 @@ module Mongoid
         #
         # @since 1.0.0
         def reset_strategies!
-          self.strategy, self.negating = nil, nil
+          self.strategy = nil
+          self.negating = nil
         end
 
         private
@@ -167,7 +168,7 @@ module Mongoid
         # @example Add the criterion.
         #   mergeable.__override__([ 1, 2 ], "$in")
         #
-        # @param [ Hash ] criterion The criteria.
+        # @param [ Hash | Criteria ] criterion The criteria.
         # @param [ String ] operator The MongoDB operator.
         #
         # @return [ Mergeable ] The new mergeable.
@@ -225,7 +226,7 @@ module Mongoid
         # @api private
         #
         # @example Add criterion with a strategy.
-        #   mergeable.with_strategy(:__union__, [ 1, 2, 3 ], "$in")
+        #   mergeable.with_strategy(:__union__, {field_name: [ 1, 2, 3 ]}, "$in")
         #
         # @param [ Symbol ] strategy The name of the strategy method.
         # @param [ Object ] criterion The criterion to add.

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

@@ -24,7 +24,7 @@ module Mongoid
         # @since 2.0.0
         POLYGON = "Polygon"
 
-        # @attribute [rw] negating If the next spression is negated.
+        # @attribute [rw] negating If the next expression is negated.
         # @attribute [rw] selector The query selector.
         attr_accessor :negating, :selector
 
@@ -434,7 +434,7 @@ module Mongoid
         # @since 1.0.0
         def not(*criterion)
           if criterion.empty?
-            tap { |query| query.negating = true }
+            dup.tap { |query| query.negating = true }
           else
             __override__(criterion.first, "$not")
           end
@@ -630,8 +630,6 @@ module Mongoid
         # Take the provided criterion and store it as a selection in the query
         # selector.
         #
-        # @api private
-        #
         # @example Store the selection.
         #   selectable.selection({ field: "value" })
         #
@@ -640,6 +638,7 @@ module Mongoid
         # @return [ Selectable ] The cloned selectable.
         #
         # @since 1.0.0
+        # @api private
         def selection(criterion = nil)
           clone.tap do |query|
             if criterion

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

@@ -21,9 +21,10 @@ module Mongoid
           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|
-                if in?(_key)
+                case _key
+                when '$in'
                   new_val & old_val
-                elsif nin?(_key)
+                when '$nin'
                   (old_val + new_val).uniq
                 else
                   new_val
@@ -52,10 +53,13 @@ module Mongoid
         def store(key, value)
           name, serializer = storage_pair(key)
           if multi_selection?(name)
-            super(name, evolve_multi(value))
+            store_name = name
+            store_value = evolve_multi(value)
           else
-            super(localized_key(name, serializer), evolve(serializer, value))
+            store_name = localized_key(name, serializer)
+            store_value = evolve(serializer, value)
           end
+          super(store_name, store_value)
         end
         alias :[]= :store
 
@@ -178,33 +182,7 @@ module Mongoid
         #
         # @since 1.0.0
         def multi_selection?(key)
-          key =~ /\$and|\$or|\$nor/
-        end
-
-        # Determines if the selection operator takes a list. Returns true for $in and $nin.
-        #
-        # @api private
-        #
-        # @example Does the selection operator take multiple values?
-        #   selector.multi_value?("$nin")
-        #
-        # @param [ String ] key The key to check.
-        #
-        # @return [ true, false ] If the key is $in or $nin.
-        #
-        # @since 2.1.1
-        def multi_value?(key)
-          key =~ /\$nin|\$in/
-        end
-
-        private
-
-        def in?(key)
-          key =~ /\$in/
-        end
-
-        def nin?(key)
-          key =~ /\$nin/
+          %w($and $or $nor).include?(key)
         end
       end
     end

data/lib/mongoid/extensions/hash.rb

@@ -46,9 +46,11 @@ module Mongoid
             value.each_pair do |_key, _value|
               value[_key] = (key == "$rename") ? _value.to_s : mongoize_for(key, klass, _key, _value)
             end
-            (consolidated[key] ||= {}).merge!(value)
+            consolidated[key] ||= {}
+            consolidated[key].update(value)
           else
-            (consolidated["$set"] ||= {}).merge!(key => mongoize_for(key, klass, key, value))
+            consolidated["$set"] ||= {}
+            consolidated["$set"].update(key => mongoize_for(key, klass, key, value))
           end
         end
         consolidated

data/lib/mongoid/extensions/regexp.rb

@@ -9,7 +9,7 @@ module Mongoid
         # type.
         #
         # @example Mongoize the object.
-        #   Regexp.mongoize(/^[abc]/)
+        #   Regexp.mongoize(/\A[abc]/)
         #
         # @param [ Regexp, String ] object The object to mongoize.
         #

data/lib/mongoid/extensions/string.rb

@@ -69,7 +69,7 @@ module Mongoid
       #
       # @since 2.3.1
       def mongoid_id?
-        self =~ /\A(|_)id$/
+        self =~ /\A(|_)id\z/
       end
 
       # Is the string a number? The literals "NaN", "Infinity", and "-Infinity"
@@ -82,7 +82,9 @@ module Mongoid
       #
       # @since 3.0.0
       def numeric?
-        true if Float(self) rescue (self =~ /^NaN|\-?Infinity$/)
+        !!Float(self)
+      rescue ArgumentError
+        (self =~ /\A(?:NaN|-?Infinity)\z/) == 0
       end
 
       # Get the string as a getter string.
@@ -94,7 +96,7 @@ module Mongoid
       #
       # @since 1.0.0
       def reader
-        delete("=").sub(/\_before\_type\_cast$/, '')
+        delete("=").sub(/\_before\_type\_cast\z/, '')
       end
 
       # Is this string a writer?

data/lib/mongoid/fields.rb

@@ -498,7 +498,8 @@ module Mongoid
       def create_translations_getter(name, meth)
         generated_methods.module_eval do
           re_define_method("#{meth}_translations") do
-            (attributes[name] ||= {}).with_indifferent_access
+            attributes[name] ||= {}
+            attributes[name].with_indifferent_access
           end
           alias_method :"#{meth}_t", :"#{meth}_translations"
         end

data/lib/mongoid/matchable.rb

@@ -2,6 +2,7 @@
 require "mongoid/matchable/default"
 require "mongoid/matchable/all"
 require "mongoid/matchable/and"
+require "mongoid/matchable/elem_match"
 require "mongoid/matchable/eq"
 require "mongoid/matchable/exists"
 require "mongoid/matchable/gt"
@@ -11,15 +12,14 @@ require "mongoid/matchable/lt"
 require "mongoid/matchable/lte"
 require "mongoid/matchable/ne"
 require "mongoid/matchable/nin"
-require "mongoid/matchable/or"
 require "mongoid/matchable/nor"
-require "mongoid/matchable/size"
-require "mongoid/matchable/elem_match"
+require "mongoid/matchable/or"
 require "mongoid/matchable/regexp"
+require "mongoid/matchable/size"
 
 module Mongoid
 
-  # This module contains all the behavior for ruby implementations of MongoDB
+  # This module contains all the behavior for Ruby implementations of MongoDB
   # selectors.
   #
   # @since 4.0.0
@@ -31,8 +31,8 @@ module Mongoid
     # @since 1.0.0
     MATCHERS = {
       "$all" => All,
-      "$elemMatch" => ElemMatch,
       "$and" => And,
+      "$elemMatch" => ElemMatch,
       "$eq" => Eq,
       "$exists" => Exists,
       "$gt" => Gt,
@@ -42,8 +42,8 @@ module Mongoid
       "$lte" => Lte,
       "$ne" => Ne,
       "$nin" => Nin,
-      "$or" => Or,
       "$nor" => Nor,
+      "$or" => Or,
       "$size" => Size,
     }.with_indifferent_access.freeze
 
@@ -64,13 +64,13 @@ module Mongoid
           value.each do |item|
             if item[0].to_s == "$not".freeze
               item = item[1]
-              return false if matcher(self, key, item)._matches?(item)
+              return false if matcher(key, item)._matches?(item)
             else
-              return false unless matcher(self, key, Hash[*item])._matches?(Hash[*item])
+              return false unless matcher(key, Hash[*item])._matches?(Hash[*item])
             end
           end
         else
-          return false unless matcher(self, key, value)._matches?(value)
+          return false unless matcher(key, value)._matches?(value)
         end
       end
       true
@@ -81,20 +81,18 @@ module Mongoid
     # Get the matcher for the supplied key and value. Will determine the class
     # name from the key.
     #
-    # @api private
-    #
     # @example Get the matcher.
     #   document.matcher(:title, { "$in" => [ "test" ] })
     #
-    # @param [ Document ] document The document to check.
     # @param [ Symbol, String ] key The field name.
     # @param [ Object, Hash ] value The value or selector.
     #
     # @return [ Matcher ] The matcher.
     #
     # @since 2.0.0.rc.7
-    def matcher(document, key, value)
-      Matchable.matcher(document, key, value)
+    # @api private
+    def matcher(key, value)
+      Matchable.matcher(self, key, value)
     end
 
     class << self
@@ -105,7 +103,7 @@ module Mongoid
       # @api private
       #
       # @example Get the matcher.
-      #   document.matcher(:title, { "$in" => [ "test" ] })
+      #   Matchable.matcher(document, :title, { "$in" => [ "test" ] })
       #
       # @param [ Document ] document The document to check.
       # @param [ Symbol, String ] key The field name.
@@ -149,6 +147,7 @@ module Mongoid
       # @return [ Object ] The value of the attribute.
       #
       # @since 2.2.1
+      # @api private
       def extract_attribute(document, key)
         if (key_string = key.to_s) =~ /.+\..+/
           key_string.split('.').inject(document.send(:as_attributes)) do |_attribs, _key|

data/lib/mongoid/matchable/all.rb

@@ -10,11 +10,12 @@ module Mongoid
       # @example Do the values match?
       #   matcher._matches?({ :key => 10 })
       #
-      # @param [ Hash ] value The values to check.
+      # @param [ Hash ] condition The condition to evaluate. This must be
+      #   a one-element hash like {'$gt' => 1}.
       #
       # @return [ true, false ] If the values match.
-      def _matches?(value)
-        first = first(value)
+      def _matches?(condition)
+        first = condition_value(condition)
         return false if first.is_a?(Array) && first.empty?
 
         attribute_array = Array.wrap(@attribute)

data/lib/mongoid/matchable/default.rb

@@ -20,52 +20,99 @@ module Mongoid
         @attribute, @document = attribute, document
       end
 
-      # Return true if the attribute and value are equal, or if it is an array
-      # if the value is included.
+      # Checks whether the attribute matches the value, using the default
+      # MongoDB matching logic (i.e., when no operator is specified in the
+      # criteria).
       #
-      # @example Does this value match?
-      #   default._matches?("value")
+      # If attribute and value are both of basic types like string or number,
+      # this method returns true if and only if the attribute equals the value.
       #
-      # @param [ Object ] value The value to check if it matches.
+      # Value can also be of a type like Regexp or Range which defines
+      # more complex matching/inclusion behavior via the === operator.
+      # If so, and attribute is still of a basic type like string or number,
+      # this method returns true if and only if the value's === operator
+      # returns true for the attribute. For example, this method returns true
+      # if attribute is a string and value is a Regexp and attribute matches
+      # the value, of if attribute is a number and value is a Range and
+      # the value includes the attribute.
       #
-      # @return [ true, false ] True if matches, false if not.
+      # If attribute is an array and value is not an array, the checks just
+      # described (i.e. the === operator invocation) are performed on each item
+      # of the attribute array. If any of the items in the attribute match
+      # the value according to the value type's === operator, this method
+      # returns true.
+      #
+      # If attribute and value are both arrays, this method returns true if and
+      # only if the arrays are equal (including the order of the elements).
+      #
+      # @param [ Object ] value The value to check.
+      #
+      # @return [ true, false ] True if attribute matches the value, false if not.
       #
       # @since 1.0.0
       def _matches?(value)
-        attribute.is_a?(Array) && !value.is_a?(Array) ? attribute.any? { |_attribute| value === _attribute } : value === attribute
+        if attribute.is_a?(Array) && !value.is_a?(Array)
+          attribute.any? { |_attribute| value === _attribute }
+        else
+          value === attribute
+        end
       end
 
       protected
 
-      # Convenience method for getting the first value in a hash.
+      # Given a condition, which is a one-element hash consisting of an
+      # operator and a value like {'$gt' => 1}, return the value.
       #
-      # @example Get the first value.
-      #   matcher.first(:test => "value")
+      # @example Get the condition value.
+      #   matcher.condition_value({'$gt' => 1})
+      #   # => 1
       #
-      # @param [ Hash ] hash The has to pull from.
+      # @param [ Hash ] condition The condition.
       #
-      # @return [ Object ] The first value.
+      # @return [ Object ] The value of the condition.
       #
       # @since 1.0.0
-      def first(hash)
-        hash.values.first
+      def condition_value(condition)
+        unless condition.is_a?(Hash)
+          raise ArgumentError, 'Condition must be a hash'
+        end
+
+        unless condition.length == 1
+          raise ArgumentError, 'Condition must have one element'
+        end
+
+        condition.values.first
       end
 
-      # If object exists then compare the two, otherwise return false
+      # Determines whether the attribute value stored in this matcher
+      # satisfies the provided condition using the provided operator.
+      #
+      # For example, given an instance of Gt matcher with the @attribute of
+      # 2, the matcher is set up to answer whether the attribute is
+      # greater than some input value. This input value is provided in
+      # the condition, which could be {"$gt" => 1}, and the operator is
+      # provided (somewhat in a duplicate fashion) in the operator argument,
+      # in this case :>.
       #
-      # @example Determine if we can compare.
-      #   matcher.determine("test", "$in")
+      # @example
+      #   matcher = Matchable::Gt.new(2)
+      #   matcher.determine({'$gt' => 1}, :>)
+      #   # => true
       #
-      # @param [ Object ] value The value to compare with.
-      # @param [ Symbol, String ] operator The comparison operation.
+      # @param [ Hash ] condition The condition to evaluate. This must be
+      #   a one-element hash; the key is ignored, and the value is passed
+      #   as the argument to the operator.
+      # @param [ Symbol, String ] operator The comparison operator or method.
+      #   The operator is invoked on the attribute stored in the matcher
+      #   instance.
       #
-      # @return [ true, false ] The comparison or false.
+      # @return [ true, false ] Result of condition evaluation.
       #
       # @since 1.0.0
-      def determine(value, operator)
-        attribute.__array__.any? {|attr|
-          attr ? attr.send(operator, first(value)) : false
-        }
+      def determine(condition, operator)
+        attribute.__array__.any? do |attr|
+          attr && attr.send(operator, condition_value(condition))
+        end
       end
     end
   end