mongoid 2.0.0.beta.5 → 2.0.0.beta.7

data/lib/mongoid.rb

@@ -21,8 +21,9 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 require "rubygems"
 
-gem "activemodel", "3.0.0.beta3"
-gem "will_paginate", "3.0.pre"
+gem "activemodel", "~>3.0.0.beta"
+gem "tzinfo", "~>0.3.22"
+gem "will_paginate", "~>3.0.pre"
 gem "mongo", "~>1.0.1"
 gem "bson", "~>1.0.1"
 
@@ -48,6 +49,7 @@ require "will_paginate/collection"
 require "mongo"
 require "mongoid/observable"
 require "mongoid/associations"
+require "mongoid/atomicity"
 require "mongoid/attributes"
 require "mongoid/callbacks"
 require "mongoid/collection"
@@ -65,6 +67,7 @@ require "mongoid/factory"
 require "mongoid/field"
 require "mongoid/fields"
 require "mongoid/finders"
+require "mongoid/hierarchy"
 require "mongoid/identity"
 require "mongoid/indexes"
 require "mongoid/javascript"
@@ -81,6 +84,11 @@ require "mongoid/versioning"
 require "mongoid/components"
 require "mongoid/document"
 
+# add railtie
+if defined?(Rails)
+  require "mongoid/railtie"
+end
+
 module Mongoid #:nodoc
 
   MONGODB_VERSION = "1.4.0"

data/lib/mongoid/associations.rb

@@ -1,11 +1,13 @@
 # encoding: utf-8
 require "mongoid/associations/proxy"
-require "mongoid/associations/belongs_to_related"
 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_related"
+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"
 
@@ -13,6 +15,8 @@ module Mongoid # :nodoc:
   module Associations #:nodoc:
     extend ActiveSupport::Concern
     included do
+      include ForeignKey
+
       cattr_accessor :embedded
       self.embedded = false
 
@@ -22,57 +26,44 @@ module Mongoid # :nodoc:
       delegate :embedded, :embedded?, :to => "self.class"
     end
 
-    module InstanceMethods
-      # Returns the associations for the +Document+.
-      def associations
-        self.class.associations
-      end
+    # Returns the associations for the +Document+.
+    def associations
+      self.class.associations
+    end
 
-      # are we in an embeds_many?
-      def embedded_many?
-        embedded? and _parent.associations[association_name].association == EmbedsMany
-      end
+    # are we in an embeds_many?
+    def embedded_many?
+      embedded? && _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
+    # 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
+    # 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
+    # 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
 
-    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?
+    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?
+          target = send(name)
+          send("#{foreign_key}=", target ? target.id : nil)
+        end
       end
+    end
 
+    module ClassMethods
       # Gets whether or not the document is embedded.
       #
       # Example:
@@ -135,7 +126,6 @@ module Mongoid # :nodoc:
       #   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
 
       alias :embed_many :embeds_many
@@ -147,7 +137,7 @@ module Mongoid # :nodoc:
       # Options:
       #
       # name: A +Symbol+ that is the plural child class name.
-      #
+     #
       # Example:
       #
       #   class Person
@@ -165,11 +155,34 @@ module Mongoid # :nodoc:
         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 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)
+        associate(Associations::ReferencedIn, opts)
+        field(opts.foreign_key, :type => Mongoid.use_object_ids ? BSON::ObjectID : String)
+        index(opts.foreign_key) unless embedded?
+        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.
       #
@@ -181,16 +194,18 @@ module Mongoid # :nodoc:
       #
       #   class Person
       #     include Mongoid::Document
-      #     has_many_related :posts
+      #     references_many :posts
       #   end
       #
-      def has_many_related(name, options = {}, &block)
-        associate(Associations::HasManyRelated, optionize(name, options, fk(self.name, options), &block))
+      def references_many(name, options = {}, &block)
+        reference_many(name, options, &block)
         set_callback :save, :before do |document|
           document.update_associations(name)
         end
       end
 
+      alias :has_many_related :references_many
+
       # Adds a relational association from the Document to one Document in
       # another database or collection.
       #
@@ -202,15 +217,18 @@ module Mongoid # :nodoc:
       #
       #   class Person
       #     include Mongoid::Document
-      #     has_one_related :game
+      #     references_one :game
       #   end
-      def has_one_related(name, options = {}, &block)
-        associate(Associations::HasOneRelated, optionize(name, options, fk(self.name, options), &block))
+      def references_one(name, options = {}, &block)
+        opts = optionize(name, options, constraint(name, options, :one), &block)
+        associate(Associations::ReferencesOne, opts)
         set_callback :save, :before do |document|
           document.update_association(name)
         end
       end
 
+      alias :has_one_related :references_one
+
       # Returns the macro associated with the supplied association name. This
       # will return embeds_on, embeds_many, embedded_in or nil.
       #
@@ -273,9 +291,15 @@ module Mongoid # :nodoc:
         )
       end
 
-      # Find the foreign key.
-      def fk(name, options)
-        options[:foreign_key] || name.to_s.foreign_key
+      def reference_many(name, options, &block)
+        if (options[:stored_as] == :array)
+          opts = optionize(name, options, constraint(name, options, :many_as_array), &block)
+          field "#{name.to_s.singularize}_ids", :type => Array, :default => []
+          associate(Associations::ReferencesManyAsArray, opts)
+        else
+          opts = optionize(name, options, constraint(name, options, :many), &block)
+          associate(Associations::ReferencesMany, opts)
+        end
       end
     end
   end

data/lib/mongoid/associations/embeds_one.rb

@@ -26,9 +26,9 @@ module Mongoid #:nodoc:
       # Returns:
       #
       # A new +HashOne+ association proxy.
-      def initialize(document, attrs, options)
+      def initialize(document, attrs, options, target = nil)
         @parent, @options  = document, options
-        @target = attrs.assimilate(@parent, @options, attrs.klass)
+        @target = target ? target : attrs.assimilate(@parent, @options, attrs.klass)
         extends(options)
       end
 
@@ -58,10 +58,10 @@ module Mongoid #:nodoc:
         # Returns:
         #
         # A new +EmbedsOne+ association proxy.
-        def instantiate(document, options)
+        def instantiate(document, options, target = nil)
           attributes = document.raw_attributes[options.name]
-          return nil if attributes.blank?
-          new(document, attributes, options)
+          return nil if attributes.blank? && target.nil?
+          new(document, attributes, options, target)
         end
 
         # Returns the macro used to create the association.
@@ -87,7 +87,7 @@ module Mongoid #:nodoc:
         # A new +EmbedsOne+ association proxy.
         def update(child, parent, options)
           child.assimilate(parent, options)
-          instantiate(parent, options)
+          instantiate(parent, options, child.is_a?(Hash) ? nil : child)
         end
       end
     end

data/lib/mongoid/associations/foreign_key.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Associations #:nodoc:
+    module ForeignKey #:nodoc:
+      extend ActiveSupport::Concern
+
+      module ClassMethods #:nodoc:
+        # Determine the value for the foreign key constriant field in the
+        # database, based on the type of association or if the actual value was
+        # supplied as an option.
+        #
+        # Example:
+        #
+        # <tt>contraint(:posts, {}, :references_one)</tt>
+        #
+        # Returns
+        #
+        # A +String+ for the foreign key field.
+        def constraint(name, options, association)
+          key = options[:foreign_key]
+
+          # Always return the supplied foreign_key option if it was supplied -
+          # the user should always be ble to override.
+          return key.to_s if key
+
+          case association
+          when :one, :many then self.name.foreign_key
+          when :many_as_array then "#{name.to_s.singularize}_ids"
+          else name.to_s.foreign_key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/associations/meta_data.rb

@@ -13,6 +13,15 @@ module Mongoid #:nodoc:
         define_method(name) { |*args| @options.send(name) }
       end
 
+      # Return true if this meta data is for an embedded association.
+      #
+      # Example:
+      #
+      # <tt>metadata.embedded?</tt>
+      def embedded?
+        [ EmbedsOne, EmbedsMany ].include?(association)
+      end
+
       # Create the new associations MetaData object, which holds the type of
       # the association and its options, with convenience methods for getting
       # that information.

data/lib/mongoid/associations/options.rb

@@ -52,7 +52,7 @@ module Mongoid #:nodoc:
         @attributes[:polymorphic] == true
       end
 
-      # Used with has_many_related to save as array of ids.
+      # Used with references_many to save as array of ids.
       def stored_as
         @attributes[:stored_as]
       end

data/lib/mongoid/associations/proxy.rb

@@ -19,6 +19,15 @@ module Mongoid #:nodoc
       def extends(options)
         extend Module.new(&options.extension) if options.extension?
       end
+
+      # Sets up the parent, klass, foreign_key, options
+      def setup(document, options)
+        @parent = document
+        @klass = options.klass
+        @options = options
+        @foreign_key = options.foreign_key
+        extends(options)
+      end
     end
   end
 end

data/lib/mongoid/associations/{belongs_to_related.rb → referenced_in.rb}

@@ -2,7 +2,7 @@
 module Mongoid #:nodoc:
   module Associations #:nodoc:
     # Represents a relational association to a "parent" object.
-    class BelongsToRelated < Proxy
+    class ReferencedIn < Proxy
 
       # Initializing a related association only requires looking up the object
       # by its id.
@@ -18,7 +18,7 @@ module Mongoid #:nodoc:
       end
 
       class << self
-        # Instantiate a new +BelongsToRelated+ or return nil if the foreign key is
+        # Instantiate a new +ReferencedIn+ or return nil if the foreign key is
         # nil. It is preferrable to use this method over the traditional call
         # to new.
         #
@@ -28,12 +28,13 @@ module Mongoid #:nodoc:
         # 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)
+          return nil if foreign_key.blank? && target.nil?
+          new(document, foreign_key, options, target)
         end
 
         # Returns the macro used to create the association.
         def macro
-          :belongs_to_related
+          :referenced_in
         end
 
         # Perform an update of the relationship of the parent and child. This
@@ -47,7 +48,7 @@ module Mongoid #:nodoc:
         #
         # Example:
         #
-        # <tt>BelongsToRelated.update(person, game, options)</tt>
+        # <tt>ReferencedIn.update(person, game, options)</tt>
         def update(target, document, options)
           document.send("#{options.foreign_key}=", target ? target.id : nil)
           instantiate(document, options, target)

data/lib/mongoid/associations/{has_many_related.rb → references_many.rb}

@@ -3,7 +3,7 @@ module Mongoid #:nodoc:
   module Associations #:nodoc:
     # Represents an relational one-to-many association with an object in a
     # separate collection or database.
-    class HasManyRelated < Proxy
+    class ReferencesMany < Proxy
 
       # Appends the object to the +Array+, setting its parent in
       # the process.
@@ -16,24 +16,22 @@ module Mongoid #:nodoc:
         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 object.
-      def build(attributes = {})
+      def build(attributes = nil)
         load_target
         name = @parent.class.to_s.underscore
-        object = @klass.instantiate(attributes.merge(name => @parent))
+        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
@@ -80,9 +78,10 @@ module Mongoid #:nodoc:
 
       # 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)
+      def find(id_or_type, options = {})
+        return self.id_criteria(id_or_type) unless id_or_type.is_a?(Symbol)
+        options[:conditions] = (options[:conditions] || {}).merge(@foreign_key.to_sym => @parent.id)
+        @klass.find(id_or_type, options)
       end
 
       # Initializing a related association only requires looking up the objects
@@ -93,11 +92,8 @@ module Mongoid #:nodoc:
       # document: The +Document+ that contains the relationship.
       # options: The association +Options+.
       def initialize(document, options, target = nil)
-        @parent, @klass, @options = document, options.klass, options
-        @foreign_key = options.foreign_key
-        @base = lambda { @klass.all(:conditions => { @foreign_key => document.id }) }
-        @target = target || @base.call
-        extends(options)
+        setup(document, options)
+        @target = target || query.call
       end
 
       # Override the default behavior to allow the criteria to get reset on
@@ -112,21 +108,60 @@ module Mongoid #:nodoc:
       #
       # A Criteria object or Array.
       def method_missing(name, *args, &block)
-        @target = @base.call unless @target.is_a?(Array)
+        @target = query.call unless @target.is_a?(Array)
         @target.send(name, *args, &block)
       end
 
-      # Delegates to <<
-      def push(*objects)
-        self << objects
+      # 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 = {})
+        attributes.each do |index, attrs|
+          begin
+            document = find(index.to_i)
+            if options && options[:allow_destroy] && attrs['_destroy']
+              @target.delete(document)
+              document.destroy
+            else
+              document.write_attributes(attrs)
+            end
+          rescue Errors::DocumentNotFound
+            build(attrs)
+          end
+        end
       end
 
       protected
-      # Load the target entries if the document is new.
+      # Load the target entries if the parent document is new.
       def load_target
         @target = @target.entries if @parent.new_record?
       end
 
+      # The default query used for retrieving the documents from the database.
+      # In this case we use the common API between Mongoid, ActiveRecord, and
+      # DataMapper so we can do one-to-many relationships with data in other
+      # databases.
+      #
+      # Example:
+      #
+      # <tt>association.query</tt>
+      #
+      # Returns:
+      #
+      #   A +Criteria+ if a Mongoid association.
+      #   An +Array+ of objects if an ActiveRecord association
+      #   A +Collection+ if a DataMapper association.
+      def query
+        @query ||= lambda { @klass.all(:conditions => { @foreign_key => @parent.id }) }
+      end
+
       # Remove the objects based on conditions.
       def remove(method, conditions)
         selector = { @foreign_key => @parent.id }.merge(conditions || {})
@@ -134,13 +169,22 @@ module Mongoid #:nodoc:
         reset; removed
       end
 
-      # Reset the memoized association on the parent.
+      # Reset the memoized association on the parent. This will execute the
+      # database query again.
+      #
+      # Example:
+      #
+      # <tt>association.reset</tt>
+      #
+      # Returns:
+      #
+      # See #query rdoc for return values.
       def reset
-        @parent.send(:reset, @options.name) { @base.call }
+        @parent.send(:reset, @options.name) { query.call }
       end
 
       class << self
-        # Preferred method for creating the new +HasManyRelated+ association.
+        # Preferred method for creating the new +ReferencesMany+ association.
         #
         # Options:
         #
@@ -152,7 +196,7 @@ module Mongoid #:nodoc:
 
         # Returns the macro used to create the association.
         def macro
-          :has_many_related
+          :references_many
         end
 
         # Perform an update of the relationship of the parent and child. This
@@ -173,7 +217,6 @@ module Mongoid #:nodoc:
           instantiate(document, options, target)
         end
       end
-
     end
   end
 end