mongoid 2.4.10 → 3.0.0.rc

data/lib/mongoid/relations/accessors.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
+module Mongoid
+  module Relations
 
     # This module contains all the behaviour related to accessing relations
     # through the getters and setters, and how to delegate to builders to
@@ -12,7 +12,7 @@ module Mongoid # :nodoc:
       # document is nil, then sets the relation on this document.
       #
       # @example Build the relation.
-      #   person.build(:addresses, { :id => 1 }, metadata)
+      #   person.__build__(:addresses, { :id => 1 }, metadata)
       #
       # @param [ String, Symbol ] name The name of the relation.
       # @param [ Hash, BSON::ObjectId ] object The id or attributes to use.
@@ -22,7 +22,7 @@ module Mongoid # :nodoc:
       # @return [ Proxy ] The relation.
       #
       # @since 2.0.0.rc.1
-      def build(name, object, metadata)
+      def __build__(name, object, metadata)
         relation = create_relation(object, metadata)
         set_relation(name, relation)
       end
@@ -74,7 +74,64 @@ module Mongoid # :nodoc:
         instance_variable_set("@#{name}", relation)
       end
 
-      module ClassMethods #:nodoc:
+      private
+
+      # 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("without_autobuild")
+        yield
+      ensure
+        Threaded.exit("without_autobuild")
+      end
+
+      module ClassMethods
+
+        # Adds the existence check for relations.
+        #
+        # @example Add the existence check.
+        #   Person.existence_check(:name, meta)
+        #
+        # @example Check if a relation exists.
+        #   person = Person.new
+        #   person.has_game?
+        #   person.game?
+        #
+        # @param [ String, Symbol ] name The name of the relation.
+        # @param [ Metadata ] The metadata.
+        #
+        # @return [ Class ] The model being set up.
+        #
+        # @since 3.0.0
+        def existence_check(name, metadata)
+          module_eval <<-END
+            def #{name}?
+              without_autobuild { !#{name}.blank? }
+            end
+            alias :has_#{name}? :#{name}?
+          END
+          self
+        end
 
         # Defines the getter for the relation. Nothing too special here: just
         # return the instance variable for the relation if it exists or build
@@ -90,22 +147,43 @@ module Mongoid # :nodoc:
         #
         # @since 2.0.0.rc.1
         def getter(name, metadata)
-          tap do
-            define_method(name) do |*args|
-              reload, variable = args.first, "@#{name}"
-              if instance_variable_defined?(variable) && !reload
-                instance_variable_get(variable)
-              else
-                _building do
-                  _loading do
-                    build(name, attributes[metadata.key], metadata)
-                  end
-                end
+          re_define_method(name) do |*args|
+            reload, variable = args.first, "@#{name}"
+            value = if instance_variable_defined?(variable) && !reload
+              instance_variable_get(variable)
+            else
+              _building do
+                _loading { __build__(name, attributes[metadata.key], metadata) }
               end
             end
+            if value.nil? && metadata.autobuilding? && !without_autobuild?
+              send("build_#{name}")
+            else
+              value
+            end
+          end
+          self
+        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.ids_getter("addresses", metadata)
+        #
+        # @param [ String, Symbol ] name The name of the relation.
+        # @param [ Metadata] metadata The metadata for the relation.
+        #
+        # @return [ Class ] The class being set up.
+        def ids_getter(name, metadata)
+          ids_method = "#{name.to_s.singularize}_ids"
+          re_define_method(ids_method) do
+            send(name).only(:id).map(&:id)
           end
+          self
         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
@@ -121,16 +199,38 @@ module Mongoid # :nodoc:
         #
         # @since 2.0.0.rc.1
         def setter(name, metadata)
-          tap do
-            define_method("#{name}=") do |object|
+          re_define_method("#{name}=") do |object|
+            without_autobuild do
               if relation_exists?(name) || metadata.many? ||
                 (object.blank? && send(name))
                 set_relation(name, send(name).substitute(object.substitutable))
               else
-                build(name, object.substitutable, metadata)
+                __build__(name, object.substitutable, metadata)
               end
             end
           end
+          self
+        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.ids_setter("addesses", metadata)
+        #
+        #  @param [ String, Symbol ] name The name of the relation.
+        #  @param [ Metadata ] metadata The metadata for the relation.
+        #
+        #  @return [ Class ] The class being set up.
+        def ids_setter(name, metadata)
+          ids_method = "#{name.to_s.singularize}_ids="
+          re_define_method(ids_method) do |ids|
+            send(metadata.setter, metadata.klass.find(ids))
+          end
+          self
         end
       end
     end

data/lib/mongoid/relations/auto_save.rb

@@ -1,13 +1,50 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
+module Mongoid
+  module Relations
 
     # This module contains the behaviour for auto-saving relations in
     # different collections.
     module AutoSave
       extend ActiveSupport::Concern
 
-      module ClassMethods #:nodoc:
+      included do
+        class_attribute :autosaved_relations
+        self.autosaved_relations = []
+      end
+
+      # Used to prevent infinite loops in associated autosaves.
+      #
+      # @example Is the document autosaved?
+      #   document.autosaved?
+      #
+      # @return [ true, false ] Has the document already been autosaved?
+      #
+      # @since 3.0.0
+      def autosaved?
+        Threaded.autosaved?(self)
+      end
+
+      # Begin the associated autosave.
+      #
+      # @example Begin autosave.
+      #   document.begin_autosave
+      #
+      # @since 3.0.0
+      def begin_autosave
+        Threaded.begin_autosave(self)
+      end
+
+      # Exit the associated autosave.
+      #
+      # @example Exit autosave.
+      #   document.exit_autosave
+      #
+      # @since 3.0.0
+      def exit_autosave
+        Threaded.exit_autosave(self)
+      end
+
+      module ClassMethods
 
         # Set up the autosave behaviour for references many and references one
         # relations. When the option is set to true, these relations will get
@@ -21,17 +58,34 @@ module Mongoid # :nodoc:
         #
         # @since 2.0.0.rc.1
         def autosave(metadata)
-          if metadata.autosave?
-            set_callback :save, :after do |document|
+          if metadata.autosave? && autosavable?(metadata)
+            autosaved_relations.push(metadata.name)
+            set_callback :save, :after, unless: :autosaved? do |document|
+              begin_autosave
               relation = document.send(metadata.name)
               if relation
                 (relation.do_or_do_not(:in_memory) || Array.wrap(relation)).each do |doc|
                   doc.save
                 end
               end
+              exit_autosave
             end
           end
         end
+
+        # Can the autosave be added?
+        #
+        # @example Can the autosave be added?
+        #   Person.autosavable?(metadata)
+        #
+        # @param [ Metadata ] metadata The relation metadata.
+        #
+        # @return [ true, false ] If the autosave is able to be added.
+        #
+        # @since 3.0.0
+        def autosavable?(metadata)
+          !autosaved_relations.include?(metadata.name) && !metadata.embedded?
+        end
       end
     end
   end

data/lib/mongoid/relations/binding.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
+module Mongoid
+  module Relations
 
     # Superclass for all objects that bind relations together.
     class Binding
@@ -21,6 +21,215 @@ module Mongoid # :nodoc:
       def initialize(base, target, metadata)
         @base, @target, @metadata = base, target, metadata
       end
+
+      # Execute the provided block inside a binding.
+      #
+      # @example Execute the binding block.
+      #   binding.binding do
+      #     base.foreign_key = 1
+      #   end
+      #
+      # @return [ Object ] The result of the yield.
+      #
+      # @since 3.0.0
+      def binding
+        unless _binding?
+          _binding do
+            yield(self) if block_given?
+          end
+        end
+      end
+
+      private
+
+      # Check if the inverse is properly defined.
+      #
+      # @api private
+      #
+      # @example Check the inverse definition.
+      #   binding.check_inverse!(doc)
+      #
+      # @param [ Document ] doc The document getting bound.
+      #
+      # @raise [ Errors::InverseNotFound ] If no inverse found.
+      #
+      # @since 3.0.0
+      def check_inverse!(doc)
+        if !metadata.forced_nil_inverse? &&
+          !doc.respond_to?(metadata.foreign_key_setter)
+          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
+          )
+        end
+      end
+
+      # Set the id of the related document in the foreign key field on the
+      # keyed document.
+      #
+      # @api private
+      #
+      # @example Bind the foreign key.
+      #   binding.bind_foreign_key(post, person.id)
+      #
+      # @param [ Document ] keyed The document that stores the foreign key.
+      # @param [ Object ] id The id of the bound document.
+      #
+      # @since 3.0.0
+      def bind_foreign_key(keyed, id)
+        unless keyed.frozen?
+          keyed.you_must(metadata.foreign_key_setter, id)
+        end
+      end
+
+      # Set the type of the related document on the foreign type field, used
+      # when relations are polymorphic.
+      #
+      # @api private
+      #
+      # @example Bind the polymorphic type.
+      #   binding.bind_polymorphic_type(post, "Person")
+      #
+      # @param [ Document ] typed The document that stores the type field.
+      # @param [ String ] name The name of the model.
+      #
+      # @since 3.0.0
+      def bind_polymorphic_type(typed, name)
+        if metadata.type
+          typed.you_must(metadata.type_setter, name)
+        end
+      end
+
+      # Set the type of the related document on the foreign type field, used
+      # when relations are polymorphic.
+      #
+      # @api private
+      #
+      # @example Bind the polymorphic type.
+      #   binding.bind_polymorphic_inverse_type(post, "Person")
+      #
+      # @param [ Document ] typed The document that stores the type field.
+      # @param [ String ] name The name of the model.
+      #
+      # @since 3.0.0
+      def bind_polymorphic_inverse_type(typed, name)
+        if metadata.inverse_type
+          typed.you_must(metadata.inverse_type_setter, name)
+        end
+      end
+
+      # Bind the inverse document to the child document so that the in memory
+      # instances are the same.
+      #
+      # @api private
+      #
+      # @example Bind the inverse.
+      #   binding.bind_inverse(post, person)
+      #
+      # @param [ Document ] doc The base document.
+      # @param [ Document ] inverse The inverse document.
+      #
+      # @since 3.0.0
+      def bind_inverse(doc, inverse)
+        if doc.respond_to?(metadata.inverse_setter)
+          doc.you_must(metadata.inverse_setter, inverse)
+        end
+      end
+
+      # Bind the inverse of field, when in a polymorphic relation.
+      #
+      # @api private
+      #
+      # @example Bind the inverse of field.
+      #   binding.bind_inverse_of_field(doc)
+      #
+      # @param [ Document ] doc The document to bind.
+      # @param [ String ] name The name of the relation.
+      #
+      # @since 3.0.0
+      def bind_inverse_of_field(doc, name)
+        if inverse_metadata = metadata.inverse_metadata(doc)
+          if setter = inverse_metadata.inverse_of_field_setter
+            doc.you_must(setter, name)
+          end
+        end
+      end
+
+      # Bind the provided document with the base from the parent relation.
+      #
+      # @api private
+      #
+      # @example Bind the document with the base.
+      #   binding.bind_from_relational_parent(doc)
+      #
+      # @param [ Document ] doc The document to bind.
+      #
+      # @since 3.0.0
+      def bind_from_relational_parent(doc)
+        check_inverse!(doc)
+        bind_foreign_key(doc, base.id)
+        bind_polymorphic_type(doc, base.class.model_name)
+        bind_inverse(doc, base)
+        bind_inverse_of_field(doc, metadata.name)
+      end
+
+      # Ensure that the metadata 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
+      #
+      # @return [ true, false ] If the metadata 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
+        end
+      end
+
+      # Bind the provided document with the base from the parent relation.
+      #
+      # @api private
+      #
+      # @example Bind the document with the base.
+      #   unbinding.unbind_from_relational_parent(doc)
+      #
+      # @param [ Document ] doc The document to unbind.
+      #
+      # @since 3.0.0
+      def unbind_from_relational_parent(doc)
+        check_inverse!(doc)
+        bind_foreign_key(doc, nil)
+        bind_polymorphic_type(doc, nil)
+        bind_inverse(doc, nil)
+        bind_inverse_of_field(doc, nil)
+      end
     end
   end
 end

data/lib/mongoid/relations/bindings/embedded/in.rb

@@ -1,8 +1,8 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
-    module Bindings #:nodoc:
-      module Embedded #:nodoc:
+module Mongoid
+  module Relations
+    module Bindings
+      module Embedded
 
         # Binding class for embedded_in relations.
         class In < Binding
@@ -23,20 +23,17 @@ module Mongoid # :nodoc:
           # @option options [ true, false ] :binding Are we in build mode?
           #
           # @since 2.0.0.rc.1
-          def bind
+          def bind_one
             base.metadata = metadata.inverse_metadata(target) unless base.metadata
             base.parentize(target)
-            unless _binding?
-              _binding do
-                if base.embedded_many?
-                  target.do_or_do_not(metadata.inverse(target)).push(base)
-                else
-                  target.do_or_do_not(metadata.inverse_setter(target), base)
-                end
+            binding do
+              if base.embedded_many?
+                target.do_or_do_not(metadata.inverse(target)).push(base)
+              else
+                target.do_or_do_not(metadata.inverse_setter(target), base)
               end
             end
           end
-          alias :bind_one :bind
 
           # Unbinds the base object and the inverse, caused by setting the
           # reference to nil.
@@ -50,18 +47,15 @@ module Mongoid # :nodoc:
           # @option options [ true, false ] :continue Do we continue unbinding?
           #
           # @since 2.0.0.rc.1
-          def unbind
-            unless _binding?
-              _binding do
-                if base.embedded_many?
-                  target.do_or_do_not(metadata.inverse(target)).delete(base)
-                else
-                  target.do_or_do_not(metadata.inverse_setter(target), nil)
-                end
+          def unbind_one
+            binding do
+              if base.embedded_many?
+                target.do_or_do_not(metadata.inverse(target)).delete(base)
+              else
+                target.do_or_do_not(metadata.inverse_setter(target), nil)
               end
             end
           end
-          alias :unbind_one :unbind
         end
       end
     end

data/lib/mongoid/relations/bindings/embedded/many.rb

@@ -1,32 +1,12 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
-    module Bindings #:nodoc:
-      module Embedded #:nodoc:
+module Mongoid
+  module Relations
+    module Bindings
+      module Embedded
 
         # Binding class for embeds_many relations.
         class Many < Binding
 
-          # Binds the base object to the inverse of the relation. This is so we
-          # are referenced to the actual objects themselves on both sides.
-          #
-          # This case sets the metadata on the inverse object as well as the
-          # document itself.
-          #
-          # @example Bind all the documents.
-          #   person.addresses.bind
-          #   person.addresses = [ Address.new ]
-          #
-          # @param [ Hash ] options The binding options.
-          #
-          # @option options [ true, false ] :continue Continue binding the inverse.
-          # @option options [ true, false ] :binding Are we in build mode?
-          #
-          # @since 2.0.0.rc.1
-          def bind
-            target.each { |doc| bind_one(doc) }
-          end
-
           # Binds a single document with the inverse relation. Used
           # specifically when appending to the proxy.
           #
@@ -42,32 +22,13 @@ module Mongoid # :nodoc:
           # @since 2.0.0.rc.1
           def bind_one(doc)
             doc.parentize(base)
-            unless _binding?
-              _binding do
-                unless metadata.versioned?
-                  doc.do_or_do_not(metadata.inverse_setter(target), base)
-                end
+            binding do
+              unless metadata.versioned?
+                doc.do_or_do_not(metadata.inverse_setter(target), base)
               end
             end
           end
 
-          # Unbinds the base object and the inverse, caused by setting the
-          # reference to nil.
-          #
-          # @example Unbind the documents.
-          #   person.addresses.unbind
-          #   person.addresses = nil
-          #
-          # @param [ Hash ] options The binding options.
-          #
-          # @option options [ true, false ] :continue Continue binding the inverse.
-          # @option options [ true, false ] :binding Are we in build mode?
-          #
-          # @since 2.0.0.rc.1
-          def unbind
-            target.each { |doc| unbind_one(doc) }
-          end
-
           # Unbind a single document.
           #
           # @example Unbind the document.
@@ -80,10 +41,8 @@ module Mongoid # :nodoc:
           #
           # @since 2.0.0.rc.1
           def unbind_one(doc)
-            unless _binding?
-              _binding do
-                doc.do_or_do_not(metadata.inverse_setter(target), nil)
-              end
+            binding do
+              doc.do_or_do_not(metadata.inverse_setter(target), nil)
             end
           end
         end

data/lib/mongoid/relations/bindings/embedded/one.rb

@@ -1,8 +1,8 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
-  module Relations #:nodoc:
-    module Bindings #:nodoc:
-      module Embedded #:nodoc:
+module Mongoid
+  module Relations
+    module Bindings
+      module Embedded
 
         # Binding class for embeds_one relations.
         class One < Binding
@@ -23,15 +23,12 @@ module Mongoid # :nodoc:
           # @option options [ true, false ] :binding Are we in build mode?
           #
           # @since 2.0.0.rc.1
-          def bind
+          def bind_one
             target.parentize(base)
-            unless _binding?
-              _binding do
-                target.do_or_do_not(metadata.inverse_setter(target), base)
-              end
+            binding do
+              target.do_or_do_not(metadata.inverse_setter(target), base)
             end
           end
-          alias :bind_one :bind
 
           # Unbinds the base object and the inverse, caused by setting the
           # reference to nil.
@@ -46,14 +43,11 @@ module Mongoid # :nodoc:
           # @option options [ true, false ] :binding Are we in build mode?
           #
           # @since 2.0.0.rc.1
-          def unbind
-            unless _binding?
-              _binding do
-                target.do_or_do_not(metadata.inverse_setter(target), nil)
-              end
+          def unbind_one
+            binding do
+              target.do_or_do_not(metadata.inverse_setter(target), nil)
             end
           end
-          alias :unbind_one :unbind
         end
       end
     end