mongoid-multi-db 3.0.0

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

@@ -0,0 +1,206 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Embedded #:nodoc:
+
+      # This class defines the behaviour needed for embedded one to one
+      # relations.
+      class One < Relations::One
+
+        # Instantiate a new embeds_one relation.
+        #
+        # @example Create the new proxy.
+        #   One.new(person, name, metadata)
+        #
+        # @param [ Document ] base The document this relation hangs off of.
+        # @param [ Document ] target The child document in the relation.
+        # @param [ Metadata ] metadata The relation's metadata
+        def initialize(base, target, metadata)
+          init(base, target, metadata) do
+            characterize_one(target)
+            bind_one
+            target.save if persistable?
+          end
+        end
+
+        # Substitutes the supplied target documents for the existing document
+        # in the relation.
+        #
+        # @example Substitute the new document.
+        #   person.name.substitute(new_name)
+        #
+        # @param [ Document ] other A document to replace the target.
+        #
+        # @return [ Document, nil ] The relation or nil.
+        #
+        # @since 2.0.0.rc.1
+        def substitute(replacement)
+          tap do |proxy|
+            if _assigning?
+              base.atomic_unsets.push(proxy.atomic_path)
+            else
+              proxy.delete if persistable?
+            end
+            proxy.unbind_one
+            return nil unless replacement
+            proxy.target = replacement
+            proxy.bind_one
+          end
+        end
+
+        private
+
+        # Instantiate the binding associated with this relation.
+        #
+        # @example Get the binding.
+        #   relation.binding([ address ])
+        #
+        # @param [ Document ] new_target The new document to bind with.
+        #
+        # @return [ Binding ] The relation's binding.
+        #
+        # @since 2.0.0.rc.1
+        def binding
+          Bindings::Embedded::One.new(base, target, metadata)
+        end
+
+        # Are we able to persist this relation?
+        #
+        # @example Can we persist the relation?
+        #   relation.persistable?
+        #
+        # @return [ true, false ] If the relation is persistable.
+        #
+        # @since 2.1.0
+        def persistable?
+          base.persisted? && !_binding? && !_building? && !_assigning?
+        end
+
+        class << self
+
+          # Return the builder that is responsible for generating the documents
+          # that will be used by this relation.
+          #
+          # @example Get the builder.
+          #   Embedded::One.builder(meta, object, person)
+          #
+          # @param [ Document ] base The base document.
+          # @param [ Metadata ] meta The metadata of the relation.
+          # @param [ Document, Hash ] object A document or attributes to build with.
+          #
+          # @return [ Builder ] A newly instantiated builder object.
+          #
+          # @since 2.0.0.rc.1
+          def builder(base, meta, object)
+            Builders::Embedded::One.new(base, meta, object)
+          end
+
+          # Returns true if the relation is an embedded one. In this case
+          # always true.
+          #
+          # @example Is this relation embedded?
+          #   Embedded::One.embedded?
+          #
+          # @return [ true ] true.
+          #
+          # @since 2.0.0.rc.1
+          def embedded?
+            true
+          end
+
+          # Returns the macro for this relation. Used mostly as a helper in
+          # reflection.
+          #
+          # @example Get the macro.
+          #   Mongoid::Relations::Embedded::One.macro
+          #
+          # @return [ Symbol ] :embeds_one.
+          #
+          # @since 2.0.0.rc.1
+          def macro
+            :embeds_one
+          end
+
+          # Return the nested builder that is responsible for generating
+          # the documents that will be used by this relation.
+          #
+          # @example Get the builder.
+          #   NestedAttributes::One.builder(attributes, options)
+          #
+          # @param [ Metadata ] metadata The relation metadata.
+          # @param [ Hash ] attributes The attributes to build with.
+          # @param [ Hash ] options The options for the builder.
+          #
+          # @option options [ true, false ] :allow_destroy Can documents be
+          #   deleted?
+          # @option options [ Integer ] :limit Max number of documents to
+          #   create at once.
+          # @option options [ Proc, Symbol ] :reject_if If documents match this
+          #   option then they are ignored.
+          # @option options [ true, false ] :update_only Only existing documents
+          #   can be modified.
+          #
+          # @return [ Builder ] A newly instantiated nested builder object.
+          #
+          # @since 2.0.0.rc.1
+          def nested_builder(metadata, attributes, options)
+            Builders::NestedAttributes::One.new(metadata, attributes, options)
+          end
+
+          # Get the path calculator for the supplied document.
+          #
+          # @example Get the path calculator.
+          #   Proxy.path(document)
+          #
+          # @param [ Document ] document The document to calculate on.
+          #
+          # @return [ Mongoid::Atomic::Paths::Embedded::One ]
+          #   The embedded one atomic path calculator.
+          #
+          # @since 2.1.0
+          def path(document)
+            Mongoid::Atomic::Paths::Embedded::One.new(document)
+          end
+
+          # Tells the caller if this relation is one that stores the foreign
+          # key on its own objects.
+          #
+          # @example Does this relation store a foreign key?
+          #   Embedded::One.stores_foreign_key?
+          #
+          # @return [ false ] false.
+          #
+          # @since 2.0.0.rc.1
+          def stores_foreign_key?
+            false
+          end
+
+          # Get the valid options allowed with this relation.
+          #
+          # @example Get the valid options.
+          #   Relation.valid_options
+          #
+          # @return [ Array<Symbol> ] The valid options.
+          #
+          # @since 2.1.0
+          def valid_options
+            [ :as, :cascade_callbacks, :cyclic ]
+          end
+
+          # Get the default validation setting for the relation. Determines if
+          # by default a validates associated will occur.
+          #
+          # @example Get the validation default.
+          #   Proxy.validation_default
+          #
+          # @return [ true, false ] The validation default.
+          #
+          # @since 2.1.9
+          def validation_default
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/embedded/sort.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Embedded #:nodoc:
+
+      # This module handles embedded associations sorting
+      # Since mongodb doesn't have virtual collection for embedded docs yet
+      # (see https://jira.mongodb.org/browse/SERVER-142 for details)
+      # Sorting implemented in ruby
+	    # This can be a performance killer on collections with many embedded documents
+	    module Sort
+
+        # Sorts documents
+        #
+        # @param [ Array<Documents> ] documents array of documents
+        # @param [ Mongoid::Relations::Metadata ] metadata association metadata
+        def sort_documents!(documents, metadata)
+          sort_options = Criteria.new(metadata.klass).order_by(metadata.order).options[:sort]
+
+          docs = documents.sort_by do |document|
+            sort_options.map do |key, direction|
+              Contexts::Enumerable::Sort.new(document.read_attribute(key), direction)
+            end
+          end
+          documents.replace(docs)
+        end
+	    end
+    end
+  end
+end
+

data/lib/mongoid/relations/macros.rb

@@ -0,0 +1,310 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # This module contains the core macros for defining relations between
+    # documents. They can be either embedded or referenced (relational).
+    module Macros
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :embedded, :instance_reader => false
+        class_attribute :relations
+        self.embedded = false
+        self.relations = {}
+      end
+
+      # This is convenience for librarys still on the old API.
+      #
+      # @example Get the associations.
+      #   person.associations
+      #
+      # @return [ Hash ] The relations.
+      #
+      # @since 2.3.1
+      def associations
+        self.relations
+      end
+
+      module ClassMethods #:nodoc:
+
+        # Adds the relation back to the parent document. This macro is
+        # necessary to set the references from the child back to the parent
+        # document. If a child does not define this relation calling
+        # persistence methods on the child object will cause a save to fail.
+        #
+        # @example Define the relation.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     embeds_many :addresses
+        #   end
+        #
+        #   class Address
+        #     include Mongoid::Document
+        #     embedded_in :person
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def embedded_in(name, options = {}, &block)
+          characterize(name, Embedded::In, options, &block).tap do |meta|
+            self.embedded = true
+            relate(name, meta)
+          end
+        end
+
+        # Adds the relation from a parent document to its children. The name
+        # of the relation needs to be a pluralized form of the child class
+        # name.
+        #
+        # @example Define the relation.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     embeds_many :addresses
+        #   end
+        #
+        #   class Address
+        #     include Mongoid::Document
+        #     embedded_in :person
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def embeds_many(name, options = {}, &block)
+          characterize(name, Embedded::Many, options, &block).tap do |meta|
+            relate(name, meta)
+            validates_relation(meta)
+          end
+        end
+
+        # Adds the relation from a parent document to its child. The name
+        # of the relation needs to be a singular form of the child class
+        # name.
+        #
+        # @example Define the relation.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     embeds_one :name
+        #   end
+        #
+        #   class Name
+        #     include Mongoid::Document
+        #     embedded_in :person
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def embeds_one(name, options = {}, &block)
+          characterize(name, Embedded::One, options, &block).tap do |meta|
+            relate(name, meta)
+            builder(name, meta).creator(name)
+            validates_relation(meta)
+          end
+        end
+
+        # Adds a relational association from the child Document to a Document in
+        # another database or collection.
+        #
+        # @example Define the relation.
+        #
+        #   class Game
+        #     include Mongoid::Document
+        #     belongs_to :person
+        #   end
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     has_one :game
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def belongs_to(name, options = {}, &block)
+          characterize(name, Referenced::In, options, &block).tap do |meta|
+            relate(name, meta)
+            reference(meta)
+            autosave(meta)
+            validates_relation(meta)
+          end
+        end
+        alias :belongs_to_related :belongs_to
+        alias :referenced_in :belongs_to
+
+        # Adds a relational association from a parent Document to many
+        # Documents in another database or collection.
+        #
+        # @example Define the relation.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     has_many :posts
+        #   end
+        #
+        #   class Game
+        #     include Mongoid::Document
+        #     belongs_to :person
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def has_many(name, options = {}, &block)
+          characterize(name, Referenced::Many, options, &block).tap do |meta|
+            relate(name, meta)
+            reference(meta)
+            autosave(meta)
+            validates_relation(meta)
+          end
+        end
+        alias :has_many_related :has_many
+        alias :references_many :has_many
+
+        # Adds a relational many-to-many association between many of this
+        # Document and many of another Document.
+        #
+        # @example Define the relation.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     has_and_belongs_to_many :preferences
+        #   end
+        #
+        #   class Preference
+        #     include Mongoid::Document
+        #     has_and_belongs_to_many :people
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        #
+        # @since 2.0.0.rc.1
+        def has_and_belongs_to_many(name, options = {}, &block)
+          characterize(name, Referenced::ManyToMany, options, &block).tap do |meta|
+            relate(name, meta)
+            reference(meta, Array)
+            autosave(meta)
+            validates_relation(meta)
+            synced(meta)
+          end
+        end
+        alias :references_and_referenced_in_many :has_and_belongs_to_many
+
+        # Adds a relational association from the child Document to a Document in
+        # another database or collection.
+        #
+        # @example Define the relation.
+        #
+        #   class Game
+        #     include Mongoid::Document
+        #     belongs_to :person
+        #   end
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     has_one :game
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def has_one(name, options = {}, &block)
+          characterize(name, Referenced::One, options, &block).tap do |meta|
+            relate(name, meta)
+            reference(meta)
+            builder(name, meta).creator(name).autosave(meta)
+            validates_relation(meta)
+          end
+        end
+        alias :has_one_related :has_one
+        alias :references_one :has_one
+
+        private
+
+        # Create the metadata for the relation.
+        #
+        # @example Create the metadata.
+        #   Person.characterize(:posts, Referenced::Many, {})
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Object ] relation The type of relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        #
+        # @return [ Metadata ] The metadata for the relation.
+        def characterize(name, relation, options, &block)
+          Metadata.new({
+            :relation => relation,
+            :extend => create_extension_module(name, &block),
+            :inverse_class_name => self.name,
+            :name => name
+          }.merge(options))
+        end
+
+        # Generate a named extension module suitable for marshaling
+        #
+        # @example Get the module.
+        #   Person.create_extension_module(:posts, &block)
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Proc ] block Optional block for defining extensions.
+        #
+        # @return [ Module, nil ] The extension or nil.
+        #
+        # @since 2.1.0
+        def create_extension_module(name, &block)
+          if block
+            extension_module_name =
+              "#{self.to_s.demodulize}#{name.to_s.camelize}RelationExtension"
+            silence_warnings do
+              self.const_set(extension_module_name, Module.new(&block))
+            end
+            "#{self}::#{extension_module_name}".constantize
+          end
+        end
+
+        # Defines a field to be used as a foreign key in the relation and
+        # indexes it if defined.
+        #
+        # @example Set up the relational fields and indexes.
+        #   Person.reference(metadata)
+        #
+        # @param [ Metadata ] metadata The metadata for the relation.
+        def reference(metadata, type = Object)
+          polymorph(metadata).cascade(metadata)
+          if metadata.relation.stores_foreign_key?
+            key = metadata.foreign_key
+            field(
+              key,
+              :type => type,
+              :identity => true,
+              :metadata => metadata,
+              :default => metadata.foreign_key_default
+            )
+            index(key, :background => true) if metadata.indexed?
+          end
+        end
+
+        # Creates a relation for the given name, metadata and relation. It adds
+        # the metadata to the relations hash and has the accessors set up.
+        #
+        # @example Set up the relation and accessors.
+        #   Person.relate(:addresses, Metadata)
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Metadata ] metadata The metadata for the relation.
+        def relate(name, metadata)
+          self.relations = relations.merge(name.to_s => metadata)
+          getter(name, metadata).setter(name, metadata)
+        end
+      end
+    end
+  end
+end