mongoid 6.4.2 → 7.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c5d349e3de6af570dd7b1347fd76b6056848149180dc355e116f67f8ac2c3c6
-  data.tar.gz: e9be28598f701bb124ba6626bb777da07d05bca692224110078700557f2c0aa9
+  metadata.gz: 6f9840f2a5bdcfd628358c56f70818857080118680059a6ca299c6de3b4554c2
+  data.tar.gz: f8700656e769546f2c8d2555013aa601d10552e9e48faf37f24c66fded700b1d
 SHA512:
-  metadata.gz: 1bf33975f8969cc06ac717cef1a443429dd6ad8e8a7cd755c8b74ed9b7bc0e1a113413dac81098f54f9c181b91d03fc5958adfaaddb03d7fb91caa9f2e11dc84
-  data.tar.gz: c5ef0576ed9941a5ba0f0865fdaff885766e4d6fe6901d1037ce408a0acdc0e00fdbfe503a5a7d721d8178a83c39c6e5893aaf0c258e871b3dca17939d0e7d97
+  metadata.gz: a05fb92510939cf2ccff55855219033db8a9a45399865f725e695af95a9501f72a0db72422766dd54fc9946854e0065b9beb870bfeb3a02b8ac9e605962419e0
+  data.tar.gz: 267ff19b100ca5ef83f383ddd8d4ece8ce0e122a16cbc6c1605bc872e391ad775bd6336beb53af733ba8d7b47d9ec01d9842f5502c7f0c135cdc2fa258b80b47

data/README.md

@@ -21,7 +21,7 @@ Project Tracking
 Compatibility
 -------------
 
-Mongoid is tested against MRI 2.2, 2.3 and JRuby (9.1).
+Mongoid is tested against MRI 2.2-2.5 and JRuby 9.1-9.2.
 
 Documentation
 -------------

data/lib/config/locales/en.yml

@@ -91,6 +91,11 @@ en:
             expecting the option to be there, please consult the following page
             with repect to Mongoid's configuration:\n\n
             \_\_http://mongoid.org/en/mongoid/docs/installation.html"
+        invalid_dependent_strategy:
+          message: "Invalid dependent strategy: %{invalid_strategy}."
+          summary: "An invalid dependent strategy was defined for the association:
+            %{association}. The valid strategies are: %{valid_strategies}."
+          resolution: "Change the dependent strategy to one of the valid types."
         invalid_field:
           message: "Defining a field named '%{name}' is not allowed."
           summary: "Defining this field would override the method '%{name}',
@@ -196,6 +201,11 @@ en:
             allowed, and don't use these names. These include names that also
             conflict with core Ruby methods on Object, Module, Enumerable, or
             included gems that inject methods into these or Mongoid internals."
+        invalid_relation_option:
+          message: "Invalid relation option :%{option} for relation '%{name}' on class
+            %{klass}."
+          summary: "An invalid option was provided for a relation."
+          resolution: "Valid options are: %{valid_options}, make sure you use only those."
         invalid_scope:
           message: "Defining a scope of value %{value} on %{klass} is not
             allowed."
@@ -494,6 +504,13 @@ en:
             attributes hash, and is raised instead of getting a NoMethodError."
           resolution: "You can include Mongoid::Attributes::Dynamic if you
             expect to be writing values for undefined fields often."
+        unknown_model:
+          message: "Attempted to instantiate an object of the unknown Model '%{klass}'."
+          summary: "A document with the value '%{value}' at the key '_type' was used to
+            instantiate a model object but Mongoid cannot find this Class."
+          resolution: "The _type field is a reserved one used by Mongoid to determine the
+            class for instantiating an object. Please don't save data in this field or ensure
+            that any values in this field correspond to valid Models."
         unsaved_document:
           message: "Attempted to save %{document} before the parent %{base}."
           summary: "You cannot call create or create! through the

data/lib/mongoid/association/accessors.rb

@@ -0,0 +1,339 @@
+# encoding: utf-8
+module Mongoid
+  module Association
+
+    # This module contains all the behaviour related to accessing relations
+    # through the getters and setters, and how to delegate to builders to
+    # create new ones.
+    module Accessors
+      extend ActiveSupport::Concern
+
+      # Builds the related document and creates the relation unless the
+      # document is nil, then sets the relation on this document.
+      #
+      # @example Build the relation.
+      #   person.__build__(:addresses, { :_id => 1 }, association)
+      #
+      # @param [ String, Symbol ] name The name of the relation.
+      # @param [ Hash, BSON::ObjectId ] object The id or attributes to use.
+      # @param [ Association ] association The association metadata.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 2.0.0.rc.1
+      def __build__(name, object, association)
+        relation = create_relation(object, association)
+        set_relation(name, relation)
+      end
+
+      # Create a relation from an object and association.
+      #
+      # @example Create the relation.
+      #   person.create_relation(document, association)
+      #
+      # @param [ Document, Array<Document> ] object The relation target.
+      # @param [ Association ] association The association metadata.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 2.0.0.rc.1
+      def create_relation(object, association)
+        type = @attributes[association.inverse_type]
+        target = association.build(self, object, type)
+        target ? association.create_relation(self, target) : nil
+      end
+
+      # Resets the criteria inside the relation proxy. Used by many-to-many
+      # relations to keep the underlying ids array in sync.
+      #
+      # @example Reset the relation criteria.
+      #   person.reset_relation_criteria(:preferences)
+      #
+      # @param [ Symbol ] name The name of the relation.
+      #
+      # @since 3.0.14
+      def reset_relation_criteria(name)
+        if instance_variable_defined?("@_#{name}")
+          send(name).reset_unloaded
+        end
+      end
+
+      # Set the supplied relation to an instance variable on the class with the
+      # provided name. Used as a helper just for code cleanliness.
+      #
+      # @example Set the proxy on the document.
+      #   person.set(:addresses, addresses)
+      #
+      # @param [ String, Symbol ] name The name of the relation.
+      # @param [ Proxy ] relation The relation to set.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 2.0.0.rc.1
+      def set_relation(name, relation)
+        instance_variable_set("@_#{name}", relation)
+      end
+
+      private
+
+      # Get the relation. Extracted out from the getter method to avoid
+      # infinite recursion when overriding the getter.
+      #
+      # @api private
+      #
+      # @example Get the relation.
+      #   document.get_relation(:name, association)
+      #
+      # @param [ Symbol ] name The name of the relation.
+      # @param [ Association ] association The association metadata.
+      # @param [ Object ] object The object used to build the relation.
+      # @param [ true, false ] reload If the relation is to be reloaded.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 3.0.16
+      def get_relation(name, association, object, reload = false)
+        if !reload && (value = ivar(name)) != false
+          value
+        else
+          _building do
+            _loading do
+              if object && needs_no_database_query?(object, association)
+                __build__(name, object, association)
+              else
+                __build__(name, attributes[association.key], association)
+              end
+            end
+          end
+        end
+      end
+
+      def needs_no_database_query?(object, association)
+        object.is_a?(Document) && !object.embedded? &&
+            object._id == attributes[association.key]
+      end
+
+      # Is the current code executing without autobuild functionality?
+      #
+      # @example Is autobuild disabled?
+      #   document.without_autobuild?
+      #
+      # @return [ true, false ] If autobuild is disabled.
+      #
+      # @since 3.0.0
+      def without_autobuild?
+        Threaded.executing?(:without_autobuild)
+      end
+
+      # Yield to the block with autobuild functionality turned off.
+      #
+      # @example Execute without autobuild.
+      #   document.without_autobuild do
+      #     document.name
+      #   end
+      #
+      # @return [ Object ] The result of the yield.
+      #
+      # @since 3.0.0
+      def without_autobuild
+        Threaded.begin_execution("without_autobuild")
+        yield
+      ensure
+        Threaded.exit_execution("without_autobuild")
+      end
+
+      # Parse out the attributes and the options from the args passed to a
+      # build_ or create_ methods.
+      #
+      # @example Parse the args.
+      #   doc.parse_args(:name => "Joe")
+      #
+      # @param [ Array ] args The arguments.
+      #
+      # @return [ Array<Hash> ] The attributes and options.
+      #
+      # @since 2.3.4
+      def parse_args(*args)
+        [args.first || {}, args.size > 1 ? args[1] : {}]
+      end
+
+      # Adds the existence check for relations.
+      #
+      # @example Add the existence check.
+      #   Person.define_existence_check!(association)
+      #
+      # @example Check if a relation exists.
+      #   person = Person.new
+      #   person.has_game?
+      #   person.game?
+      #
+      # @param [ Association ] association The association.
+      #
+      # @return [ Class ] The model being set up.
+      #
+      # @since 3.0.0
+      def self.define_existence_check!(association)
+        name = association.name
+        association.inverse_class.tap do |klass|
+          klass.module_eval <<-END, __FILE__, __LINE__ + 1
+              def #{name}?
+                without_autobuild { !__send__(:#{name}).blank? }
+              end
+              alias :has_#{name}? :#{name}?
+          END
+        end
+      end
+
+      # Defines the getter for the relation. Nothing too special here: just
+      # return the instance variable for the relation if it exists or build
+      # the thing.
+      #
+      # @example Set up the getter for the relation.
+      #   Person.define_getter!(association)
+      #
+      # @param [ Association ] association The association metadata for the relation.
+      #
+      # @return [ Class ] The class being set up.
+      #
+      # @since 2.0.0.rc.1
+      def self.define_getter!(association)
+        name = association.name
+        association.inverse_class.tap do |klass|
+          klass.re_define_method(name) do |reload = false|
+            value = get_relation(name, association, nil, reload)
+            if value.nil? && association.autobuilding? && !without_autobuild?
+              value = send("build_#{name}")
+            end
+            value
+          end
+        end
+      end
+
+      # Defines the getter for the ids of documents in the relation. Should
+      # be specify only for referenced many relations.
+      #
+      # @example Set up the ids getter for the relation.
+      #   Person.define_ids_getter!(association)
+      #
+      # @param [ Association ] association The association metadata for the relation.
+      #
+      # @return [ Class ] The class being set up.
+      def self.define_ids_getter!(association)
+        ids_method = "#{association.name.to_s.singularize}_ids"
+        association.inverse_class.tap do |klass|
+          klass.re_define_method(ids_method) do
+            send(association.name).only(:id).map(&:id)
+          end
+        end
+      end
+
+      # Defines the setter for the relation. This does a few things based on
+      # some conditions. If there is an existing association, a target
+      # substitution will take place, otherwise a new relation will be
+      # created with the supplied target.
+      #
+      # @example Set up the setter for the relation.
+      #   Person.define_setter!(association)
+      #
+      # @param [ Association ] association The association metadata for the relation.
+      #
+      # @return [ Class ] The class being set up.
+      #
+      # @since 2.0.0.rc.1
+      def self.define_setter!(association)
+        name = association.name
+        association.inverse_class.tap do |klass|
+          klass.re_define_method("#{name}=") do |object|
+            without_autobuild do
+              if value = get_relation(name, association, object)
+                if value.respond_to?(:substitute)
+                  set_relation(name, value.substitute(object.substitutable))
+                else
+                  value = __build__(name, value, association)
+                  set_relation(name, value.substitute(object.substitutable))
+                end
+              else
+                __build__(name, object.substitutable, association)
+              end
+            end
+          end
+        end
+      end
+
+      # Defines the setter method that allows you to set documents
+      # in this relation by their ids. The defined setter, finds
+      # documents with given ids and invokes regular relation setter
+      # with found documents. Ids setters should be defined only for
+      # referenced many relations.
+      #
+      # @example Set up the id_setter for the relation.
+      #   Person.define_ids_setter!(association)
+      #
+      #  @param [ Association ] association The association for the relation.
+      #
+      #  @return [ Class ] The class being set up.
+      def self.define_ids_setter!(association)
+        ids_method = "#{association.name.to_s.singularize}_ids="
+        association.inverse_class.tap do |klass|
+          klass.re_define_method(ids_method) do |ids|
+            send(association.setter, association.relation_class.find(ids.reject(&:blank?)))
+          end
+        end
+      end
+
+      # Defines a builder method for an embeds_one relation. This is
+      # defined as #build_name.
+      #
+      # @example
+      #   Person.define_builder!(association)
+      #
+      # @param [ Association ] association The association for the relation.
+      #
+      # @return [ Class ] The class being set up.
+      #
+      # @since 2.0.0.rc.1
+      def self.define_builder!(association)
+        name = association.name
+        association.inverse_class.tap do |klass|
+          klass.re_define_method("build_#{name}") do |*args|
+            attributes, _options = parse_args(*args)
+            document = Factory.build(association.relation_class, attributes)
+            _building do
+              child = send("#{name}=", document)
+              child.run_callbacks(:build)
+              child
+            end
+          end
+        end
+      end
+
+      # Defines a creator method for an embeds_one relation. This is
+      # defined as #create_name. After the object is built it will
+      # immediately save.
+      #
+      # @example
+      #   Person.define_creator!(association)
+      #
+      # @param [ Association ] association The association for the relation.
+      #
+      # @return [ Class ] The class being set up.
+      #
+      # @since 2.0.0.rc.1
+      def self.define_creator!(association)
+        name = association.name
+        association.inverse_class.tap do |klass|
+          klass.re_define_method("create_#{name}") do |*args|
+            attributes, _options = parse_args(*args)
+            document = Factory.build(association.klass, attributes)
+            doc = _assigning do
+              send("#{name}=", document)
+            end
+            doc.save
+            save if new_record? && association.stores_foreign_key?
+            doc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/{relations/binding.rb → association/bindable.rb}

@@ -1,25 +1,25 @@
 # encoding: utf-8
 module Mongoid
-  module Relations
+  module Association
 
     # Superclass for all objects that bind relations together.
-    class Binding
+    module Bindable
       include Threaded::Lifecycle
 
-      attr_reader :base, :target, :metadata
+      attr_reader :_base, :_target, :_association
 
       # Create the new binding.
       #
       # @example Initialize a binding.
-      #   Binding.new(base, target, metadata)
+      #   Binding.new(base, target, association)
       #
       # @param [ Document ] base The base of the binding.
       # @param [ Document, Array<Document> ] target The target of the binding.
-      # @param [ Metadata ] metadata The relation's metadata.
+      # @param [ Association ] association The association metadata.
       #
       # @since 2.0.0.rc.1
-      def initialize(base, target, metadata)
-        @base, @target, @metadata = base, target, metadata
+      def initialize(base, target, association)
+        @_base, @_target, @_association = base, target, association
       end
 
       # Execute the provided block inside a binding.
@@ -55,32 +55,12 @@ module Mongoid
       #
       # @since 3.0.0
       def check_inverse!(doc)
-        if !metadata.forced_nil_inverse? &&
-          !doc.respond_to?(metadata.foreign_key_setter)
+        unless _association.bindable?(doc)
           raise Errors::InverseNotFound.new(
-            base.class,
-            metadata.name,
-            doc.class,
-            metadata.foreign_key
-          )
-        end
-      end
-
-      # Check for problems with multiple inverse definitions.
-      #
-      # @api private
-      #
-      # @example Check for inverses errors.
-      #   binding.check_inverses!(doc)
-      #
-      # @param [ Document ] doc The document to check.
-      #
-      # @since 3.0.0
-      def check_inverses!(doc)
-        inverses = metadata.inverses(doc)
-        if inverses.count > 1 && base.send(metadata.foreign_key).nil?
-          raise Errors::InvalidSetPolymorphicRelation.new(
-            metadata.name, base.class.name, target.class.name
+              _base.class,
+              _association.name,
+              doc.class,
+              _association.foreign_key
           )
         end
       end
@@ -99,7 +79,7 @@ module Mongoid
       # @since 3.0.0
       def bind_foreign_key(keyed, id)
         unless keyed.frozen?
-          keyed.you_must(metadata.foreign_key_setter, id)
+          keyed.you_must(_association.foreign_key_setter, id)
         end
       end
 
@@ -116,8 +96,8 @@ module Mongoid
       #
       # @since 3.0.0
       def bind_polymorphic_type(typed, name)
-        if metadata.type
-          typed.you_must(metadata.type_setter, name)
+        if _association.type
+          typed.you_must(_association.type_setter, name)
         end
       end
 
@@ -134,8 +114,8 @@ module Mongoid
       #
       # @since 3.0.0
       def bind_polymorphic_inverse_type(typed, name)
-        if metadata.inverse_type
-          typed.you_must(metadata.inverse_type_setter, name)
+        if _association.inverse_type
+          typed.you_must(_association.inverse_type_setter, name)
         end
       end
 
@@ -152,8 +132,8 @@ module Mongoid
       #
       # @since 3.0.0
       def bind_inverse(doc, inverse)
-        if doc.respond_to?(metadata.inverse_setter)
-          doc.you_must(metadata.inverse_setter, inverse)
+        if doc.respond_to?(_association.inverse_setter)
+          doc.you_must(_association.inverse_setter, inverse)
         end
       end
 
@@ -169,31 +149,31 @@ module Mongoid
       # @since 3.0.0
       def bind_from_relational_parent(doc)
         check_inverse!(doc)
-        bind_foreign_key(doc, record_id(base))
-        bind_polymorphic_type(doc, base.class.name)
-        bind_inverse(doc, base)
+        bind_foreign_key(doc, record_id(_base))
+        bind_polymorphic_type(doc, _base.class.name)
+        bind_inverse(doc, _base)
       end
 
-      def record_id(base)
-        base.__send__(metadata.primary_key)
+      def record_id(_base)
+        _base.__send__(_association.primary_key)
       end
 
-      # Ensure that the metadata on the base is correct, for the cases
+      # Ensure that the association on the base is correct, for the cases
       # where we have multiple belongs to definitions and were are setting
       # different parents in memory in order.
       #
       # @api private
       #
-      # @example Set the base metadata.
-      #   binding.set_base_metadata
+      # @example Set the base association.
+      #   binding.set_base_association
       #
-      # @return [ true, false ] If the metadata changed.
+      # @return [ true, false ] If the association changed.
       #
       # @since 2.4.4
-      def set_base_metadata
-        inverse_metadata = metadata.inverse_metadata(target)
-        if inverse_metadata != metadata && !inverse_metadata.nil?
-          base.__metadata = inverse_metadata
+      def set_base_association
+        inverse_association = _association.inverse_association(_target)
+        if inverse_association != _association && !inverse_association.nil?
+          _base._association = inverse_association
         end
       end
 

data/lib/mongoid/association/builders.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+module Mongoid
+  module Association
+
+    # This module is responsible for defining the build and create methods used
+    # in one to one relations.
+    #
+    # @example Methods that get created.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     embeds_one :name
+    #   end
+    #
+    #   # The following methods get created:
+    #   person.build_name({ :first_name => "Durran" })
+    #   person.create_name({ :first_name => "Durran" })
+    #
+    # @since 2.0.0.rc.1
+    module Builders
+      extend ActiveSupport::Concern
+
+      private
+
+      # Parse out the attributes and the options from the args passed to a
+      # build_ or create_ methods.
+      #
+      # @example Parse the args.
+      #   doc.parse_args(:name => "Joe")
+      #
+      # @param [ Array ] args The arguments.
+      #
+      # @return [ Array<Hash> ] The attributes and options.
+      #
+      # @since 2.3.4
+      def parse_args(*args)
+        [ args.first || {}, args.size > 1 ? args[1] : {} ]
+      end
+
+      # Defines a builder method. This is defined as #build_name.
+      #
+      # @example
+      #   Person.define_builder!(association)
+      #
+      # @param [ Association ] association The association metadata for the relation.
+      #
+      # @return [ Class ] The class being set up.
+      #
+      # @since 2.0.0.rc.1
+      def self.define_builder!(association)
+        association.inverse_class.tap do |klass|
+          klass.re_define_method("build_#{association.name}") do |*args|
+            attributes, _options = parse_args(*args)
+            document = Factory.build(association.relation_class, attributes)
+            _building do
+              child = send("#{association.name}=", document)
+              child.run_callbacks(:build)
+              child
+            end
+          end
+        end
+      end
+
+      # Defines a creator method. This is defined as #create_name.
+      # After the object is built it will immediately save.
+      #
+      # @example
+      #   Person.define_creator!(association)
+      #
+      # @param [ Association ] association The association metadata for the relation.
+      #
+      # @return [ Class ] The class being set up.
+      #
+      # @since 2.0.0.rc.1
+      def self.define_creator!(association)
+        association.inverse_class.tap do |klass|
+          klass.re_define_method("create_#{association.name}") do |*args|
+            attributes, _options = parse_args(*args)
+            document = Factory.build(association.relation_class, attributes)
+            doc = _assigning do
+              send("#{association.name}=", document)
+            end
+            doc.save
+            save if new_record? && association.stores_foreign_key?
+            doc
+          end
+        end
+      end
+    end
+  end
+end