mongoid-multi-db 3.0.0

data/lib/mongoid/relations/accessors.rb

@@ -0,0 +1,138 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # 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 }, metadata)
+      #
+      # @param [ String, Symbol ] name The name of the relation.
+      # @param [ Hash, BSON::ObjectId ] object The id or attributes to use.
+      # @param [ Metadata ] metadata The relation's metadata.
+      # @param [ true, false ] building If we are in a build operation.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 2.0.0.rc.1
+      def build(name, object, metadata)
+        relation = create_relation(object, metadata)
+        set_relation(name, relation)
+      end
+
+      # Create a relation from an object and metadata.
+      #
+      # @example Create the relation.
+      #   person.create_relation(document, metadata)
+      #
+      # @param [ Document, Array<Document ] object The relation target.
+      # @param [ Metadata ] metadata The relation metadata.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 2.0.0.rc.1
+      def create_relation(object, metadata)
+        type = @attributes[metadata.inverse_type]
+        target = metadata.builder(self, object).build(type)
+        target ? metadata.relation.new(self, target, metadata) : nil
+      end
+
+      # Determines if the relation exists or not.
+      #
+      # @example Does the relation exist?
+      #   person.relation_exists?(:people)
+      #
+      # @param [ String ] name The name of the relation to check.
+      #
+      # @return [ true, false ] True if set and not nil, false if not.
+      #
+      # @since 2.0.0.rc.1
+      def relation_exists?(name)
+        ivar(name)
+      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
+
+      module ClassMethods #:nodoc:
+
+        # 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.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.
+        #
+        # @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
+              end
+            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.setter("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.
+        #
+        # @since 2.0.0.rc.1
+        def setter(name, metadata)
+          tap do
+            define_method("#{name}=") do |object|
+              if relation_exists?(name) || metadata.many? ||
+                (object.blank? && send(name))
+                set_relation(name, send(name).substitute(object.substitutable))
+              else
+                build(name, object.substitutable, metadata)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/auto_save.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # This module contains the behaviour for auto-saving relations in
+    # different collections.
+    module AutoSave
+      extend ActiveSupport::Concern
+
+      module ClassMethods #:nodoc:
+
+        # 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 is first saved, but not if the
+        # parent already exists in the database.
+        #
+        # @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?
+            set_callback :save, :after do |document|
+              relation = document.send(metadata.name)
+              if relation
+                (relation.do_or_do_not(:in_memory) || relation.to_a).each do |doc|
+                  doc.save
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/binding.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # 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
+    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,69 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Bindings #:nodoc:
+      module Embedded #:nodoc:
+
+        # 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
+            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
+              end
+            end
+          end
+          alias :bind_one :bind
+
+          # 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
+            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
+              end
+            end
+          end
+          alias :unbind_one :unbind
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Bindings #:nodoc:
+      module Embedded #:nodoc:
+
+        # 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.
+          #
+          # @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)
+            unless _binding?
+              _binding do
+                unless metadata.versioned?
+                  doc.do_or_do_not(metadata.inverse_setter(target), base)
+                end
+              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.
+          #   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)
+            unless _binding?
+              _binding do
+                doc.do_or_do_not(metadata.inverse_setter(target), nil)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Bindings #:nodoc:
+      module Embedded #:nodoc:
+
+        # Binding class for embeds_one relations.
+        class One < 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 document.
+          #   person.name.bind(:continue => true)
+          #   person.name = Name.new
+          #
+          # @param [ Hash ] options The options to pass through.
+          #
+          # @option options [ true, false ] :continue Do we continue binding?
+          # @option options [ true, false ] :binding Are we in build mode?
+          #
+          # @since 2.0.0.rc.1
+          def bind
+            target.parentize(base)
+            unless _binding?
+              _binding do
+                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.
+          #
+          # @example Unbind the document.
+          #   person.name.unbind(:continue => true)
+          #   person.name = nil
+          #
+          # @param [ Hash ] options The options to pass through.
+          #
+          # @option options [ true, false ] :continue Do we continue unbinding?
+          # @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
+            end
+          end
+          alias :unbind_one :unbind
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Bindings #:nodoc:
+      module Referenced #:nodoc:
+
+        # Binding class for all referenced_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.
+          #   game.person.bind(:continue => true)
+          #   game.person = Person.new
+          #
+          # @since 2.0.0.rc.1
+          def bind
+            unless _binding?
+              _binding do
+                inverse = metadata.inverse(target)
+                base.you_must(metadata.foreign_key_setter, target.id)
+                if metadata.inverse_type
+                  base.you_must(metadata.inverse_type_setter, target.class.model_name)
+                end
+                if inverse
+                  inverse_metadata = metadata.inverse_metadata(target)
+                  if inverse_metadata != metadata && !inverse_metadata.nil?
+                    base.metadata = inverse_metadata
+                    if base.referenced_many?
+                      target.send(inverse).push(base) unless Mongoid.identity_map_enabled?
+                    else
+                      target.do_or_do_not(metadata.inverse_setter(target), base)
+                    end
+                  end
+                end
+              end
+            end
+          end
+          alias :bind_one :bind
+
+          # Unbinds the base object and the inverse, caused by setting the
+          # reference to nil.
+          #
+          # @example Unbind the document.
+          #   game.person.unbind(:continue => true)
+          #   game.person = nil
+          #
+          # @since 2.0.0.rc.1
+          def unbind
+            unless _binding?
+              _binding do
+                inverse = metadata.inverse(target)
+                base.you_must(metadata.foreign_key_setter, nil)
+                if metadata.inverse_type
+                  base.you_must(metadata.inverse_type_setter, nil)
+                end
+                if inverse
+                  if base.referenced_many?
+                    target.send(inverse).delete(base)
+                  else
+                    target.send(metadata.inverse_setter(target), nil)
+                  end
+                end
+              end
+            end
+          end
+          alias :unbind_one :unbind
+        end
+      end
+    end
+  end
+end