mongoid 2.0.0.beta.20 → 2.0.0.rc.1

data/lib/mongoid/associations.rb

@@ -1,364 +0,0 @@
-# encoding: utf-8
-require "mongoid/associations/proxy"
-require "mongoid/associations/embedded_in"
-require "mongoid/associations/embeds_many"
-require "mongoid/associations/embeds_one"
-require "mongoid/associations/foreign_key"
-require "mongoid/associations/references_many"
-require "mongoid/associations/references_many_as_array"
-require "mongoid/associations/references_one"
-require "mongoid/associations/referenced_in"
-require "mongoid/associations/options"
-require "mongoid/associations/meta_data"
-
-module Mongoid # :nodoc:
-  module Associations #:nodoc:
-    extend ActiveSupport::Concern
-    included do
-      include ForeignKey
-
-      cattr_accessor :embedded
-      self.embedded = false
-
-      class_inheritable_accessor :associations, :cascades
-      self.associations = {}
-      self.cascades = {}
-
-      delegate :embedded, :embedded?, :to => "self.class"
-    end
-
-    # Returns the associations for the +Document+.
-    def associations
-      self.class.associations
-    end
-
-    # are we in an embeds_many?
-    def embedded_many?
-      embedded? && _parent.associations[association_name].association == EmbedsMany
-    end
-
-    # are we in an embeds_one?
-    def embedded_one?
-      embedded? && !embedded_many?
-    end
-
-    # Update the one-to-one relational association for the name.
-    def update_association(name)
-      association = send(name)
-      association.save if new_record? && !association.nil?
-    end
-
-    # Updates all the one-to-many relational associations for the name.
-    def update_associations(name)
-      send(name).each { |doc| doc.save } if new_record?
-    end
-
-    def update_foreign_keys
-      associations.each do |name, association|
-        next unless association.macro == :referenced_in
-        foreign_key = association.options.foreign_key
-        if send(foreign_key).nil?
-          proxy = send(name)
-          send("#{foreign_key}=", proxy && proxy.target ? proxy.id : nil)
-        end
-      end
-    end
-
-    module ClassMethods
-      # Gets whether or not the document is embedded.
-      #
-      # Example:
-      #
-      # <tt>Person.embedded?</tt>
-      #
-      # Returns:
-      #
-      # <tt>true</tt> if embedded, <tt>false</tt> if not.
-      def embedded?
-        !!self.embedded
-      end
-
-      # Adds the association 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 association calling
-      # persistence methods on the child object will cause a save to fail.
-      #
-      # Options:
-      #
-      # name: A +Symbol+ that matches the name of the parent class.
-      #
-      # Example:
-      #
-      #   class Person
-      #     include Mongoid::Document
-      #     embeds_many :addresses
-      #   end
-      #
-      #   class Address
-      #     include Mongoid::Document
-      #     embedded_in :person, :inverse_of => :addresses
-      #   end
-      def embedded_in(name, options = {}, &block)
-        opts = optionize(name, options, nil, &block)
-        Associations::EmbeddedIn.validate_options(opts)
-        self.embedded = true
-        associate(Associations::EmbeddedIn, opts)
-      end
-
-      # Adds the association from a parent document to its children. The name
-      # of the association needs to be a pluralized form of the child class
-      # name.
-      #
-      # Options:
-      #
-      # name: A +Symbol+ that is the plural child class name.
-      #
-      # Example:
-      #
-      #   class Person
-      #     include Mongoid::Document
-      #     embeds_many :addresses
-      #   end
-      #
-      #   class Address
-      #     include Mongoid::Document
-      #     embedded_in :person, :inverse_of => :addresses
-      #   end
-      def embeds_many(name, options = {}, &block)
-        opts = optionize(name, options, nil, &block)
-        Associations::EmbedsMany.validate_options(opts)
-        associate(Associations::EmbedsMany, opts)
-      end
-
-      alias :embed_many :embeds_many
-
-      # Adds the association from a parent document to its child. The name
-      # of the association needs to be a singular form of the child class
-      # name.
-      #
-      # Options:
-      #
-      # name: A +Symbol+ that is the plural child class name.
-     #
-      # Example:
-      #
-      #   class Person
-      #     include Mongoid::Document
-      #     embeds_one :name
-      #   end
-      #
-      #   class Name
-      #     include Mongoid::Document
-      #     embedded_in :person
-      #   end
-      def embeds_one(name, options = {}, &block)
-        opts = optionize(name, options, nil, &block)
-        type = Associations::EmbedsOne
-        type.validate_options(opts)
-        associate(type, opts)
-        add_builder(type, opts)
-        add_creator(type, opts)
-      end
-
-      alias :embed_one :embeds_one
-
-      # Adds a relational association from the child Document to a Document in
-      # another database or collection.
-      #
-      # Options:
-      #
-      # name: A +Symbol+ that is the related class name.
-      #
-      # Example:
-      #
-      #   class Game
-      #     include Mongoid::Document
-      #     referenced_in :person
-      #   end
-      #
-      def referenced_in(name, options = {}, &block)
-        opts = optionize(name, options, constraint(name, options, :in), &block)
-        Associations::ReferencedIn.validate_options(opts)
-        associate(Associations::ReferencedIn, opts)
-        field(opts.foreign_key, :inverse_class_name => opts.class_name, :identity => true)
-        index(opts.foreign_key, :background => true) if !embedded? && opts.index
-        set_callback(:save, :before) { |document| document.update_foreign_keys }
-      end
-
-      alias :belongs_to_related :referenced_in
-
-      # Adds a relational association from the Document to many Documents in
-      # another database or collection.
-      #
-      # Options:
-      #
-      # name: A +Symbol+ that is the related class name pluralized.
-      # default_order: A +Criteria+ that specifies the default sort order for
-      # this association. (e.g. :position.asc). If an explicit ordering is
-      # specified on a +Criteria+ object, the default order will NOT be used.
-      #
-      # Example:
-      #
-      #   class Person
-      #     include Mongoid::Document
-      #     references_many :posts
-      #     references_many :board_games, :default_order => :title.asc
-      #   end
-      #
-      def references_many(name, options = {}, &block)
-        reference_many(name, options, &block)
-        set_callback :save, :before do |document|
-          document.update_associations(name)
-        end
-        add_cascade(name, options)
-      end
-
-      alias :has_many_related :references_many
-
-      # Adds a relational association from the Document to one Document in
-      # another database or collection.
-      #
-      # Options:
-      #
-      # name: A +Symbol+ that is the related class name pluralized.
-      #
-      # Example:
-      #
-      #   class Person
-      #     include Mongoid::Document
-      #     references_one :game
-      #   end
-      def references_one(name, options = {}, &block)
-        opts = optionize(name, options, constraint(name, options, :one), &block)
-        type = Associations::ReferencesOne
-        associate(type, opts)
-        add_builder(type, opts)
-        add_creator(type, opts)
-        set_callback :save, :before do |document|
-          document.update_association(name)
-        end
-        add_cascade(name, options)
-      end
-
-      alias :has_one_related :references_one
-
-      # Returns the association reflection object with the supplied association
-      # name.
-      #
-      # Options:
-      #
-      # name: The association name.
-      #
-      # Example:
-      #
-      # <tt>Person.reflect_on_association(:addresses)</tt>
-      def reflect_on_association(name)
-        association = associations[name.to_s]
-      end
-
-      # Returns all association meta data for the provided type.
-      #
-      # Options:
-      #
-      # macro: The association macro.
-      #
-      # Example:
-      #
-      # <tt>Person.reflect_on_all_associations(:embeds_many)</tt>
-      def reflect_on_all_associations(macro)
-        associations.values.select { |meta| meta.macro == macro }
-      end
-
-      protected
-      # Adds the association to the associations hash with the type as the key,
-      # then adds the accessors for the association. The defined setters and
-      # getters for the associations will perform the necessary memoization.
-      #
-      # Example:
-      #
-      # <tt>Person.associate(EmbedsMany, { :name => :addresses })</tt>
-      def associate(type, options)
-        name = options.name.to_s
-        associations[name] = MetaData.new(type, options)
-        define_method(name) do
-          memoized(name) do
-            proxy = type.new(self, options)
-            case proxy
-            when Associations::ReferencesOne,
-                 Associations::EmbedsOne,
-                 Associations::ReferencedIn,
-                 Associations::EmbeddedIn
-              proxy.target ? proxy : nil
-            else
-              proxy
-            end
-          end
-        end
-        define_method("#{name}=") do |object|
-          unmemoize(name)
-          memoized(name) { type.update(object, self, options) }
-        end
-      end
-
-      # Adds a builder for a has_one association. This comes in the form of
-      # build_name(attributes)
-      def add_builder(type, options)
-        name = options.name.to_s
-        define_method("build_#{name}") do |*params|
-          attrs = params[0]
-          attr_options = params[1] || {}
-          reset(name) do
-            proxy = type.new(self, options)
-            proxy.build((attrs || {}).stringify_keys)
-            proxy
-          end unless type == Associations::EmbedsOne && attr_options[:update_only]
-        end
-      end
-
-      # Adds a creator for a has_one association. This comes in the form of
-      # create_name(attributes)
-      def add_creator(type, options)
-        name = options.name.to_s
-        define_method("create_#{name}") do |*params|
-          attrs = params[0]
-          attr_options = params[1] || {}
-          unless type == Associations::EmbedsOne && attr_options[:update_only]
-            send("build_#{name}", attrs, attr_options).tap(&:save)
-          end
-        end
-      end
-
-      # Create the callbacks for dependent deletes and destroys.
-      def add_cascade(name, options)
-        dependent = options[:dependent]
-        self.cascades[name] = dependent if dependent
-      end
-
-      # build the options given the params.
-      def optionize(name, options, foreign_key, &block)
-        Associations::Options.new(
-          options.merge(:name => name, :foreign_key => foreign_key, :extend => block)
-        )
-      end
-
-      def reference_many(name, options, &block)
-        if (options[:stored_as] == :array)
-          foreign_key = "#{name.to_s.singularize}_ids"
-          opts = optionize(name, options, constraint(name, options, :many_as_array), &block)
-          field(
-            foreign_key,
-            :type => Array,
-            :default => [],
-            :identity => true,
-            :inverse_class_name => opts.class_name
-          )
-          index(foreign_key, :background => true) if opts.index
-          associate(Associations::ReferencesManyAsArray, opts)
-        else
-          opts = optionize(name, options, constraint(name, options, :many), &block)
-          associate(Associations::ReferencesMany, opts)
-        end
-      end
-    end
-  end
-end

data/lib/mongoid/associations/embedded_in.rb

@@ -1,74 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Associations #:nodoc:
-    # Represents an association that is embedded within another document in the
-    # database, either as one or many.
-    class EmbeddedIn < 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:
-      #
-      # document: The child +Document+
-      # options: The association options
-      def initialize(document, options, target = nil)
-        if target
-          inverse = determine_name(target, options)
-          document.parentize(target, inverse)
-          document.notify
-          target.unmemoize(inverse)
-        end
-        @target, @options = document._parent, 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
-
-      protected
-      def determine_name(target, options)
-        inverse = options.inverse_of
-        return inverse unless inverse.is_a?(Array)
-        inverse.detect { |name| target.respond_to?(name) }
-      end
-
-      class << self
-        # 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)
-          new(child, options, target)
-        end
-
-        # Validate the options passed to the embedded in macro, to encapsulate
-        # the behavior in this class instead of the associations module.
-        #
-        # Options:
-        #
-        # options: Thank you captain obvious.
-        def validate_options(options = {})
-          check_dependent_not_allowed!(options)
-          check_inverse_must_be_defined!(options)
-        end
-      end
-    end
-  end
-end

data/lib/mongoid/associations/embeds_many.rb

@@ -1,299 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Associations #:nodoc:
-    # Represents embedding many documents within a parent document, which will
-    # be an array as the underlying storage mechanism.
-    class EmbedsMany < 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._index = @target.size - 1
-          doc.notify
-        end
-      end
-
-      alias :concat :<<
-      alias :push :<<
-
-      # 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._index = @target.size - 1
-        document
-      end
-
-      # Clears the association, and notifies the parents of the removal.
-      def clear
-        unless @target.empty?
-          document = @target.first
-          document._parent.update_child(document, true) if (document._parent)
-          @target.clear
-        end
-      end
-
-      # Returns a count of the number of documents in the association that have
-      # actually been persisted to the database.
-      #
-      # Use #size if you want the total number of documents.
-      #
-      # Returns:
-      #
-      # The total number of persisted embedded docs, as flagged by the
-      # #persisted? method.
-      def count
-        @target.select(&:persisted?).size
-      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)
-        build(attrs, type).tap(&:save)
-      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)
-        raise Errors::Validations.new(document) unless document.errors.empty?
-        document
-      end
-
-      # Delete all the documents in the association without running callbacks.
-      #
-      # Example:
-      #
-      # <tt>addresses.delete_all</tt>
-      #
-      # Returns:
-      #
-      # The number of documents deleted.
-      def delete_all(conditions = {})
-        remove(:delete, conditions)
-      end
-
-      # Delete all the documents in the association and run destroy callbacks.
-      #
-      # Example:
-      #
-      # <tt>addresses.destroy_all</tt>
-      #
-      # Returns:
-      #
-      # The number of documents destroyed.
-      def destroy_all(conditions = {})
-        remove(:destroy, conditions)
-      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
-        criteria.id(param).first
-      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, target_array = nil)
-        @parent, @association_name = parent, options.name
-        @klass, @options = options.klass, options
-        if target_array
-          build_children_from_target_array(target_array)
-        else
-          build_children_from_attributes(parent.raw_attributes[@association_name])
-        end
-        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)
-        if @target.respond_to?(name)
-          super
-        else
-          @klass.send(:with_scope, criteria) do
-            object = @klass.send(name, *args)
-          end
-        end
-      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, options = {})
-        @parent.instance_variable_set(:@building_nested, true)
-        id_index, reordering = {}, false
-        attributes.each do |index, attrs|
-          document = if attrs["id"].present?
-            reordering = true
-            id_index[attrs["id"]] = index.to_i
-            detect { |document| document.id.to_s == attrs["id"].to_s }
-          else
-            detect { |document| document._index == index.to_i }
-          end
-          if document
-            if options && options[:allow_destroy] && Boolean.set(attrs['_destroy'])
-              @target.delete(document)
-              document.destroy
-            else
-              document.write_attributes(attrs)
-            end
-          else
-            document = build(attrs)
-            id_index[document.id.to_s] = index.to_i
-          end
-        end
-        if reordering
-          @target.sort! do |a, b|
-            ai, bi = id_index[a.id.to_s], id_index[b.id.to_s]
-            ai.nil? ? (bi.nil? ? 0 : 1) : (bi.nil? ? -1 : ai <=> bi)
-          end
-        end
-        @target.each_with_index { |document, index| document._index = index }
-        @parent.instance_variable_set(:@building_nested, false)
-        self
-      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(options)
-      end
-
-      protected
-      # Initializes each of the attributes in the hash.
-      def build_children_from_attributes(attributes)
-        @target = []
-        if attributes
-          attributes.each_with_index do |attrs, index|
-            klass = attrs.klass
-            child = klass ? klass.instantiate(attrs) : @klass.instantiate(attrs)
-            child.parentize(@parent, @association_name)
-            child._index = index
-            @target << child
-          end
-        end
-      end
-
-      # Initializes the target array from an existing array of documents.
-      def build_children_from_target_array(target_array)
-        @target = target_array
-        @target.each_with_index do |child, index|
-          child._index = index
-        end
-      end
-
-      # Removes documents based on a method.
-      def remove(method, conditions)
-        criteria = @klass.find(conditions || {})
-        criteria.documents = @target
-        count = criteria.size
-        criteria.each do |doc|
-          @target.delete(doc); doc.send(method)
-        end; count
-      end
-
-      # Returns the criteria object for the target class with its documents set
-      # to @target.
-      def criteria
-        criteria = @klass.criteria
-        criteria.documents = @target
-        criteria
-      end
-
-      class << self
-        # 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.raw_attributes.delete(options.name)
-          children.assimilate(parent, options)
-          if children && children.first.is_a?(Mongoid::Document)
-            new(parent, options, children)
-          else
-            new(parent, options)
-          end
-        end
-
-        # Validate the options passed to the embeds many macro, to encapsulate
-        # the behavior in this class instead of the associations module.
-        #
-        # Options:
-        #
-        # options: Thank you captain obvious.
-        def validate_options(options = {})
-          check_dependent_not_allowed!(options)
-          check_inverse_not_allowed!(options)
-        end
-      end
-    end
-  end
-end