stonegao-mongoid 2.0.0.rc.6

data/lib/mongoid/relations/constraint.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # Used for converting foreign key values to the correct type based on the
+    # types of ids that the document stores.
+    #
+    # @note Durran: The name of this class is this way to match the metadata
+    #   getter, and foreign_key was already taken there.
+    class Constraint
+      attr_reader :metadata
+
+      # Create the new constraint with the metadata.
+      #
+      # @example Instantiate the constraint.
+      #   Constraint.new(metdata)
+      #
+      # @param [ Metadata ] metadata The metadata of the relation.
+      #
+      # @since 2.0.0.rc.7
+      def initialize(metadata)
+        @metadata = metadata
+      end
+
+      # Convert the supplied object to the appropriate type to set as the
+      # foreign key for a relation.
+      #
+      # @example Convert the object.
+      #   constraint.convert("12345")
+      #
+      # @param [ Object ] object The object to convert.
+      #
+      # @return [ Object ] The object cast to the correct type.
+      #
+      # @since 2.0.0.rc.7
+      def convert(object)
+        return object if metadata.polymorphic?
+        if metadata.stores_foreign_key? && metadata.klass.using_object_ids?
+          return BSON::ObjectId.cast!(metadata.klass, object)
+        end
+        object
+      end
+    end
+  end
+end

data/lib/mongoid/relations/cyclic.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # This module provides convenience macros for using cyclic embedded
+    # relations.
+    module Cyclic
+      extend ActiveSupport::Concern
+
+      module ClassMethods #:nodoc:
+
+        # Create a cyclic embedded relation that creates a tree hierarchy for
+        # the document and many embedded child documents.
+        #
+        # @example Set up a recursive embeds many.
+        #
+        #   class Role
+        #     include Mongoid::Document
+        #     recursively_embeds_many
+        #   end
+        #
+        # @example The previous example is a shorcut for this.
+        #
+        #   class Role
+        #     include Mongoid::Document
+        #     embeds_many :child_roles, :class_name => "Role", :cyclic => true
+        #     embedded_in :parent_role, :class_name => "Role", :cyclic => true
+        #   end
+        #
+        # This provides the default nomenclature for accessing a parent document
+        # or its children.
+        #
+        # @since 2.0.0.rc.1
+        def recursively_embeds_many
+          embeds_many cyclic_child_name, :class_name => self.name, :cyclic => true
+          embedded_in cyclic_parent_name, :class_name => self.name, :cyclic => true
+        end
+
+        # Create a cyclic embedded relation that creates a single self
+        # referencing relationship for a parent and a single child.
+        #
+        # @example Set up a recursive embeds one.
+        #
+        #   class Role
+        #     include Mongoid::Document
+        #     recursively_embeds_one
+        #   end
+        #
+        # @example The previous example is a shorcut for this.
+        #
+        #   class Role
+        #     include Mongoid::Document
+        #     embeds_one :child_role, :class_name => "Role", :cyclic => true
+        #     embedded_in :parent_role, :class_name => "Role", :cyclic => true
+        #   end
+        #
+        # This provides the default nomenclature for accessing a parent document
+        # or its children.
+        #
+        # @since 2.0.0.rc.1
+        def recursively_embeds_one
+          embeds_one cyclic_child_name(false), :class_name => self.name, :cyclic => true
+          embedded_in cyclic_parent_name, :class_name => self.name, :cyclic => true
+        end
+
+        private
+
+        # Determines the parent name given the class.
+        #
+        # @example Determine the parent name.
+        #   Role.cyclic_parent_name
+        #
+        # @return [ String ] "parent_" plus the class name underscored.
+        #
+        # @since 2.0.0.rc.1
+        def cyclic_parent_name
+          ("parent_" << self.name.underscore.singularize).to_sym
+        end
+
+        # Determines the child name given the class.
+        #
+        # @example Determine the child name.
+        #   Role.cyclic_child_name
+        #
+        # @param [ true, false ] many Is the a many relation?
+        #
+        # @return [ String ] "child_" plus the class name underscored in
+        #   singular or plural form.
+        #
+        # @since 2.0.0.rc.1
+        def cyclic_child_name(many = true)
+          ("child_" << self.name.underscore.send(many ? :pluralize : :singularize)).to_sym
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Embedded
+
+      # This class defines the behaviour necessary to handle relations that are
+      # embedded within another relation, either as a single document or
+      # multiple documents.
+      class In < 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.
+        #   name.person.bind(:continue => true)
+        #
+        # @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)
+          base.save if target.persisted? && !options[:binding]
+        end
+
+        # Instantiate a new embedded_in relation.
+        #
+        # @example Create the new relation.
+        #   Embedded::In.new(name, person, metadata)
+        #
+        # @param [ Document ] base The document the relation hangs off of.
+        # @param [ Document ] target The target (parent) of the relation.
+        # @param [ Metadata ] metadata The relation metadata.
+        #
+        # @return [ In ] The proxy.
+        def initialize(base, target, metadata)
+          init(base, target, metadata) do
+            characterize_one(target)
+            base.parentize(target)
+          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.
+        #
+        # @example Unbind the relation.
+        #   name.person.unbind(:continue => false)
+        #
+        # @param [ Proxy ] old_target The previous target of the relation.
+        # @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 unbind(old_target, options = {})
+          binding(old_target).unbind(options)
+          base.delete if old_target.persisted? && !base.destroyed?
+        end
+
+        private
+
+        # Instantiate the binding associated with this relation.
+        #
+        # @example Get the binding.
+        #   binding([ address ])
+        #
+        # @param [ Proxy ] new_target The new documents to bind with.
+        #
+        # @return [ Binding ] A binding object.
+        #
+        # @since 2.0.0.rc.1
+        def binding(new_target = nil)
+          Bindings::Embedded::In.new(base, new_target || target, metadata)
+        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::In.builder(meta, object, person)
+          #
+          # @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(meta, object)
+            Builders::Embedded::In.new(meta, object)
+          end
+
+          # Returns true if the relation is an embedded one. In this case
+          # always true.
+          #
+          # @example Is this relation embedded?
+          #   Embedded::In.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::In.macro
+          #
+          # @return [ Symbol ] :embedded_in.
+          #
+          # @since 2.0.0.rc.1
+          def macro
+            :embedded_in
+          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
+
+          # 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::In.stores_foreign_key?
+          #
+          # @return [ false ] false.
+          #
+          # @since 2.0.0.rc.1
+          def stores_foreign_key?
+            false
+          end
+        end
+      end
+    end
+  end
+end