mongoid 2.0.0.alpha → 2.0.0.beta.5

data/lib/mongoid.rb

@@ -21,13 +21,15 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 require "rubygems"
 
-gem "activemodel", ">= 3.0.pre"
-gem "will_paginate", ">= 3.0.pre"
-gem "mongo", ">= 0.19.1"
+gem "activemodel", "3.0.0.beta3"
+gem "will_paginate", "3.0.pre"
+gem "mongo", "~>1.0.1"
+gem "bson", "~>1.0.1"
 
 require "delegate"
 require "singleton"
 require "time"
+require "ostruct"
 require "active_support/core_ext"
 require 'active_support/json'
 require "active_support/inflector"
@@ -44,16 +46,18 @@ require "active_model/validator"
 require "active_model/validations"
 require "will_paginate/collection"
 require "mongo"
+require "mongoid/observable"
 require "mongoid/associations"
 require "mongoid/attributes"
 require "mongoid/callbacks"
 require "mongoid/collection"
-require "mongoid/commands"
+require "mongoid/collections"
 require "mongoid/config"
 require "mongoid/contexts"
 require "mongoid/criteria"
 require "mongoid/cursor"
 require "mongoid/deprecation"
+require "mongoid/dirty"
 require "mongoid/extensions"
 require "mongoid/extras"
 require "mongoid/errors"
@@ -67,8 +71,8 @@ require "mongoid/javascript"
 require "mongoid/matchers"
 require "mongoid/memoization"
 require "mongoid/named_scope"
-require "mongoid/observable"
 require "mongoid/paths"
+require "mongoid/persistence"
 require "mongoid/scope"
 require "mongoid/state"
 require "mongoid/timestamps"
@@ -79,6 +83,8 @@ require "mongoid/document"
 
 module Mongoid #:nodoc
 
+  MONGODB_VERSION = "1.4.0"
+
   class << self
 
     # Sets the Mongoid configuration options. Best used by passing a block.

data/lib/mongoid/associations.rb

@@ -2,8 +2,8 @@
 require "mongoid/associations/proxy"
 require "mongoid/associations/belongs_to_related"
 require "mongoid/associations/embedded_in"
-require "mongoid/associations/embed_many"
-require "mongoid/associations/embed_one"
+require "mongoid/associations/embeds_many"
+require "mongoid/associations/embeds_one"
 require "mongoid/associations/has_many_related"
 require "mongoid/associations/has_one_related"
 require "mongoid/associations/options"
@@ -13,9 +13,13 @@ module Mongoid # :nodoc:
   module Associations #:nodoc:
     extend ActiveSupport::Concern
     included do
-      # Associations need to inherit down the chain.
+      cattr_accessor :embedded
+      self.embedded = false
+
       class_inheritable_accessor :associations
       self.associations = {}
+
+      delegate :embedded, :embedded?, :to => "self.class"
     end
 
     module InstanceMethods
@@ -24,9 +28,15 @@ module Mongoid # :nodoc:
         self.class.associations
       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?
+      # are we in an embeds_many?
+      def embedded_many?
+        embedded? and _parent.associations[association_name].association == EmbedsMany
+      end
+
+      # Update all the dirty child documents after an update.
+      def update_embedded(name)
+        association = send(name)
+        association.to_a.each { |doc| doc.save if doc.changed? || doc.new_record? } unless association.blank?
       end
 
       # Update the one-to-one relational association for the name.
@@ -34,14 +44,46 @@ module Mongoid # :nodoc:
         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
     end
 
     module ClassMethods
+      # 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
+      #     belongs_to_related :person
+      #   end
+      #
+      def belongs_to_related(name, options = {}, &block)
+        opts = optionize(name, options, fk(name, options), &block)
+        associate(Associations::BelongsToRelated, opts)
+        field(opts.foreign_key, :type => Mongoid.use_object_ids ? BSON::ObjectID : String)
+        index(opts.foreign_key) unless embedded?
+      end
 
-      # Deprecated: Document.belongs_to will become Document.embedded_in
-      def belongs_to(name, options = {}, &block)
-        Mongoid.deprecate("Document.belongs_to will become Document.embedded_in")
-        embedded_in(name, options, &block)
+      # 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
@@ -57,7 +99,7 @@ module Mongoid # :nodoc:
       #
       #   class Person
       #     include Mongoid::Document
-      #     embed_many :addresses
+      #     embeds_many :addresses
       #   end
       #
       #   class Address
@@ -66,48 +108,40 @@ module Mongoid # :nodoc:
       #   end
       def embedded_in(name, options = {}, &block)
         unless options.has_key?(:inverse_of)
-          raise Errors::InvalidOptions.new("Options for belongs_to association must include :inverse_of")
+          raise Errors::InvalidOptions.new("Options for embedded_in association must include :inverse_of")
         end
         self.embedded = true
-        add_association(
-          Associations::EmbeddedIn,
-          Associations::Options.new(
-            options.merge(:name => name, :extend => block)
-          )
-        )
+        associate(Associations::EmbeddedIn, optionize(name, options, nil, &block))
       end
 
-      # Adds a relational association from the child Document to a Document in
-      # another database or collection.
+      # 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 related class name.
+      # name: A +Symbol+ that is the plural child class name.
       #
       # Example:
       #
-      #   class Game
+      #   class Person
       #     include Mongoid::Document
-      #     belongs_to_related :person
+      #     embeds_many :addresses
       #   end
       #
-      def belongs_to_related(name, options = {}, &block)
-        opts = Associations::Options.new(
-            options.merge(:name => name, :extend => block, :foreign_key => foreign_key(name, options))
-          )
-        add_association(Associations::BelongsToRelated, opts)
-        field(opts.foreign_key, :type => Mongoid.use_object_ids ? Mongo::ObjectID : String)
-        index(opts.foreign_key) unless self.embedded
+      #   class Address
+      #     include Mongoid::Document
+      #     embedded_in :person, :inverse_of => :addresses
+      #   end
+      def embeds_many(name, options = {}, &block)
+        associate(Associations::EmbedsMany, optionize(name, options, nil, &block))
+        set_callback(:update, :after) { |document| document.update_embedded(name) } unless name == :versions
       end
 
-      # Deprecated: Document.has_many will become Document.embed_many
-      def has_many(name, options = {}, &block)
-        Mongoid.deprecate("Document.has_many will become Document.embed_many")
-        embed_many(name, options, &block)
-      end
+      alias :embed_many :embeds_many
 
-      # 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
+      # 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:
@@ -118,22 +152,24 @@ module Mongoid # :nodoc:
       #
       #   class Person
       #     include Mongoid::Document
-      #     embed_many :addresses
+      #     embeds_one :name
       #   end
       #
-      #   class Address
+      #   class Name
       #     include Mongoid::Document
-      #     embedded_in :person, :inverse_of => :addresses
+      #     embedded_in :person
       #   end
-      def embed_many(name, options = {}, &block)
-        add_association(
-          Associations::EmbedMany,
-          Associations::Options.new(
-            options.merge(:name => name, :extend => block)
-          )
-        )
+      def embeds_one(name, options = {}, &block)
+        opts = optionize(name, options, nil, &block)
+        type = Associations::EmbedsOne
+        associate(type, opts)
+        add_builder(type, opts)
+        add_creator(type, opts)
+        set_callback(:update, :after) { |document| document.update_embedded(name) }
       end
 
+      alias :embed_one :embeds_one
+
       # Adds a relational association from the Document to many Documents in
       # another database or collection.
       #
@@ -149,51 +185,12 @@ module Mongoid # :nodoc:
       #   end
       #
       def has_many_related(name, options = {}, &block)
-        add_association(Associations::HasManyRelated,
-          Associations::Options.new(
-            options.merge(:name => name, :foreign_key => foreign_key(self.name, options), :extend => block)
-          )
-        )
-        before_save do |document|
+        associate(Associations::HasManyRelated, optionize(name, options, fk(self.name, options), &block))
+        set_callback :save, :before do |document|
           document.update_associations(name)
         end
       end
 
-      # Deprecated: Document.has_one will become Document.embed_one
-      def has_one(name, options = {}, &block)
-        Mongoid.deprecate("Document.has_one will become Document.embed_one")
-        embed_one(name, options, &block)
-      end
-
-      # 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
-      #     embed_one :name
-      #   end
-      #
-      #   class Name
-      #     include Mongoid::Document
-      #     embedded_in :person
-      #   end
-      def embed_one(name, options = {}, &block)
-        opts = Associations::Options.new(
-          options.merge(:name => name, :extend => block)
-        )
-        type = Associations::EmbedOne
-        add_association(type, opts)
-        add_builder(type, opts)
-        add_creator(type, opts)
-      end
-
       # Adds a relational association from the Document to one Document in
       # another database or collection.
       #
@@ -208,19 +205,14 @@ module Mongoid # :nodoc:
       #     has_one_related :game
       #   end
       def has_one_related(name, options = {}, &block)
-        add_association(
-          Associations::HasOneRelated,
-          Associations::Options.new(
-            options.merge(:name => name, :foreign_key => foreign_key(name, options), :extend => block)
-          )
-        )
-        before_save do |document|
+        associate(Associations::HasOneRelated, optionize(name, options, fk(self.name, options), &block))
+        set_callback :save, :before do |document|
           document.update_association(name)
         end
       end
 
       # Returns the macro associated with the supplied association name. This
-      # will return has_one, has_many, belongs_to or nil.
+      # will return embeds_on, embeds_many, embedded_in or nil.
       #
       # Options:
       #
@@ -238,14 +230,17 @@ module Mongoid # :nodoc:
       # 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.
-      def add_association(type, options)
+      #
+      # 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) { type.instantiate(self, options) }
-        end
+        define_method(name) { memoized(name) { type.instantiate(self, options) } }
         define_method("#{name}=") do |object|
-          reset(name) { type.update(object, self, options) }
+          unmemoize(name)
+          memoized(name) { type.update(object, self, options) }
         end
       end
 
@@ -253,8 +248,10 @@ module Mongoid # :nodoc:
       # build_name(attributes)
       def add_builder(type, options)
         name = options.name.to_s
-        define_method("build_#{name}") do |attrs|
-          reset(name) { type.new(self, (attrs || {}).stringify_keys, options) }
+        define_method("build_#{name}") do |*params|
+          attrs = params[0]
+          attr_options = params[1] || {}
+          reset(name) { type.new(self, (attrs || {}).stringify_keys, options) } unless type == Associations::EmbedsOne && attr_options[:update_only]
         end
       end
 
@@ -262,14 +259,22 @@ module Mongoid # :nodoc:
       # create_name(attributes)
       def add_creator(type, options)
         name = options.name.to_s
-        define_method("create_#{name}") do |attrs|
-          document = send("build_#{name}", attrs)
-          document.run_callbacks(:create) { document.save }; document
+        define_method("create_#{name}") do |*params|
+          attrs = params[0]
+          attr_options = params[1] || {}
+          send("build_#{name}", attrs, attr_options).tap(&:save) unless type == Associations::EmbedsOne && attr_options[:update_only]
         end
       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
+
       # Find the foreign key.
-      def foreign_key(name, options)
+      def fk(name, options)
         options[:foreign_key] || name.to_s.foreign_key
       end
     end

data/lib/mongoid/associations/belongs_to_related.rb

@@ -1,8 +1,8 @@
 # encoding: utf-8
 module Mongoid #:nodoc:
   module Associations #:nodoc:
-    class BelongsToRelated #:nodoc:
-      include Proxy
+    # Represents a relational association to a "parent" object.
+    class BelongsToRelated < Proxy
 
       # Initializing a related association only requires looking up the object
       # by its id.
@@ -53,7 +53,6 @@ module Mongoid #:nodoc:
           instantiate(document, options, target)
         end
       end
-
     end
   end
 end

data/lib/mongoid/associations/embedded_in.rb

@@ -1,8 +1,9 @@
 # encoding: utf-8
 module Mongoid #:nodoc:
   module Associations #:nodoc:
-    class EmbeddedIn #:nodoc:
-      include Proxy
+    # 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
@@ -48,16 +49,23 @@ module Mongoid #:nodoc:
 
         # 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 embed_one or an embed_many.
+        # +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.parentize(target, determine_name(target, options))
           child.notify
           instantiate(child, options)
         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
       end
     end
   end