mongoid 7.0.5 → 7.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d4a5f733ce016f190a456b5801a1e3a1efbe89a30d99a20cd4c73e5696e7004
-  data.tar.gz: a40c8e747c7eeff97d8259bd6b11d35bf25de5434674c24f1c5ebe71ed5d6f3e
+  metadata.gz: ef857ba0b8faece9cb5bb46f2d1cb6e50fa1e2b52e6870c22cec4c5a3e73b98d
+  data.tar.gz: 030fbeeabf03434eb695eef129dd7abc1304419b550937ae225c2edd33824570
 SHA512:
-  metadata.gz: 121ace21edf0fec13546294a101b4bb383eed7d7b7ead0d6bd3624ccfad5601a70a9e4b0363e710e687ba237835ea4a61da8d17ebab00a2537751a7fcbf5410f
-  data.tar.gz: d39854dd3981a7c517e6ba00c0d85feb1e9bb6e928dabf233f603bf35f8299706c0981ed3cb9ba3c121e2af58ae42bc0e0e876a3a45f0264ac344d48469e9401
+  metadata.gz: 5e05da048526dece6963bfc5d33bb8e2db2ae3e26d37c9aa39949b9f69d16a93e33780bc7ce9244b23df11eb70e77d86cd95dfcd4426f864f3eb3429c0883033
+  data.tar.gz: dbb8f110097c0184d6de55630aac584722944d345723cca7ecaf76719548798970e992ba051beeb9b3ed801a49b4a2b1397a04717597620ab0183967091b368a

data/LICENSE

@@ -1,4 +1,5 @@
 Copyright (c) 2009-2016 Durran Jordan
+Copyright (c) 2015-2020 MongoDB, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -31,7 +31,8 @@ Please see the [MongoDB website](http://docs.mongodb.org/ecosystem/tutorial/ruby
 License
 -------
 
-Copyright (c) 2009-2017 Durran Jordan
+Copyright (c) 2009-2016 Durran Jordan
+Copyright (c) 2015-2020 MongoDB, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/mongoid.rb

@@ -13,6 +13,7 @@ require "active_support/time_with_zone"
 require "active_model"
 
 require "mongo"
+require 'mongo/active_support'
 
 require "mongoid/version"
 require "mongoid/config"

data/lib/mongoid/attributes.rb

@@ -157,21 +157,21 @@ module Mongoid
     #
     # @since 1.0.0
     def write_attribute(name, value)
-      access = database_field_name(name)
-      if attribute_writable?(access)
+      field_name = database_field_name(name)
+      if attribute_writable?(field_name)
         _assigning do
-          validate_attribute_value(access, value)
-          localized = fields[access].try(:localized?)
+          validate_attribute_value(field_name, value)
+          localized = fields[field_name].try(:localized?)
           attributes_before_type_cast[name.to_s] = value
-          typed_value = typed_value_for(access, value)
-          unless attributes[access] == typed_value || attribute_changed?(access)
-            attribute_will_change!(access)
+          typed_value = typed_value_for(field_name, value)
+          unless attributes[field_name] == typed_value || attribute_changed?(field_name)
+            attribute_will_change!(field_name)
           end
           if localized
-            attributes[access] ||= {}
-            attributes[access].merge!(typed_value)
+            attributes[field_name] ||= {}
+            attributes[field_name].merge!(typed_value)
           else
-            attributes[access] = typed_value
+            attributes[field_name] = typed_value
           end
           typed_value
         end
@@ -337,20 +337,28 @@ module Mongoid
 
     private
 
-    # Validates an attribute value. This provides validation checking if
-    # the value is valid for given a field.
-    # For now, only Hash and Array fields are validated.
+    # Validates an attribute value as being assignable to the specified field.
     #
-    # @param [ String, Symbol ] access The name of the attribute to validate.
-    # @param [ Object ] value The to be validated.
+    # For now, only Hash and Array fields are validated, and the value is
+    # being checked to be of an appropriate type (i.e. either Hash or Array,
+    # respectively, or nil).
+    #
+    # This method takes the name of the field as stored in the document
+    # in the database, not (necessarily) the Ruby method name used to read/write
+    # the said field.
+    #
+    # @param [ String, Symbol ] field_name The name of the field.
+    # @param [ Object ] value The value to be validated.
     #
     # @since 3.0.10
-    def validate_attribute_value(access, value)
-      return unless fields[access] && value
+    def validate_attribute_value(field_name, value)
+      return if value.nil?
+      field = fields[field_name]
+      return unless field
       validatable_types = [ Hash, Array ]
-      if validatable_types.include? fields[access].type
-        unless value.is_a? fields[access].type
-          raise Mongoid::Errors::InvalidValue.new(fields[access].type, value.class)
+      if validatable_types.include?(field.type)
+        unless value.is_a?(field.type)
+          raise Mongoid::Errors::InvalidValue.new(field.type, value.class)
         end
       end
     end

data/lib/mongoid/attributes/dynamic.rb

@@ -38,12 +38,13 @@ module Mongoid
       # @since 4.0.0
       def define_dynamic_reader(name)
         return unless name.valid_method_name?
-        class_eval <<-READER, __FILE__, __LINE__ + 1
-          def #{name}
-            attribute_will_change!(#{name.inspect})
-            read_raw_attribute(#{name.inspect})
+
+        class_eval do
+          define_method(name) do
+            attribute_will_change!(name)
+            read_raw_attribute(name)
           end
-        READER
+        end
       end
 
       # Define a reader method for a dynamic attribute before type cast.
@@ -57,12 +58,12 @@ module Mongoid
       #
       # @since 4.0.0
       def define_dynamic_before_type_cast_reader(name)
-        class_eval <<-READER, __FILE__, __LINE__ + 1
-          def #{name}_before_type_cast
-            attribute_will_change!(#{name.inspect})
-            read_attribute_before_type_cast(#{name.inspect})
+        class_eval do
+          define_method("#{name}_before_type_cast") do
+            attribute_will_change!(name)
+            read_attribute_before_type_cast(name)
           end
-        READER
+        end
       end
 
       # Define a writer method for a dynamic attribute.
@@ -78,11 +79,11 @@ module Mongoid
       def define_dynamic_writer(name)
         return unless name.valid_method_name?
 
-        class_eval <<-WRITER, __FILE__, __LINE__ + 1
-          def #{name}=(value)
-            write_attribute(#{name.inspect}, value)
+        class_eval do
+          define_method("#{name}=") do |value|
+            write_attribute(name, value)
           end
-        WRITER
+        end
       end
 
       # If the attribute is dynamic, add a field for it with a type of object

data/lib/mongoid/config/environment.rb

@@ -6,35 +6,48 @@ module Mongoid
     module Environment
       extend self
 
-      # Get the name of the environment that we are running under. This first
-      # looks for Rails, then Sinatra, then a RACK_ENV environment variable,
-      # and if none of those are found raises an error.
+      # Get the name of the environment that Mongoid is running under.
+      #
+      # Uses the following sources in order:
+      # - If +::Rails+ is defined, +Rails.env+.
+      # - If +::Sinatra+ is defined, +Sinatra::Base.environment+.
+      # - +RACK_ENV+
+      # - +MONGOID_ENV*
       #
       # @example Get the env name.
       #   Environment.env_name
       #
-      # @raise [ Errors::NoEnvironment ] If no environment was set.
+      # @raise [ Errors::NoEnvironment ] If environment name cannot be
+      #   determined because none of the sources was set.
       #
       # @return [ String ] The name of the current environment.
       #
       # @since 2.3.0
+      # @api public
       def env_name
-        return Rails.env if defined?(Rails) && Rails.respond_to?(:env)
-        return Sinatra::Base.environment.to_s if defined?(Sinatra)
-        ENV["RACK_ENV"] || ENV["MONGOID_ENV"] || raise(Errors::NoEnvironment.new)
+        if defined?(::Rails)
+          return ::Rails.env
+        end
+        if defined?(::Sinatra)
+          return ::Sinatra::Base.environment.to_s
+        end
+        ENV["RACK_ENV"] || ENV["MONGOID_ENV"] or raise Errors::NoEnvironment
       end
 
       # Load the yaml from the provided path and return the settings for the
-      # current environment.
+      # specified environment, or for the current Mongoid environment.
       #
       # @example Load the yaml.
       #   Environment.load_yaml("/work/mongoid.yml")
       #
       # @param [ String ] path The location of the file.
+      # @param [ String | Symbol ] environment Optional environment name to
+      #   override the current Mongoid environment.
       #
       # @return [ Hash ] The settings.
       #
       # @since 2.3.0
+      # @api private
       def load_yaml(path, environment = nil)
         env = environment ? environment.to_s : env_name
         YAML.load(ERB.new(File.new(path).read).result)[env]

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

@@ -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/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