mongoid 1.2.14 → 1.9.0

data/lib/mongoid.rb

@@ -22,12 +22,12 @@
 require "rubygems"
 
 gem "activesupport", ">= 2.2.2", "<3.0.pre"
-gem "mongo", ">= 0.19.1"
+gem "mongo", "~>1.0"
+gem "bson", "~>1.0"
 gem "durran-validatable", ">= 2.0.1"
 gem "will_paginate", ">= 2.3.11", "< 2.9"
 
 require "delegate"
-require "observer"
 require "singleton"
 require "time"
 require "validatable"
@@ -37,16 +37,19 @@ require "active_support/inflector"
 require "active_support/time_with_zone"
 require "will_paginate/collection"
 require "mongo"
+require "mongoid/concern"
+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"
@@ -60,6 +63,8 @@ require "mongoid/javascript"
 require "mongoid/matchers"
 require "mongoid/memoization"
 require "mongoid/named_scope"
+require "mongoid/paths"
+require "mongoid/persistence"
 require "mongoid/scope"
 require "mongoid/state"
 require "mongoid/timestamps"
@@ -69,6 +74,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

@@ -1,25 +1,25 @@
 # encoding: utf-8
 require "mongoid/associations/proxy"
-require "mongoid/associations/belongs_to"
 require "mongoid/associations/belongs_to_related"
-require "mongoid/associations/has_many"
+require "mongoid/associations/embedded_in"
+require "mongoid/associations/embeds_many"
+require "mongoid/associations/embeds_one"
 require "mongoid/associations/has_many_related"
-require "mongoid/associations/has_one"
 require "mongoid/associations/has_one_related"
 require "mongoid/associations/options"
 require "mongoid/associations/meta_data"
 
 module Mongoid # :nodoc:
   module Associations #:nodoc:
-    def self.included(base)
-      base.class_eval do
-        # Associations need to inherit down the chain.
-        class_inheritable_accessor :associations
-        self.associations = {}
+    extend ActiveSupport::Concern
+    included do
+      cattr_accessor :embedded
+      self.embedded = false
 
-        include InstanceMethods
-        extend ClassMethods
-      end
+      class_inheritable_accessor :associations
+      self.associations = {}
+
+      delegate :embedded, :embedded?, :to => "self.class"
     end
 
     module InstanceMethods
@@ -28,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.
@@ -38,9 +44,48 @@ 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
+
+      # 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
@@ -54,51 +99,56 @@ module Mongoid # :nodoc:
       #
       #   class Person
       #     include Mongoid::Document
-      #     has_many :addresses
+      #     embeds_many :addresses
       #   end
       #
       #   class Address
       #     include Mongoid::Document
-      #     belongs_to :person, :inverse_of => :addresses
+      #     embedded_in :person, :inverse_of => :addresses
       #   end
-      def belongs_to(name, options = {}, &block)
+      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::BelongsTo,
-          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.
+      alias :belongs_to :embedded_in
+
+      # 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))
+        unless name == :versions
+          after_update do |document|
+            document.update_embedded(name)
+          end
+        end
       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
+      alias :embed_many :embeds_many
+      alias :has_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:
@@ -109,22 +159,27 @@ module Mongoid # :nodoc:
       #
       #   class Person
       #     include Mongoid::Document
-      #     has_many :addresses
+      #     embeds_one :name
       #   end
       #
-      #   class Address
+      #   class Name
       #     include Mongoid::Document
-      #     belongs_to :person, :inverse_of => :addresses
+      #     embedded_in :person
       #   end
-      def has_many(name, options = {}, &block)
-        add_association(
-          Associations::HasMany,
-          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)
+        after_update do |document|
+          document.update_embedded(name)
+        end
       end
 
+      alias :embed_one :embeds_one
+      alias :has_one :embeds_one
+
       # Adds a relational association from the Document to many Documents in
       # another database or collection.
       #
@@ -140,45 +195,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)
-          )
-        )
+        associate(Associations::HasManyRelated, optionize(name, options, fk(self.name, options), &block))
         before_save do |document|
           document.update_associations(name)
         end
       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
-      #     has_many :addresses
-      #   end
-      #
-      #   class Address
-      #     include Mongoid::Document
-      #     belongs_to :person
-      #   end
-      def has_one(name, options = {}, &block)
-        opts = Associations::Options.new(
-          options.merge(:name => name, :extend => block)
-        )
-        type = Associations::HasOne
-        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.
       #
@@ -193,12 +215,7 @@ 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)
-          )
-        )
+        associate(Associations::HasOneRelated, optionize(name, options, fk(self.name, options), &block))
         before_save do |document|
           document.update_association(name)
         end
@@ -223,14 +240,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
 
@@ -249,16 +269,32 @@ module Mongoid # :nodoc:
         name = options.name.to_s
         define_method("create_#{name}") do |attrs|
           document = send("build_#{name}", attrs)
-          document.run_callbacks(:before_create)
-          document.save
-          document.run_callbacks(:after_create); document
+          document.save; document
         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
+
+      # Build the association options.
+      def build_options(name, options, &block)
+        Associations::Options.new(
+          options.merge(
+            :name => name,
+            :foreign_key => foreign_key(name, options),
+            :extend => block
+          )
+        )
+      end
     end
   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/{belongs_to.rb → embedded_in.rb}

@@ -1,8 +1,9 @@
 # encoding: utf-8
 module Mongoid #:nodoc:
   module Associations #:nodoc:
-    class BelongsTo #: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
@@ -43,21 +44,28 @@ module Mongoid #:nodoc:
 
         # Returns the macro used to create the association.
         def macro
-          :belongs_to
+          :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 a has_one or a has_many.
+        # +Document+. Will properly set an embeds_one or an embeds_many.
         #
         # Returns:
         #
-        # A new +BelongsTo+ association proxy.
+        # 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