mongoid_heroku_stable 4.0.0

data/lib/mongoid/relations/auto_save.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+
+    # This module contains the behaviour for auto-saving relations in
+    # different collections.
+    module AutoSave
+      extend ActiveSupport::Concern
+
+      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.__autosaving__
+      #
+      # @since 3.1.3
+      def __autosaving__
+        Threaded.begin_autosave(self)
+        yield
+      ensure
+        Threaded.exit_autosave(self)
+      end
+
+      # Check if there is changes for auto-saving
+      #
+      # @example Return true if there is changes on self or in
+      #           autosaved relations.
+      #   document.changed_for_autosave?
+      #
+      # @since 3.1.3
+      def changed_for_autosave?
+        new_record? || changed? || marked_for_destruction?
+      end
+
+      # Returns the relation, if it exists
+      #
+      # @since 3.1.3
+      def relation_changed_for_autosave(metadata)
+        ivar(metadata.name) if self.class.autosaved_relations.include?(metadata.name)
+      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
+        # saved automatically when the parent saved, if they are dirty.
+        #
+        # @example Set up autosave options.
+        #   Person.autosave(metadata)
+        #
+        # @param [ Metadata ] metadata The relation metadata.
+        #
+        # @since 2.0.0.rc.1
+        def autosave(metadata)
+          if metadata.autosave? && autosavable?(metadata)
+            autosaved_relations.push(metadata.name)
+            set_callback :save, :after, unless: :autosaved? do |document|
+              if before_callback_halted?
+                self.before_callback_halted = false
+              else
+                __autosaving__ do
+                  if document.changed_for_autosave? || relation = document.relation_changed_for_autosave(metadata)
+                    relation = document.__send__(metadata.name) unless relation
+                    (relation.do_or_do_not(:in_memory) || Array.wrap(relation)).each do |doc|
+                      doc.save
+                    end if relation
+                  end
+                end
+              end
+            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
+end

data/lib/mongoid/relations/binding.rb

@@ -0,0 +1,218 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+
+    # Superclass for all objects that bind relations together.
+    class Binding
+      include Threaded::Lifecycle
+
+      attr_reader :base, :target, :metadata
+
+      # Create the new binding.
+      #
+      # @example Initialize a binding.
+      #   Binding.new(base, target, metadata)
+      #
+      # @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.
+      #
+      # @since 2.0.0.rc.1
+      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 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, record_id(base))
+        bind_polymorphic_type(doc, base.class.name)
+        bind_inverse(doc, base)
+      end
+
+      def record_id(base)
+        base.__send__(metadata.primary_key)
+      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)
+      end
+    end
+  end
+end

data/lib/mongoid/relations/bindings.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+require "mongoid/relations/binding"
+require "mongoid/relations/bindings/embedded/in"
+require "mongoid/relations/bindings/embedded/many"
+require "mongoid/relations/bindings/embedded/one"
+require "mongoid/relations/bindings/referenced/in"
+require "mongoid/relations/bindings/referenced/many"
+require "mongoid/relations/bindings/referenced/many_to_many"
+require "mongoid/relations/bindings/referenced/one"

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

@@ -0,0 +1,63 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module Bindings
+      module Embedded
+
+        # Binding class for embedded_in relations.
+        class In < 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 the documents.
+          #   name.person.bind(:continue => true)
+          #   name.person = Person.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_one
+            base.metadata = metadata.inverse_metadata(target) unless base.metadata
+            base.parentize(target)
+            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
+
+          # Unbinds the base object and the inverse, caused by setting the
+          # reference to nil.
+          #
+          # @example Unbind the document.
+          #   name.person.unbind(:continue => true)
+          #   name.person = nil
+          #
+          # @param [ Hash ] options The options to pass through.
+          #
+          # @option options [ true, false ] :continue Do we continue unbinding?
+          #
+          # @since 2.0.0.rc.1
+          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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module Bindings
+      module Embedded
+
+        # Binding class for embeds_many relations.
+        class Many < Binding
+
+          # Binds a single document with the inverse relation. Used
+          # specifically when appending to the proxy.
+          #
+          # @example Bind one document.
+          #   person.addresses.bind_one(address)
+          #
+          # @param [ Document ] doc The single document to bind.
+          # @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_one(doc)
+            doc.parentize(base)
+            binding do
+              doc.do_or_do_not(metadata.inverse_setter(target), base)
+            end
+          end
+
+          # Unbind a single document.
+          #
+          # @example Unbind the document.
+          #   person.addresses.unbind_one(document)
+          #
+          # @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_one(doc)
+            binding do
+              doc.do_or_do_not(metadata.inverse_setter(target), nil)
+            end
+          end
+        end
+      end
+    end
+  end
+end