mongoid 7.1.1 → 7.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b90b3442fbb22055d692fca89eb33e90868e45588812f1975926dee5a85d8b10
-  data.tar.gz: d9c2a5eaf30d5ca34a365be11b648efc8932a7cda1b29fd8982847cf9cb528cd
+  metadata.gz: fd29f8f1d696ba937654fcd72eb3669ac9ba501465828b7eba0f7b707e606f5b
+  data.tar.gz: c9f4a8dbb8a105a7e596019760d100913ddd008972b34f7595674ad7c49d4159
 SHA512:
-  metadata.gz: ca1480e9cbd438a8905ef4d8f1e9ac59e66ee6436b0017f40c350de6421dd5f99a8a96c1bfa31bb0291738ad97bdad5ce18ee2ccc60a0cea2d91f1795abd5a8c
-  data.tar.gz: a3f7da9b676f022dc9bf48199eeb34f68fc14e2c076b539a81149401a6b1b81914f96ba21daca7a392b40a5bf5ed8ef9b76d7499033b786b530d161a1e3bb29b
+  metadata.gz: 0e00e8d47e7af2fec23380035bcdbd0badc438552aed52aa0f462e246274e7f77220190d99bb6a83a1a90b8e0a41d19103c94fa454382635a2c193d52260c322
+  data.tar.gz: 709300f2570059e460cd341cbaffe7da6328df142825bb726b65cbc377d6ba5129cf7fc973a40fc2de10a50307f49ac0f71db98b0edbb8a65c9cb33910e9d66f

data/lib/mongoid/association/embedded/embeds_many.rb

@@ -200,7 +200,8 @@ module Mongoid
         def determine_inverses(other)
           matches = relation_class.relations.values.select do |rel|
             relation_complements.include?(rel.class) &&
-                rel.relation_class_name == inverse_class_name
+              # https://jira.mongodb.org/browse/MONGOID-4882
+              rel.relation_class_name.sub(/\A::/, '') == inverse_class_name
           end
           if matches.size > 1
             raise Errors::AmbiguousRelationship.new(relation_class, @owner_class, name, matches)

data/lib/mongoid/association/embedded/embeds_one.rb

@@ -162,7 +162,8 @@ module Mongoid
         def determine_inverses(other)
           matches = relation_class.relations.values.select do |rel|
             relation_complements.include?(rel.class) &&
-                rel.relation_class_name == inverse_class_name
+              # https://jira.mongodb.org/browse/MONGOID-4882
+              rel.relation_class_name.sub(/\A::/, '') == inverse_class_name
 
           end
           if matches.size > 1

data/lib/mongoid/association/proxy.rb

@@ -16,7 +16,7 @@ module Mongoid
       # We undefine most methods to get them sent through to the target.
       instance_methods.each do |method|
         undef_method(method) unless
-          method =~ /^(__.*|send|object_id|equal\?|respond_to\?|tap|public_send|extend_proxy|extend_proxies)$/
+          method =~ /\A(__.*|send|object_id|equal\?|respond_to\?|tap|public_send|extend_proxy|extend_proxies)\z/
       end
 
       include Threaded::Lifecycle

data/lib/mongoid/atomic.rb

@@ -38,7 +38,9 @@ module Mongoid
     # @since 2.2.0
     def add_atomic_pull(document)
       document.flagged_for_destroy = true
-      (delayed_atomic_pulls[document.association_name.to_s] ||= []).push(document)
+      key = document.association_name.to_s
+      delayed_atomic_pulls[key] ||= []
+      delayed_atomic_pulls[key] << document
     end
 
     # Add an atomic unset for the document.
@@ -53,7 +55,9 @@ module Mongoid
     # @since 3.0.0
     def add_atomic_unset(document)
       document.flagged_for_destroy = true
-      (delayed_atomic_unsets[document.association_name.to_s] ||= []).push(document)
+      key = document.association_name.to_s
+      delayed_atomic_unsets[key] ||= []
+      delayed_atomic_unsets[key] << document
     end
 
     # Returns path of the attribute for modification
@@ -191,7 +195,13 @@ module Mongoid
     #
     # @since 2.1.0
     def atomic_paths
-      @atomic_paths ||= _association ? _association.path(self) : Atomic::Paths::Root.new(self)
+      @atomic_paths ||= begin
+        if _association
+          _association.path(self)
+        else
+          Atomic::Paths::Root.new(self)
+        end
+      end
     end
 
     # Get all the attributes that need to be pulled.

data/lib/mongoid/criteria.rb

@@ -450,7 +450,13 @@ module Mongoid
     #
     # @since 3.1.0
     def for_js(javascript, scope = {})
-      js_query(BSON::CodeWithScope.new(javascript, scope))
+      code = if scope.empty?
+        # CodeWithScope is not supported for $where as of MongoDB 4.4
+        BSON::Code.new(javascript)
+      else
+        BSON::CodeWithScope.new(javascript, scope)
+      end
+      js_query(code)
     end
 
     private

data/lib/mongoid/criteria/modifiable.rb

@@ -74,7 +74,8 @@ module Mongoid
       # @since 5.1.0
       def create_with(attrs = {})
         tap do
-          (@create_attrs ||= {}).merge!(attrs)
+          @create_attrs ||= {}
+          @create_attrs.update(attrs)
         end
       end
 

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

@@ -60,7 +60,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

@@ -12,7 +12,7 @@ module Mongoid
           # Is the object a regexp?
           #
           # @example Is the object a regex?
-          #   /^[123]/.regexp?
+          #   /\A[123]/.regexp?
           #
           # @return [ true ] Always true.
           #
@@ -24,7 +24,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.
             #
@@ -55,7 +55,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/mergeable.rb

@@ -163,7 +163,7 @@ module Mongoid
               if expr.is_a?(Selectable)
                 expr = expr.selector
               end
-              normalized = _mongoid_normalize_expr(expr)
+              normalized = _mongoid_expand_keys(expr)
               sel.store(operator, result_criteria.push(normalized))
             end
           end
@@ -190,9 +190,9 @@ module Mongoid
             sel = query.selector
             _mongoid_flatten_arrays(criteria).each do |criterion|
               if criterion.is_a?(Selectable)
-                expr = _mongoid_normalize_expr(criterion.selector)
+                expr = _mongoid_expand_keys(criterion.selector)
               else
-                expr = criterion
+                expr = _mongoid_expand_keys(criterion)
               end
               if sel.empty?
                 sel.store(operator, [expr])
@@ -212,7 +212,7 @@ module Mongoid
         # explicitly only expands Array objects and Array subclasses.
         private def _mongoid_flatten_arrays(array)
           out = []
-          pending = array
+          pending = array.dup
           until pending.empty?
             item = pending.shift
             if item.nil?
@@ -226,11 +226,78 @@ module Mongoid
           out
         end
 
-        # @api private
-        private def _mongoid_normalize_expr(expr)
-          expr.inject({}) do |hash, (field, value)|
-            hash.merge!(field.__expr_part__(value.__expand_complex__))
+        # Takes a criteria hash and expands Key objects into hashes containing
+        # MQL corresponding to said key objects.
+        #
+        # Ruby does not permit multiple symbol operators. For example,
+        # {:foo.gt => 1, :foo.gt => 2} is collapsed to {:foo.gt => 2} by the
+        # language. Therefore this method never has to deal with multiple
+        # identical operators.
+        #
+        # Similarly, this method should never need to expand a literal value
+        # and an operator at the same time.
+        #
+        # @param [ Hash ] Criteria including Key instances.
+        #
+        # @return [ Hash ] Expanded criteria.
+        private def _mongoid_expand_keys(expr)
+          unless expr.is_a?(Hash)
+            raise ArgumentError, 'Argument must be a Hash'
+          end
+
+          result = {}
+          expr.each do |field, value|
+            field.__expr_part__(value.__expand_complex__).each do |k, v|
+              if result[k]
+                if result[k].is_a?(Hash)
+                  # Existing value is an operator.
+                  # If new value is also an operator, ensure there are no
+                  # conflicts and add
+                  if v.is_a?(Hash)
+                    # The new value is also an operator.
+                    # If there are no conflicts, combine the hashes, otherwise
+                    # add new conditions to top level with $and.
+                    if (v.keys & result[k].keys).empty?
+                      result[k].update(v)
+                    else
+                      raise NotImplementedError, 'Ruby does not allow same symbol operator with different values'
+                      result['$and'] ||= []
+                      result['$and'] << {k => v}
+                    end
+                  else
+                    # The new value is a simple value.
+                    # If there isn't an $eq operator already in the query,
+                    # transform the new value into an $eq operator and add it
+                    # to the existing hash. Otherwise add the new condition
+                    # with $and to the top level.
+                    if result[k].key?('$eq')
+                      raise NotImplementedError, 'Ruby does not allow same symbol operator with different values'
+                      result['$and'] ||= []
+                      result['$and'] << {k => v}
+                    else
+                      result[k].update('$eq' => v)
+                    end
+                  end
+                else
+                  # Existing value is a simple value.
+                  # If we are adding an operator, and the operator is not $eq,
+                  # convert existing value into $eq and add the new operator
+                  # to the same hash. Otherwise add the new condition with $and
+                  # to the top level.
+                  if v.is_a?(Hash) && !v.key?('$eq')
+                    result[k] = {'$eq' => result[k]}.update(v)
+                  else
+                    raise NotImplementedError, 'Ruby does not allow same symbol operator with different values'
+                    result['$and'] ||= []
+                    result['$and'] << {k => v}
+                  end
+                end
+              else
+                result[k] = v
+              end
+            end
           end
+          result
         end
 
         # Adds the criterion to the existing selection.

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

@@ -89,11 +89,27 @@ module Mongoid
             if new_s.is_a?(Selectable)
               new_s = new_s.selector
             end
-            normalized = _mongoid_normalize_expr(new_s)
+            normalized = _mongoid_expand_keys(new_s)
             normalized.each do |k, v|
               k = k.to_s
               if c.selector[k]
-                c = c.send(:__multi__, [k => v], '$and')
+                # There is already a condition on k.
+                # If v is an operator, and all existing conditions are
+                # also operators, and v isn't present in existing conditions,
+                # we can add to existing conditions.
+                # Otherwise use $and.
+                if v.is_a?(Hash) &&
+                  v.length == 1 &&
+                  (new_k = v.keys.first).start_with?('$') &&
+                  (existing_kv = c.selector[k]).is_a?(Hash) &&
+                  !existing_kv.key?(new_k) &&
+                  existing_kv.keys.all? { |sub_k| sub_k.start_with?('$') }
+                then
+                  merged_v = c.selector[k].merge(v)
+                  c.selector.store(k, merged_v)
+                else
+                  c = c.send(:__multi__, [k => v], '$and')
+                end
               else
                 c.selector.store(k, v)
               end
@@ -567,17 +583,21 @@ module Mongoid
               if new_s.is_a?(Selectable)
                 new_s = new_s.selector
               end
-              new_s.each do |k, v|
+              _mongoid_expand_keys(new_s).each do |k, v|
                 k = k.to_s
                 if c.selector[k] || k[0] == ?$
                   c = c.send(:__multi__, [{'$nor' => [{k => v}]}], '$and')
                 else
-                  if v.is_a?(Regexp)
-                    negated_operator = '$not'
+                  if v.is_a?(Hash)
+                    c = c.send(:__multi__, [{'$nor' => [{k => v}]}], '$and')
                   else
-                    negated_operator = '$ne'
+                    if v.is_a?(Regexp)
+                      negated_operator = '$not'
+                    else
+                      negated_operator = '$ne'
+                    end
+                    c = c.send(:__override__, {k => v}, negated_operator)
                   end
-                  c = c.send(:__override__, {k => v}, negated_operator)
                 end
               end
               c
@@ -665,7 +685,7 @@ module Mongoid
             # and add the result to self.
             exprs = criteria.map do |criterion|
               if criterion.is_a?(Selectable)
-                _mongoid_normalize_expr(criterion.selector)
+                _mongoid_expand_keys(criterion.selector)
               else
                 Hash[criterion.map do |k, v|
                   if k.is_a?(Symbol)

data/lib/mongoid/extensions/hash.rb

@@ -48,9 +48,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

@@ -11,7 +11,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/fields.rb

@@ -500,7 +500,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/regexp.rb

@@ -10,8 +10,8 @@ module Mongoid
       # Does the supplied query match the attribute?
       #
       # @example Does this match?
-      #   matcher._matches?(/^Em/)
-      #   matcher._matches?(BSON::Regex::Raw.new("^Em"))
+      #   matcher._matches?(/\AEm/)
+      #   matcher._matches?(BSON::Regex::Raw.new("\\AEm"))
       #
       # @param [ BSON::Regexp::Raw, Regexp ] regexp The regular expression object.
       #

data/lib/mongoid/persistable/pushable.rb

@@ -57,7 +57,10 @@ module Mongoid
       def push(pushes)
         prepare_atomic_operation do |ops|
           process_atomic_operations(pushes) do |field, value|
-            existing = send(field) || (attributes[field] ||= [])
+            existing = send(field) || begin
+              attributes[field] ||= []
+              attributes[field]
+            end
             values = [ value ].flatten(1)
             values.each{ |val| existing.push(val) }
             ops[atomic_attribute_name(field)] = { "$each" => values }

data/lib/mongoid/persistence_context.rb

@@ -122,6 +122,12 @@ module Mongoid
       end
     end
 
+    def client_name
+      @client_name ||= options[:client] ||
+                         Threaded.client_override ||
+                         storage_options && __evaluate__(storage_options[:client])
+    end
+
     # Determine if this persistence context is equal to another.
     #
     # @example Compare two persistence contexts.
@@ -139,12 +145,6 @@ module Mongoid
 
     private
 
-    def client_name
-      @client_name ||= options[:client] ||
-                         Threaded.client_override ||
-                         storage_options && __evaluate__(storage_options[:client])
-    end
-
     def set_options!(opts)
       @options ||= opts.each.reduce({}) do |_options, (key, value)|
                      unless VALID_OPTIONS.include?(key.to_sym)

data/lib/mongoid/query_cache.rb

@@ -168,7 +168,8 @@ module Mongoid
         @coll_name ||= result.namespace.sub("#{database.name}.", '') if result.namespace
         documents = result.documents
         if @cursor_id.zero? && !@after_first_batch
-          (@cached_documents ||= []).concat(documents)
+          @cached_documents ||= []
+          @cached_documents.concat(documents)
         end
         @after_first_batch = true
         documents

data/lib/mongoid/validatable/uniqueness.rb

@@ -150,7 +150,7 @@ module Mongoid
       #
       # @since 2.3.0
       def filter(value)
-        !case_sensitive? && value ? /\A#{Regexp.escape(value.to_s)}$/i : value
+        !case_sensitive? && value ? /\A#{Regexp.escape(value.to_s)}\z/i : value
       end
 
       # Scope the criteria to the scope options provided.

data/lib/mongoid/version.rb

@@ -2,5 +2,5 @@
 # encoding: utf-8
 
 module Mongoid
-  VERSION = "7.1.1"
+  VERSION = "7.1.2"
 end

data/lib/rails/generators/mongoid/model/templates/model.rb.tt

@@ -13,7 +13,7 @@ class <%= class_name %><%= " < #{options[:parent].classify}" if options[:parent]
   field :<%= attribute.name %>, type: <%= attribute.type_class %>
 <% end -%>
 <% attributes.select{|attr| attr.reference? }.each do |attribute| -%>
-  embedded_in :<%= attribute.name%>
+  belongs_to :<%= attribute.name%>
 <% end -%>
 end
 <% end -%>