mongoid-pre 2.0.0.beta1

data/lib/mongoid/associations/belongs_to_related.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Associations #:nodoc:
+    class BelongsToRelated #:nodoc:
+      include Proxy
+
+      # Initializing a related association only requires looking up the object
+      # by its id.
+      #
+      # Options:
+      #
+      # document: The +Document+ that contains the relationship.
+      # options: The association +Options+.
+      def initialize(document, foreign_key, options, target = nil)
+        @options = options
+        @target = target || options.klass.find(foreign_key)
+        extends(options)
+      end
+
+      class << self
+        # Instantiate a new +BelongsToRelated+ or return nil if the foreign key is
+        # nil. It is preferrable to use this method over the traditional call
+        # to new.
+        #
+        # Options:
+        #
+        # document: The +Document+ that contains the relationship.
+        # options: The association +Options+.
+        def instantiate(document, options, target = nil)
+          foreign_key = document.send(options.foreign_key)
+          foreign_key.blank? ? nil : new(document, foreign_key, options, target)
+        end
+
+        # Returns the macro used to create the association.
+        def macro
+          :belongs_to_related
+        end
+
+        # Perform an update of the relationship of the parent and child. This
+        # will assimilate the child +Document+ into the parent's object graph.
+        #
+        # Options:
+        #
+        # target: The target(parent) object
+        # document: The +Document+ to update.
+        # options: The association +Options+
+        #
+        # Example:
+        #
+        # <tt>BelongsToRelated.update(person, game, options)</tt>
+        def update(target, document, options)
+          document.send("#{options.foreign_key}=", target ? target.id : nil)
+          instantiate(document, options, target)
+        end
+      end
+
+    end
+  end
+end

data/lib/mongoid/associations/embedded_in.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Associations #:nodoc:
+    class EmbeddedIn #:nodoc:
+      include Proxy
+
+      # Creates the new association by setting the internal
+      # target as the passed in Document. This should be the
+      # parent.
+      #
+      # All method calls on this object will then be delegated
+      # to the internal document itself.
+      #
+      # Options:
+      #
+      # target: The parent +Document+
+      # options: The association options
+      def initialize(target, options)
+        @target, @options = target, options
+        extends(options)
+      end
+
+      # Returns the parent document. The id param is present for
+      # compatibility with rails, however this could be overwritten
+      # in the future.
+      def find(id)
+        @target
+      end
+
+      class << self
+        # Creates the new association by setting the internal
+        # document as the passed in Document. This should be the
+        # parent.
+        #
+        # Options:
+        #
+        # document: The parent +Document+
+        # options: The association options
+        def instantiate(document, options)
+          target = document._parent
+          target.nil? ? nil : new(target, options)
+        end
+
+        # Returns the macro used to create the association.
+        def macro
+          :embedded_in
+        end
+
+        # Perform an update of the relationship of the parent and child. This
+        # is initialized by setting a parent object as the association on the
+        # +Document+. Will properly set an embeds_one or an embeds_many.
+        #
+        # Returns:
+        #
+        # A new +EmbeddedIn+ association proxy.
+        def update(target, child, options)
+          child.parentize(target, options.inverse_of)
+          child.notify
+          instantiate(child, options)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/associations/embeds_many.rb

@@ -0,0 +1,193 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Associations #:nodoc:
+    class EmbedsMany
+      include Proxy
+
+      attr_accessor :association_name, :klass
+
+      # Appends the object to the +Array+, setting its parent in
+      # the process.
+      def <<(*documents)
+        documents.flatten.each do |doc|
+          doc.parentize(@parent, @association_name)
+          @target << doc
+          doc.notify
+        end
+      end
+
+      alias :concat :<<
+      alias :push :<<
+
+      # Clears the association, and notifies the parents of the removal.
+      def clear
+        unless @target.empty?
+          document = @target.first
+          document.notify_observers(document, true)
+          @target.clear
+        end
+      end
+
+      # Builds a new Document and adds it to the association collection. The
+      # document created will be of the same class as the others in the
+      # association, and the attributes will be passed into the constructor.
+      #
+      # Returns:
+      #
+      # The newly created Document.
+      def build(attrs = {}, type = nil)
+        document = type ? type.instantiate : @klass.instantiate
+        document.parentize(@parent, @association_name)
+        document.write_attributes(attrs)
+        @target << document
+        document
+      end
+
+      # Creates a new Document and adds it to the association collection. The
+      # document created will be of the same class as the others in the
+      # association, and the attributes will be passed into the constructor and
+      # the new object will then be saved.
+      #
+      # Returns:
+      #
+      # The newly created Document.
+      def create(attrs = {}, type = nil)
+        object = build(attrs, type)
+        object.run_callbacks(:create) { object.save }; object
+      end
+
+      # Creates a new Document and adds it to the association collection. The
+      # document created will be of the same class as the others in the
+      # association, and the attributes will be passed into the constructor and
+      # the new object will then be saved. If validation fails an error will
+      # get raised.
+      #
+      # Returns:
+      #
+      # The newly created Document.
+      def create!(attrs = {}, type = nil)
+        document = create(attrs, type)
+        errors = document.errors
+        raise Errors::Validations.new(errors) unless errors.empty?
+        document
+      end
+
+      # Finds a document in this association.
+      #
+      # If :all is passed, returns all the documents
+      #
+      # If an id is passed, will return the document for that id.
+      #
+      # Returns:
+      #
+      # Array or single Document.
+      def find(param)
+        return @target if param == :all
+        return detect { |document| document.id == param }
+      end
+
+      # Creates the new association by finding the attributes in
+      # the parent document with its name, and instantiating a
+      # new document for each one found. These will then be put in an
+      # internal array.
+      #
+      # This then delegated all methods to the array class since this is
+      # essentially a proxy to an array itself.
+      #
+      # Options:
+      #
+      # parent: The parent document to the association.
+      # options: The association options.
+      def initialize(parent, options)
+        @parent, @association_name = parent, options.name
+        @klass, @options = options.klass, options
+        initialize_each(parent.raw_attributes[@association_name])
+        extends(options)
+      end
+
+      # If the target array does not respond to the supplied method then try to
+      # find a named scope or criteria on the class and send the call there.
+      #
+      # If the method exists on the array, use the default proxy behavior.
+      def method_missing(name, *args, &block)
+        unless @target.respond_to?(name)
+          object = @klass.send(name, *args)
+          object.documents = @target
+          return object
+        end
+        super
+      end
+
+      # Used for setting associations via a nested attributes setter from the
+      # parent +Document+.
+      #
+      # Options:
+      #
+      # attributes: A +Hash+ of integer keys and +Hash+ values.
+      #
+      # Returns:
+      #
+      # The newly build target Document.
+      def nested_build(attributes)
+        attributes.values.each do |attrs|
+          build(attrs)
+        end
+      end
+
+      # Paginate the association. Will create a new criteria, set the documents
+      # on it and execute in an enumerable context.
+      #
+      # Options:
+      #
+      # options: A +Hash+ of pagination options.
+      #
+      # Returns:
+      #
+      # A +WillPaginate::Collection+.
+      def paginate(options)
+        criteria = Mongoid::Criteria.translate(@klass, options)
+        criteria.documents = @target
+        criteria.paginate
+      end
+
+      protected
+      # Initializes each of the attributes in the hash.
+      def initialize_each(attributes)
+        @target = attributes ? attributes.collect do |attrs|
+          klass = attrs.klass
+          child = klass ? klass.instantiate(attrs) : @klass.instantiate(attrs)
+          child.parentize(@parent, @association_name)
+          child
+        end : []
+      end
+
+      class << self
+
+        # Preferred method of creating a new +EmbedsMany+ association. It will
+        # delegate to new.
+        #
+        # Options:
+        #
+        # document: The parent +Document+
+        # options: The association options
+        def instantiate(document, options)
+          new(document, options)
+        end
+
+        # Returns the macro used to create the association.
+        def macro
+          :embeds_many
+        end
+
+        # Perform an update of the relationship of the parent and child. This
+        # is initialized by setting the has_many to the supplied +Enumerable+
+        # and setting up the parentization.
+        def update(children, parent, options)
+          parent.remove_attribute(options.name)
+          children.assimilate(parent, options)
+          instantiate(parent, options)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/associations/embeds_one.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Associations #:nodoc:
+    class EmbedsOne #:nodoc:
+      include Proxy
+
+      # Build a new object for the association.
+      def build(attrs = {}, type = nil)
+        @target = attrs.assimilate(@parent, @options, type); self
+      end
+
+      # Creates the new association by finding the attributes in
+      # the parent document with its name, and instantiating a
+      # new document for it.
+      #
+      # All method calls on this object will then be delegated
+      # to the internal document itself.
+      #
+      # Options:
+      #
+      # document: The parent +Document+
+      # attributes: The attributes of the target object.
+      # options: The association options.
+      #
+      # Returns:
+      #
+      # A new +HashOne+ association proxy.
+      def initialize(document, attrs, options)
+        @parent, @options  = document, options
+        @target = attrs.assimilate(@parent, @options, attrs.klass)
+        extends(options)
+      end
+
+      # Used for setting the association via a nested attributes setter on the
+      # parent +Document+. Called when using accepts_nested_attributes_for.
+      #
+      # Options:
+      #
+      # attributes: The attributes for the new association
+      #
+      # Returns:
+      #
+      # A new target document.
+      def nested_build(attributes)
+        build(attributes)
+      end
+
+      class << self
+        # Preferred method of instantiating a new +EmbedsOne+, since nil values
+        # will be handled properly.
+        #
+        # Options:
+        #
+        # document: The parent +Document+
+        # options: The association options.
+        #
+        # Returns:
+        #
+        # A new +EmbedsOne+ association proxy.
+        def instantiate(document, options)
+          attributes = document.raw_attributes[options.name]
+          return nil if attributes.blank?
+          new(document, attributes, options)
+        end
+
+        # Returns the macro used to create the association.
+        def macro
+          :embeds_one
+        end
+
+        # Perform an update of the relationship of the parent and child. This
+        # will assimilate the child +Document+ into the parent's object graph.
+        #
+        # Options:
+        #
+        # child: The child +Document+ or +Hash+.
+        # parent: The parent +Document+ to update.
+        # options: The association +Options+
+        #
+        # Example:
+        #
+        # <tt>EmbedsOne.update({:first_name => "Hank"}, person, options)</tt>
+        #
+        # Returns:
+        #
+        # A new +EmbedsOne+ association proxy.
+        def update(child, parent, options)
+          child.assimilate(parent, options)
+          instantiate(parent, options)
+        end
+      end
+
+    end
+  end
+end

data/lib/mongoid/associations/has_many_related.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Associations #:nodoc:
+    class HasManyRelated #:nodoc:
+      include Proxy
+
+      # Appends the object to the +Array+, setting its parent in
+      # the process.
+      def <<(*objects)
+        load_target
+        objects.flatten.each do |object|
+          object.send("#{@foreign_key}=", @parent.id)
+          @target << object
+          object.save unless @parent.new_record?
+        end
+      end
+
+      # Builds a new Document and adds it to the association collection. The
+      # document created will be of the same class as the others in the
+      # association, and the attributes will be passed into the constructor.
+      #
+      # Returns the newly created object.
+      def build(attributes = {})
+        load_target
+        name = @parent.class.to_s.underscore
+        object = @klass.instantiate(attributes.merge(name => @parent))
+        @target << object
+        object
+      end
+
+      # Delegates to <<
+      def concat(*objects)
+        self << objects
+      end
+
+      # Creates a new Document and adds it to the association collection. The
+      # document created will be of the same class as the others in the
+      # association, and the attributes will be passed into the constructor and
+      # the new object will then be saved.
+      #
+      # Returns the newly created object.
+      def create(attributes)
+        object = build(attributes)
+        object.run_callbacks(:create) { object.save }; object
+      end
+
+      # Finds a document in this association.
+      # If an id is passed, will return the document for that id.
+      def find(*args)
+        args[1][:conditions].merge!(@foreign_key.to_sym => @parent.id) if args.size > 1
+        @klass.find(*args)
+      end
+
+      # Initializing a related association only requires looking up the objects
+      # by their ids.
+      #
+      # Options:
+      #
+      # document: The +Document+ that contains the relationship.
+      # options: The association +Options+.
+      def initialize(document, options, target = nil)
+        @parent, @klass = document, options.klass
+        @foreign_key = options.foreign_key
+        @base = lambda { @klass.all(:conditions => { @foreign_key => document.id }) }
+        @target = target || @base.call
+        extends(options)
+      end
+
+      # Override the default behavior to allow the criteria to get reset on
+      # each call into the association.
+      #
+      # Example:
+      #
+      #   person.posts.where(:title => "New")
+      #   person.posts # resets the criteria
+      #
+      # Returns:
+      #
+      # A Criteria object or Array.
+      def method_missing(name, *args, &block)
+        @target = @base.call unless @target.is_a?(Array)
+        @target.send(name, *args, &block)
+      end
+
+      # Delegates to <<
+      def push(*objects)
+        self << objects
+      end
+
+      protected
+      # Load the target entries if the document is new.
+      def load_target
+        @target = @target.entries if @parent.new_record?
+      end
+
+      class << self
+        # Preferred method for creating the new +HasManyRelated+ association.
+        #
+        # Options:
+        #
+        # document: The +Document+ that contains the relationship.
+        # options: The association +Options+.
+        def instantiate(document, options, target = nil)
+          new(document, options, target)
+        end
+
+        # Returns the macro used to create the association.
+        def macro
+          :has_many_related
+        end
+
+        # Perform an update of the relationship of the parent and child. This
+        # will assimilate the child +Document+ into the parent's object graph.
+        #
+        # Options:
+        #
+        # related: The related object
+        # parent: The parent +Document+ to update.
+        # options: The association +Options+
+        #
+        # Example:
+        #
+        # <tt>RelatesToOne.update(game, person, options)</tt>
+        def update(target, document, options)
+          name = document.class.to_s.underscore
+          target.each { |child| child.send("#{name}=", document) }
+          instantiate(document, options, target)
+        end
+      end
+
+    end
+  end
+end