mongoid 2.0.2 → 2.1.0

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

@@ -7,28 +7,6 @@ module Mongoid # :nodoc:
       # relations.
       class One < Relations::One
 
-        # Binds the base object to the inverse of the relation. This is so we
-        # are referenced to the actual objects themselves and dont hit the
-        # database twice when setting the relations up.
-        #
-        # This is called after first creating the relation, or if a new object
-        # is set on the relation.
-        #
-        # @example Bind the relation.
-        #   person.name.bind(:continue => false)
-        #
-        # @param [ Hash ] options The options to bind with.
-        #
-        # @option options [ true, false ] :binding Are we in build mode?
-        # @option options [ true, false ] :continue Continue binding the
-        #   inverse?
-        #
-        # @since 2.0.0.rc.1
-        def bind(options = {})
-          binding.bind(options)
-          target.save if base.persisted? && !options[:binding]
-        end
-
         # Instantiate a new embeds_one relation.
         #
         # @example Create the new proxy.
@@ -40,29 +18,30 @@ module Mongoid # :nodoc:
         def initialize(base, target, metadata)
           init(base, target, metadata) do
             characterize_one(target)
-            target.parentize(base)
+            bind_one
+            target.save if persistable?
           end
         end
 
-        # Unbinds the base object to the inverse of the relation. This occurs
-        # when setting a side of the relation to nil.
-        #
-        # Will delete the object if necessary.
+        # Substitutes the supplied target documents for the existing document
+        # in the relation.
         #
-        # @example Unbind the relation.
-        #   person.name.unbind(name, :continue => true)
+        # @example Substitute the new document.
+        #   person.name.substitute(new_name)
         #
-        # @param [ Document ] old_target The previous target of the relation.
-        # @param [ Hash ] options The options to bind with.
+        # @param [ Document ] other A document to replace the target.
         #
-        # @option options [ true, false ] :binding Are we in build mode?
-        # @option options [ true, false ] :continue Continue binding the
-        #   inverse?
+        # @return [ Document, nil ] The relation or nil.
         #
         # @since 2.0.0.rc.1
-        def unbind(old_target, options = {})
-          binding(old_target).unbind(options)
-          old_target.delete if base.persisted? && !old_target.destroyed?
+        def substitute(replacement)
+          tap do |proxy|
+            proxy.delete
+            proxy.unbind_one
+            return nil unless replacement
+            proxy.target = replacement
+            proxy.bind_one
+          end
         end
 
         private
@@ -77,8 +56,20 @@ module Mongoid # :nodoc:
         # @return [ Binding ] The relation's binding.
         #
         # @since 2.0.0.rc.1
-        def binding(new_target = nil)
-          Bindings::Embedded::One.new(base, new_target || target, metadata)
+        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?
         end
 
         class << self
@@ -95,8 +86,8 @@ module Mongoid # :nodoc:
           # @return [ Builder ] A newly instantiated builder object.
           #
           # @since 2.0.0.rc.1
-          def builder(meta, object)
-            Builders::Embedded::One.new(meta, object)
+          def builder(meta, object, loading = false)
+            Builders::Embedded::One.new(meta, object, loading)
           end
 
           # Returns true if the relation is an embedded one. In this case
@@ -151,6 +142,21 @@ module Mongoid # :nodoc:
             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.
           #
@@ -163,6 +169,18 @@ module Mongoid # :nodoc:
           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, :cyclic ]
+          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

@@ -157,7 +157,6 @@ module Mongoid # :nodoc:
         # @param [ Hash ] options The relation options.
         # @param [ Proc ] block Optional block for defining extensions.
         def references_many(name, options = {}, &block)
-          check_options(options)
           characterize(name, Referenced::Many, options, &block).tap do |meta|
             relate(name, meta)
             reference(meta)
@@ -191,8 +190,10 @@ module Mongoid # :nodoc:
         def references_and_referenced_in_many(name, options = {}, &block)
           characterize(name, Referenced::ManyToMany, options, &block).tap do |meta|
             relate(name, meta)
-            reference(meta)
+            reference(meta, Array)
+            autosave(meta)
             validates_relation(meta)
+            synced(meta)
           end
         end
         alias :has_and_belongs_to_many :references_and_referenced_in_many
@@ -228,26 +229,6 @@ module Mongoid # :nodoc:
 
         private
 
-        # Temporary check while people switch over to the new macro. Will be
-        # deleted in 2.0.0.
-        #
-        # @example Check the options.
-        #   Person.check_options({})
-        #
-        # @param [ Hash ] options The options given to the relational many.
-        #
-        # @raise [ RuntimeError ] If :stored_as => :array is found.
-        #
-        # @since 2.0.0.rc.1
-        def check_options(options = {})
-          if options[:stored_as] == :array
-            raise RuntimeError.new(
-              "Macro: references_many :name, :stored_as => :array " <<
-              "Is no longer valid. Please use: references_and_referenced_in_many :name"
-            )
-          end
-        end
-
         # Create the metadata for the relation.
         #
         # @example Create the metadata.
@@ -263,13 +244,35 @@ module Mongoid # :nodoc:
           Metadata.new(
             options.merge(
               :relation => relation,
-              :extend => block,
+              :extend => create_extension_module(name, &block),
               :inverse_class_name => self.name,
               :name => name
             )
           )
         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.
         #
@@ -277,12 +280,13 @@ module Mongoid # :nodoc:
         #   Person.reference(metadata)
         #
         # @param [ Metadata ] metadata The metadata for the relation.
-        def reference(metadata)
+        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

data/lib/mongoid/relations/many.rb

@@ -7,85 +7,18 @@ module Mongoid #:nodoc:
     class Many < Proxy
 
       delegate :avg, :max, :min, :sum, :to => :criteria
+      delegate :length, :size, :to => :target
 
-      # Appends a document or array of documents to the relation. Will set
-      # the parent and update the index in the process.
-      #
-      # @example Append a document.
-      #   person.addresses << address
-      #
-      # @example Push a document.
-      #   person.addresses.push(address)
-      #
-      # @example Concat with other documents.
-      #   person.addresses.concat([ address_one, address_two ])
-      #
-      # @param [ Document, Array<Document> ] *args Any number of documents.
-      def <<(*args)
-        options = default_options(args)
-        args.flatten.each do |doc|
-          return doc unless doc
-          append(doc, options)
-          doc.save if base.persisted? && !options[:binding]
-        end
-      end
-      alias :concat :<<
-      alias :push :<<
-
-      # Builds a new document in the relation and appends it to the target.
-      # Takes an optional type if you want to specify a subclass.
-      #
-      # @example Build a new document on the relation.
-      #   person.people.build(:name => "Bozo")
-      #
-      # @param [ Hash ] attributes The attributes to build the document with.
-      # @param [ Class ] type Optional class to build the document with.
-      #
-      # @return [ Document ] The new document.
-      def build(attributes = {}, type = nil, &block)
-        instantiated(type).tap do |doc|
-          doc.write_attributes(attributes)
-          doc.identify
-          append(doc, default_options(:binding => true))
-          block.call(doc) if block
-        end
-      end
-      alias :new :build
-
-      # Creates a new document on the references many relation. This will
-      # save the document if the parent has been persisted.
+      # Is the relation empty?
       #
-      # @example Create and save the new document.
-      #   person.posts.create(:text => "Testing")
+      # @example Is the relation empty??
+      #   person.addresses.blank?
       #
-      # @param [ Hash ] attributes The attributes to create with.
-      # @param [ Class ] type The optional type of document to create.
+      # @return [ true, false ] If the relation is empty or not.
       #
-      # @return [ Document ] The newly created document.
-      def create(attributes = nil, type = nil, &block)
-        build(attributes, type).tap do |doc|
-          block.call(doc) if block
-          doc.save if base.persisted?
-        end
-      end
-
-      # Creates a new document on the references many relation. This will
-      # save the document if the parent has been persisted and will raise an
-      # error if validation fails.
-      #
-      # @example Create and save the new document.
-      #   person.posts.create!(:text => "Testing")
-      #
-      # @param [ Hash ] attributes The attributes to create with.
-      # @param [ Class ] type The optional type of document to create.
-      #
-      # @raise [ Errors::Validations ] If validation failed.
-      #
-      # @return [ Document ] The newly created document.
-      def create!(attributes = nil, type = nil)
-        build(attributes, type).tap do |doc|
-          doc.save! if base.persisted?
-        end
+      # @since 2.1.0
+      def blank?
+        size == 0
       end
 
       # Determine if any documents in this relation exist in the database.
@@ -146,8 +79,8 @@ module Mongoid #:nodoc:
       # @return [ true, false ] If the proxy responds to the method.
       #
       # @since 2.0.0
-      def respond_to?(name)
-        [].respond_to?(name) || methods.include?(name)
+      def respond_to?(name, include_private = false)
+        [].respond_to?(name, include_private) || super
       end
 
       # Gets the document as a serializable hash, used by ActiveModel's JSON and
@@ -170,34 +103,8 @@ module Mongoid #:nodoc:
         target.map { |document| document.serializable_hash(options) }
       end
 
-      # Always returns the number of documents that are in memory.
-      #
-      # @example Get the number of loaded documents.
-      #   relation.size
-      #
-      # @return [ Integer ] The number of documents in memory.
-      #
-      # @since 2.0.0
-      def size
-        target.size
-      end
-      alias :length :size
-
       private
 
-      # Get the default options used in binding functions.
-      #
-      # @example Get the default options.
-      #   relation.default_options(:continue => true)
-      #
-      # @param [ Hash, Array ] args The arguments to parse from.
-      #
-      # @return [ Hash ] The options merged with the actuals.
-      def default_options(args = {})
-        options = args.is_a?(Hash) ? args : args.extract_options!
-        Mongoid.binding_defaults.merge(options)
-      end
-
       # Find the first object given the supplied attributes or create/initialize it.
       #
       # @example Find or create|initialize.

data/lib/mongoid/relations/metadata.rb

@@ -8,6 +8,54 @@ module Mongoid # :nodoc:
 
       delegate :foreign_key_default, :stores_foreign_key?, :to => :relation
 
+      # Returns the as option of the relation.
+      #
+      # @example Get the as option.
+      #   metadata.as
+      #
+      # @return [ true, false ] The as option.
+      #
+      # @since 2.1.0
+      def as
+        self[:as]
+      end
+
+      # Tells whether an as option exists.
+      #
+      # @example Is the as option set?
+      #   metadata.as?
+      #
+      # @return [ true, false ] True if an as exists, false if not.
+      #
+      # @since 2.0.0.rc.1
+      def as?
+        !!as
+      end
+
+      # Returns the autosave option of the relation.
+      #
+      # @example Get the autosave option.
+      #   metadata.autosave
+      #
+      # @return [ true, false ] The autosave option.
+      #
+      # @since 2.1.0
+      def autosave
+        self[:autosave]
+      end
+
+      # Does the metadata have a autosave option?
+      #
+      # @example Is the relation autosaving?
+      #   metadata.autosave?
+      #
+      # @return [ true, false ] If the relation autosaves.
+      #
+      # @since 2.1.0
+      def autosave?
+        !!autosave
+      end
+
       # Gets a relation builder associated with the relation this metadata is
       # for.
       #
@@ -19,8 +67,8 @@ module Mongoid # :nodoc:
       # @return [ Builder ] The builder for the relation.
       #
       # @since 2.0.0.rc.1
-      def builder(object)
-        relation.builder(self, object)
+      def builder(object, loading = false)
+        relation.builder(self, object, loading)
       end
 
       # Returns the name of the strategy used for handling dependent relations.
@@ -55,10 +103,81 @@ module Mongoid # :nodoc:
         @class_name ||= (self[:class_name] || classify)
       end
 
+      # Get the foreign key contraint for the metadata.
+      #
+      # @example Get the constaint.
+      #   metadata.constraint
+      #
+      # @return [ Constraint ] The constraint.
+      #
+      # @since 2.0.0.rc.1
       def constraint
         @constraint ||= Constraint.new(self)
       end
 
+      # Get the criteria that is used to query for this metadata's relation.
+      #
+      # @example Get the criteria.
+      #   metadata.criteria([ id_one, id_two ])
+      #
+      # @param [ Object ] object The foreign key used for the query.
+      #
+      # @return [ Criteria ] The criteria.
+      #
+      # @since 2.1.0
+      def criteria(object, type = nil)
+        query = relation.criteria(self, object, type)
+        order ? query.order_by(order) : query
+      end
+
+      # Returns the cyclic option of the relation.
+      #
+      # @example Get the cyclic option.
+      #   metadata.cyclic
+      #
+      # @return [ true, false ] The cyclic option.
+      #
+      # @since 2.1.0
+      def cyclic
+        self[:cyclic]
+      end
+
+      # Does the metadata have a cyclic option?
+      #
+      # @example Is the metadata cyclic?
+      #   metadata.cyclic?
+      #
+      # @return [ true, false ] If the metadata is cyclic.
+      #
+      # @since 2.1.0
+      def cyclic?
+        !!cyclic
+      end
+
+      # Returns the dependent option of the relation.
+      #
+      # @example Get the dependent option.
+      #   metadata.dependent
+      #
+      # @return [ Symbol ] The dependent option.
+      #
+      # @since 2.1.0
+      def dependent
+        self[:dependent]
+      end
+
+      # Does the metadata have a dependent option?
+      #
+      # @example Is the metadata performing cascades?
+      #   metadata.dependent?
+      #
+      # @return [ true, false ] If the metadata cascades.
+      #
+      # @since 2.1.0
+      def dependent?
+        !!dependent
+      end
+
       # Will determine if the relation is an embedded one or not. Currently
       # only checks against embeds one and many.
       #
@@ -72,12 +191,12 @@ module Mongoid # :nodoc:
         @embedded ||= (macro == :embeds_one || macro == :embeds_many)
       end
 
-      # Returns the extension of the relation. This can be a proc or module.
+      # Returns the extension of the relation.
       #
       # @example Get the relation extension.
       #   metadata.extension
       #
-      # @return [ Proc ] The extension or nil.
+      # @return [ Module ] The extension or nil.
       #
       # @since 2.0.0.rc.1
       def extension
@@ -115,6 +234,18 @@ module Mongoid # :nodoc:
         @foreign_key ||= determine_foreign_key
       end
 
+      # Get the name of the method to check if the foreign key has changed.
+      #
+      # @example Get the foreign key check method.
+      #   metadata.foreign_key_check
+      #
+      # @return [ String ] The foreign key check.
+      #
+      # @since 2.1.0
+      def foreign_key_check
+        @foreign_key_check ||= "#{foreign_key}_changed?"
+      end
+
       # Returns the name of the method used to set the foreign key on a
       # document.
       #
@@ -128,6 +259,18 @@ module Mongoid # :nodoc:
         @foreign_key_setter ||= "#{foreign_key}="
       end
 
+      # Returns the index option of the relation.
+      #
+      # @example Get the index option.
+      #   metadata.index
+      #
+      # @return [ true, false ] The index option.
+      #
+      # @since 2.1.0
+      def index
+        self[:index]
+      end
+
       # Tells whether a foreign key index exists on the relation.
       #
       # @example Is the key indexed?
@@ -137,7 +280,7 @@ module Mongoid # :nodoc:
       #
       # @since 2.0.0.rc.1
       def indexed?
-        !!self[:index]
+        !!index
       end
 
       # Instantiate new metadata for a relation.
@@ -149,6 +292,7 @@ module Mongoid # :nodoc:
       #
       # @since 2.0.0.rc.1
       def initialize(properties = {})
+        Options.validate!(properties)
         merge!(properties)
       end
 
@@ -168,15 +312,14 @@ module Mongoid # :nodoc:
         "  cyclic:               #{cyclic || "No"},\n" <<
         "  dependent:            #{dependent || "None"},\n" <<
         "  inverse_of:           #{inverse_of || "N/A"},\n" <<
-        "  inverse_setter:       #{inverse_setter},\n" <<
-        "  inverse_type:         #{inverse_type || "N/A"},\n" <<
-        "  inverse_type_setter:  #{inverse_type_setter || "N/A"},\n" <<
         "  key:                  #{key},\n" <<
         "  macro:                #{macro},\n" <<
         "  name:                 #{name},\n" <<
-        "  polymorphic:          #{polymorphic? ? "Yes" : "No"},\n" <<
+        "  order:                #{order.inspect || "No"},\n" <<
+        "  polymorphic:          #{polymorphic? || "No"},\n" <<
         "  relation:             #{relation},\n" <<
-        "  setter:               #{setter}>\n"
+        "  setter:               #{setter},\n" <<
+        "  versioned:            #{versioned? || "No"}>\n"
       end
 
       # Get the name of the inverse relation if it exists. If this is a
@@ -196,6 +339,30 @@ module Mongoid # :nodoc:
         @inverse ||= (cyclic? ? cyclic_inverse : inverse_relation)
       end
 
+      # Returns the inverse_class_name option of the relation.
+      #
+      # @example Get the inverse_class_name option.
+      #   metadata.inverse_class_name
+      #
+      # @return [ true, false ] The inverse_class_name option.
+      #
+      # @since 2.1.0
+      def inverse_class_name
+        self[:inverse_class_name]
+      end
+
+      # Returns the if the inverse class name option exists.
+      #
+      # @example Is an inverse class name defined?
+      #   metadata.inverse_class_name?
+      #
+      # @return [ true, false ] If the inverse if defined.
+      #
+      # @since 2.1.0
+      def inverse_class_name?
+        !!inverse_class_name
+      end
+
       # Used for relational many to many only. This determines the name of the
       # foreign key field on the inverse side of the relation, since in this
       # case there are keys on both sides.
@@ -224,6 +391,34 @@ module Mongoid # :nodoc:
         @inverse_klass ||= inverse_class_name.constantize
       end
 
+      def inverse_metadata(document)
+        document.reflect_on_association(inverse(document))
+      end
+
+      # Returns the inverse_of option of the relation.
+      #
+      # @example Get the inverse_of option.
+      #   metadata.inverse_of
+      #
+      # @return [ true, false ] The inverse_of option.
+      #
+      # @since 2.1.0
+      def inverse_of
+        self[:inverse_of]
+      end
+
+      # Does the metadata have a inverse_of option?
+      #
+      # @example Is an inverse_of defined?
+      #   metadata.inverse_of?
+      #
+      # @return [ true, false ] If the relation has an inverse_of defined.
+      #
+      # @since 2.1.0
+      def inverse_of?
+        !!inverse_of
+      end
+
       # Returns the setter for the inverse side of the relation.
       #
       # @example Get the inverse setter.
@@ -235,7 +430,7 @@ module Mongoid # :nodoc:
       #
       # @since 2.0.0.rc.1
       def inverse_setter(other = nil)
-        inverse(other).to_s << "="
+        "#{inverse(other)}="
       end
 
       # Returns the name of the field in which to store the name of the class
@@ -248,11 +443,8 @@ module Mongoid # :nodoc:
       #
       # @since 2.0.0.rc.1
       def inverse_type
-        if relation.stores_foreign_key? && polymorphic?
-          (polymorphic? ? name.to_s : class_name.underscore) << "_type"
-        else
-          return nil
-        end
+        @inverse_type ||=
+          relation.stores_foreign_key? && polymorphic? ? "#{name}_type" : nil
       end
 
       # Gets the setter for the field that sets the type of document on a
@@ -265,7 +457,7 @@ module Mongoid # :nodoc:
       #
       # @since 2.0.0.rc.1
       def inverse_type_setter
-        inverse_type ? inverse_type << "=" : nil
+        @inverse_type_setter ||= inverse_type ? "#{inverse_type}=" : nil
       end
 
       # This returns the key that is to be used to grab the attributes for the
@@ -306,6 +498,43 @@ module Mongoid # :nodoc:
         relation.macro
       end
 
+      # Get the name associated with this metadata.
+      #
+      # @example Get the name.
+      #   metadata.name
+      #
+      # @return [ Symbol ] The name.
+      #
+      # @since 2.1.0
+      def name
+        self[:name]
+      end
+
+      # Is the name defined?
+      #
+      # @example Is the name defined?
+      #   metadata.name?
+      #
+      # @return [ true, false ] If the name is defined.
+      #
+      # @since 2.1.0
+      def name?
+        !!name
+      end
+
+      # Does the relation have a destructive dependent option specified. This
+      # is true for :dependent => :delete and :dependent => :destroy.
+      #
+      # @example Is the relation destructive?
+      #   metadata.destructive?
+      #
+      # @return [ true, false ] If the relation is destructive.
+      #
+      # @since 2.1.0
+      def destructive?
+        @destructive ||= (dependent == :delete || dependent == :destroy)
+      end
+
       # Gets a relation nested builder associated with the relation this metadata
       # is for. Nested builders are used in conjunction with nested attributes.
       #
@@ -322,6 +551,20 @@ module Mongoid # :nodoc:
         relation.nested_builder(self, attributes, options)
       end
 
+      # Get the path calculator for the supplied document.
+      #
+      # @example Get the path calculator.
+      #   metadata.path(document)
+      #
+      # @param [ Document ] document The document to calculate on.
+      #
+      # @return [ Object ] The atomic path calculator.
+      #
+      # @since 2.1.0
+      def path(document)
+        relation.path(document)
+      end
+
       # Returns true if the relation is polymorphic.
       #
       # @example Is the relation polymorphic?
@@ -334,6 +577,18 @@ module Mongoid # :nodoc:
         @polymorphic ||= (!!self[:as] || !!self[:polymorphic])
       end
 
+      # Get the relation associated with this metadata.
+      #
+      # @example Get the relation.
+      #   metadata.relation
+      #
+      # @return [ Proxy ] The relation proxy class.
+      #
+      # @since 2.1.0
+      def relation
+        self[:relation]
+      end
+
       # Gets the method name used to set this relation.
       #
       # @example Get the setter.
@@ -347,6 +602,32 @@ module Mongoid # :nodoc:
         @setter ||= "#{name.to_s}="
       end
 
+      # Returns the name of the field in which to store the name of the class
+      # for the polymorphic relation.
+      #
+      # @example Get the name of the field.
+      #   metadata.inverse_type
+      #
+      # @return [ String ] The name of the field for storing the type.
+      #
+      # @since 2.0.0.rc.1
+      def type
+        @type ||= polymorphic? ? "#{as.to_s}_type" : nil
+      end
+
+      # Gets the setter for the field that sets the type of document on a
+      # polymorphic relation.
+      #
+      # @example Get the inverse type setter.
+      #   metadata.inverse_type_setter
+      #
+      # @return [ String ] The name of the setter.
+      #
+      # @since 2.0.0.rc.1
+      def type_setter
+        @type_setter ||= type ? "#{type}=" : nil
+      end
+
       # Are we validating this relation automatically?
       #
       # @example Is automatic validation on?
@@ -359,6 +640,42 @@ module Mongoid # :nodoc:
         self[:validate] != false
       end
 
+      # Is this relation using Mongoid's internal versioning system?
+      #
+      # @example Is this relation versioned?
+      #   metadata.versioned?
+      #
+      # @return [ true, false ] If the relation uses Mongoid versioning.
+      #
+      # @since 2.1.0
+      def versioned?
+        !!self[:versioned]
+      end
+
+      # Returns default order for this association.
+      #
+      # @example Get default order
+      #   metadata.order
+      #
+      # @return [ Criterion::Complex, nil] nil if doesn't set
+      #
+      # @since 2.1.0
+      def order
+        self[:order]
+      end
+
+      # Is a default order set?
+      #
+      # @example Is the order set?
+      #   metadata.order?
+      #
+      # @return [ true, false ] If the order is set.
+      #
+      # @since 2.1.0
+      def order?
+        !!order
+      end
+
       private
 
       # Returns the class name for the relation.
@@ -510,30 +827,10 @@ module Mongoid # :nodoc:
       # @since 2.0.0.rc.1
       def lookup_inverse(other)
         return nil unless other
-        other.to_a.first.relations.each_pair do |key, meta|
+        other.class.relations.each_pair do |key, meta|
           return meta.name if meta.as == name
         end
       end
-
-      # Handles two different cases - the first is a convenience for JSON like
-      # access to the hash instead of having to call []. The second is a
-      # delegation of the "*?" methods to has_key? as a convenience to check
-      # for existence of a value.
-      #
-      # @example Extras provided by this method.
-      #   metadata.name
-      #   metadata.name?
-      #
-      # @param [ Symbol ] name The name of the method.
-      # @param [ Array ] args The arguments passed to the method.
-      #
-      # @return [ Object ] Either the value or a boolen.
-      #
-      # @since 2.0.0.rc.1
-      def method_missing(name, *args)
-        method = name.to_s
-        method =~ /\?/ ? has_key?(method.sub('?', '').to_sym) : self[name]
-      end
     end
   end
 end