mongoid 0.9.6 → 0.9.7

data/VERSION

@@ -1 +1 @@
-0.9.6
+0.9.7

data/lib/mongoid.rb

@@ -80,12 +80,12 @@ module Mongoid
   # Sets the Mongo::DB to be used.
   def self.database=(db)
     raise InvalidDatabaseError.new("Database should be a Mongo::DB, not #{db.class.name}") unless db.kind_of?(Mongo::DB)
-    @@database = db
+    @database = db
   end
 
   # Returns the Mongo::DB to use or raise an error if none was set.
   def self.database
-    @@database || (raise InvalidDatabaseError.new("No database has been set"))
+    @database || (raise InvalidDatabaseError.new("No database has been set"))
   end
 
 end

data/lib/mongoid/associations.rb

@@ -1,6 +1,4 @@
 # encoding: utf-8
-require "mongoid/associations/decorator"
-require "mongoid/associations/accessor"
 require "mongoid/associations/belongs_to"
 require "mongoid/associations/has_many"
 require "mongoid/associations/has_one"
@@ -22,9 +20,15 @@ module Mongoid # :nodoc:
         self.class.associations
       end
 
-      # Updates all the relational associations for the document.
+      # Updates all the one-to-many relational associations for the name.
       def update_associations(name)
-        send(name).each { |doc| doc.save }
+        send(name).each { |doc| doc.quick_save }
+      end
+
+      # Update the one-to-one relational association for the name.
+      def update_association(name)
+        association = send(name)
+        association.quick_save if association
       end
     end
 
@@ -138,12 +142,15 @@ module Mongoid # :nodoc:
       #   end
       #
       def relates_to_one(name, options = {})
-        field "#{name.to_s}_id"
-        index "#{name.to_s}_id"
+        key = name.to_s
+        field "#{key}_id"
         add_association(
           Associations::RelatesToOne,
           Associations::Options.new(options.merge(:name => name))
         )
+        before_save do |document|
+          document.update_association(name)
+        end
       end
 
       # Adds a relational association from the Document to many Documents in
@@ -162,7 +169,7 @@ module Mongoid # :nodoc:
       def relates_to_many(name, options = {})
         add_association(
           Associations::RelatesToMany,
-          Associations::Options.new(options.merge(:name => name))
+          Associations::Options.new(options.merge(:name => name, :parent_key => self.name.foreign_key))
         )
         before_save do |document|
           document.update_associations(name)
@@ -177,11 +184,11 @@ module Mongoid # :nodoc:
         associations[name] = type
         define_method(name) do
           return instance_variable_get("@#{name}") if instance_variable_defined?("@#{name}")
-          proxy = Associations::Accessor.get(type, self, options)
+          proxy = type.instantiate(self, options)
           instance_variable_set("@#{name}", proxy)
         end
         define_method("#{name}=") do |object|
-          proxy = Associations::Accessor.set(type, self, object, options)
+          proxy = type.update(object, self, options)
           if instance_variable_defined?("@#{name}")
             remove_instance_variable("@#{name}")
           else

data/lib/mongoid/associations/belongs_to.rb

@@ -2,27 +2,51 @@
 module Mongoid #:nodoc:
   module Associations #:nodoc:
     class BelongsTo #:nodoc:
-      include Decorator
 
-      # Creates the new association by setting the internal 
+      delegate :==, :to => :document
+      attr_reader :document, :options
+
+      # Creates the new association by setting the internal
       # document 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 parent +Document+
+      # options: The association options
       def initialize(document, options)
-        @document = document.parent
-        decorate!
+        @document, @options = document, options
       end
 
       # Returns the parent document. The id param is present for
-      # compatibility with rails, however this could be overwritten 
+      # compatibility with rails, however this could be overwritten
       # in the future.
       def find(id)
         @document
       end
 
+      # Delegate all missing methods over to the parent +Document+.
+      def method_missing(name, *args)
+        @document.send(name, *args)
+      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)
+          parent = document.parent
+          parent.nil? ? nil : new(parent, options)
+        end
+
         # Returns the macro used to create the association.
         def macro
           :belongs_to

data/lib/mongoid/associations/has_many.rb

@@ -83,6 +83,18 @@ module Mongoid #:nodoc:
       end
 
       class << self
+
+        # Preferred method of creating a new +HasMany+ 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
           :has_many

data/lib/mongoid/associations/has_one.rb

@@ -2,16 +2,13 @@
 module Mongoid #:nodoc:
   module Associations #:nodoc:
     class HasOne #:nodoc:
-      include Decorator
 
-      delegate :valid?, :to => :document
-
-      attr_accessor :parent, :options
+      delegate :==, :to => :document
+      attr_reader :document, :parent, :options
 
       # Build a new object for the association.
       def build(attributes)
         @document = attributes.assimilate(@parent, @options)
-        decorate!
         self
       end
 
@@ -28,14 +25,37 @@ module Mongoid #:nodoc:
       #
       # All method calls on this object will then be delegated
       # to the internal document itself.
-      def initialize(document, options)
+      #
+      # Options:
+      #
+      # document: The parent +Document+
+      # attributes: The attributes of the decorated object.
+      # options: The association options.
+      def initialize(document, attributes, options)
         @parent, @options = document, options
-        attributes = @parent.attributes[options.name]
-        @document = (attributes || {}).assimilate(@parent, @options)
-        decorate!
+        unless attributes.nil?
+          @document = attributes.assimilate(@parent, @options)
+        end
+      end
+
+      # Delegate all missing methods over to the +Document+.
+      def method_missing(name, *args)
+        @document.send(name, *args)
       end
 
       class << self
+        # Preferred method of instantiating a new +HasOne+, since nil values
+        # will be handled properly.
+        #
+        # Options:
+        #
+        # document: The parent +Document+
+        # options: The association options.
+        def instantiate(document, options)
+          attributes = document.attributes[options.name]
+          new(document, attributes, options)
+        end
+
         # Returns the macro used to create the association.
         def macro
           :has_one

data/lib/mongoid/associations/options.rb

@@ -32,6 +32,11 @@ module Mongoid #:nodoc:
         @attributes[:name]
       end
 
+      # Returns the parent foreign key association name.
+      def parent_key
+        @attributes[:parent_key]
+      end
+
       # Returns whether or not this association is polymorphic.
       def polymorphic
         @attributes[:polymorphic] == true

data/lib/mongoid/associations/relates_to_many.rb

@@ -17,6 +17,16 @@ module Mongoid #:nodoc:
       end
 
       class << self
+        # Preferred method for creating the new +RelatesToMany+ association.
+        #
+        # Options:
+        #
+        # document: The +Document+ that contains the relationship.
+        # options: The association +Options+.
+        def instantiate(document, options)
+          new(document, options)
+        end
+
         # Returns the macro used to create the association.
         def macro
           :relates_to_many

data/lib/mongoid/associations/relates_to_one.rb

@@ -2,7 +2,9 @@
 module Mongoid #:nodoc:
   module Associations #:nodoc:
     class RelatesToOne #:nodoc:
-      include Decorator
+
+      delegate :==, :to => :document
+      attr_reader :document
 
       # Initializing a related association only requires looking up the object
       # by its id.
@@ -11,12 +13,29 @@ module Mongoid #:nodoc:
       #
       # document: The +Document+ that contains the relationship.
       # options: The association +Options+.
-      def initialize(document, options)
-        @document = options.klass.find(document.send(options.foreign_key))
-        decorate!
+      def initialize(document, foreign_key, options)
+        @document = options.klass.find(foreign_key)
+      end
+
+      # Delegate all missing methods over to the +Document+.
+      def method_missing(name, *args)
+        @document.send(name, *args)
       end
 
       class << self
+        # Instantiate a new +RelatesToOne+ 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)
+          foreign_key = document.send(options.foreign_key)
+          foreign_key.nil? ? nil : new(document, foreign_key, options)
+        end
+
         # Returns the macro used to create the association.
         def macro
           :relates_to_one
@@ -35,7 +54,7 @@ module Mongoid #:nodoc:
         #
         # <tt>RelatesToOne.update(game, person, options)</tt>
         def update(related, parent, options)
-          parent.send("#{options.foreign_key}=", related.id)
+          parent.send("#{options.foreign_key}=", related.id); related
         end
       end
 

data/lib/mongoid/commands.rb

@@ -5,6 +5,7 @@ require "mongoid/commands/delete_all"
 require "mongoid/commands/destroy"
 require "mongoid/commands/destroy_all"
 require "mongoid/commands/save"
+require "mongoid/commands/quick_save"
 require "mongoid/commands/validate"
 
 module Mongoid #:nodoc:
@@ -61,6 +62,13 @@ module Mongoid #:nodoc:
         end
       end
 
+      # Performs a save with no validations and no callbacks. This is used in
+      # relational association saves, and is not recommended for use by
+      # anything else.
+      def quick_save
+        QuickSave.execute(self)
+      end
+
       # Update the attributes of the +Document+. Will call save after the
       # attributes have been updated.
       def update_attributes(attrs = {})

data/lib/mongoid/commands/quick_save.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Commands
+    class QuickSave
+      # Performs a save of the supplied +Document+ without any validations or
+      # callbacks. This is a dangerous command only intended for internal use
+      # with saving relational associations.
+      #
+      # Options:
+      #
+      # doc: A +Document+ that is going to be persisted.
+      #
+      # Returns: true
+      def self.execute(doc)
+        doc.collection.save(doc.attributes)
+      end
+    end
+  end
+end

data/lib/mongoid/commands/save.rb

@@ -21,7 +21,7 @@ module Mongoid #:nodoc:
           collection ? collection.save(doc.attributes) : raise(MissingParentError.new(doc))
         end
         doc.run_callbacks :after_save
-        return doc
+        return true
       end
     end
   end

data/lib/mongoid/criteria.rb

@@ -110,13 +110,9 @@ module Mongoid #:nodoc:
     # Example:
     #
     # <tt>criteria.each { |doc| p doc }</tt>
-    def each
+    def each(&block)
       @collection ||= execute
-      if block_given?
-        @collection.each { |doc| yield doc }
-      else
-        @collection.each
-      end
+      block_given? ? @collection.each { |doc| yield doc } : self
     end
 
     # Adds a criterion to the +Criteria+ that specifies values that are not allowed
@@ -152,9 +148,7 @@ module Mongoid #:nodoc:
     #
     # Returns: <tt>self</tt>
     def extras(extras)
-      @options = extras
-      filter_options
-      self
+      @options = extras; filter_options; self
     end
 
     # Return the first result for the +Criteria+.
@@ -176,8 +170,7 @@ module Mongoid #:nodoc:
     # Example:
     #
     # <tt>criteria.select(:field1).where(:field1 => "Title").group(Person)</tt>
-    def group(klass = nil)
-      @klass = klass if klass
+    def group
       @klass.collection.group(
         @options[:fields],
         @selector,
@@ -367,11 +360,8 @@ module Mongoid #:nodoc:
     # Either returns the page option and removes it from the options, or
     # returns a default value of 1.
     def page
-      if @options[:skip] && @options[:limit]
-        (@options[:skip].to_i + @options[:limit].to_i) / @options[:limit].to_i
-      else
-        1
-      end
+      skips, limits = @options[:skip], @options[:limit]
+      (skips && limits) ? (skips + limits) / limits : 1
     end
 
     # Executes the +Criteria+ and paginates the results.
@@ -505,8 +495,8 @@ module Mongoid #:nodoc:
       page_num = @options.delete(:page)
       per_page_num = @options.delete(:per_page)
       if (page_num || per_page_num)
-        @options[:limit] = (per_page_num || 20).to_i
-        @options[:skip] = (page_num || 1).to_i * @options[:limit] - @options[:limit]
+        @options[:limit] = limits = (per_page_num || 20).to_i
+        @options[:skip] = (page_num || 1).to_i * limits - limits
       end
     end
 

data/lib/mongoid/document.rb

@@ -8,17 +8,10 @@ module Mongoid #:nodoc:
     attr_accessor :association_name, :parent
     attr_reader :attributes, :new_record
 
-    define_callbacks \
-      :after_create,
-      :after_destroy,
-      :after_save,
-      :after_update,
-      :after_validation,
-      :before_create,
-      :before_destroy,
-      :before_save,
-      :before_update,
-      :before_validation
+    delegate :collection, :defaults, :embedded?, :fields, :primary_key, :to => :klass
+
+    define_callbacks :before_create, :before_destroy, :before_save, :before_update, :before_validation
+    define_callbacks :after_create, :after_destroy, :after_save, :after_update, :after_validation
 
     class << self
 
@@ -29,7 +22,7 @@ module Mongoid #:nodoc:
       # Returns: <tt>Mongo::Collection</tt>
       def collection
         return nil if embedded?
-        @collection_name = self.to_s.demodulize.tableize
+        @collection_name ||= self.to_s.demodulize.tableize
         @collection ||= Mongoid.database.collection(@collection_name)
       end
 
@@ -56,11 +49,8 @@ module Mongoid #:nodoc:
       #
       # <tt>field :score, :default => 0</tt>
       def field(name, options = {})
-        @fields ||= {}.with_indifferent_access
-        @defaults ||= {}.with_indifferent_access
-        @fields[name] = Field.new(name.to_s, options)
-        @defaults[name] = options[:default] if options[:default]
-        define_field_methods(name, options)
+        define(name, options)
+        default(name, options)
       end
 
       # Returns all the fields for the Document as a +Hash+ with names as keys.
@@ -107,12 +97,23 @@ module Mongoid #:nodoc:
       end
 
       protected
-      def define_field_methods(name, options)
+
+      # Define a field attribute for the +Document+.
+      def define(name, options = {})
+        @fields ||= {}.with_indifferent_access
+        @fields[name] = Field.new(name.to_s, options)
         define_method(name) { read_attribute(name) }
         define_method("#{name}=") { |value| write_attribute(name, value) }
         define_method("#{name}?") { read_attribute(name) == true } if options[:type] == Boolean
       end
 
+      # Set up a default value for a field.
+      def default(name, options = {})
+        value = options[:default]
+        @defaults ||= {}.with_indifferent_access
+        @defaults[name] = value if value
+      end
+
     end
 
     # Performs equality checking on the attributes. For now we chack against
@@ -138,9 +139,7 @@ module Mongoid #:nodoc:
     #
     # Returns: The child +Document+.
     def assimilate(parent, options)
-      parentize(parent, options.name)
-      notify
-      self
+      parentize(parent, options.name); notify; self
     end
 
     # Clone the current +Document+. This will return all attributes with the
@@ -149,26 +148,6 @@ module Mongoid #:nodoc:
       self.class.instantiate(@attributes.except(:_id).except(:versions).dup, true)
     end
 
-    # Get the Mongo::Collection associated with this Document.
-    def collection
-      self.class.collection
-    end
-
-    # Returns the class defaults
-    def defaults
-      self.class.defaults
-    end
-
-    # Return true if the +Document+ is embedded in another +Document+.
-    def embedded?
-      self.class.embedded?
-    end
-
-    # Get the fields for the Document class.
-    def fields
-      self.class.fields
-    end
-
     # Get the id associated with this object. This will pull the _id value out
     # of the attributes +Hash+.
     def id
@@ -209,22 +188,6 @@ module Mongoid #:nodoc:
       "#{self.class.name} : #{@attributes.inspect}"
     end
 
-    # Return the +Document+ primary key. This will only exist if a key has been
-    # set up on the +Document+ and will return an array of fields.
-    #
-    # Example:
-    #
-    #   class Person < Mongoid::Document
-    #     field :first_name
-    #     field :last_name
-    #     key :first_name, :last_name
-    #   end
-    #
-    # <tt>person.primary_key #[:first_name, :last_name]</tt>
-    def primary_key
-      self.class.primary_key
-    end
-
     # Returns true is the +Document+ has not been persisted to the database,
     # false if it has. This is determined by the instance variable @new_record
     # and NOT if the object has an id.
@@ -322,8 +285,8 @@ module Mongoid #:nodoc:
     # This will also cause the observing +Document+ to notify it's parent if
     # there is any.
     def update(child, clear = false)
-      @attributes.insert(child.association_name, child.attributes) unless clear
-      @attributes.delete(child.association_name) if clear
+      name = child.association_name
+      clear ? @attributes.delete(name) : @attributes.insert(name, child.attributes)
       notify
     end
 
@@ -377,5 +340,10 @@ module Mongoid #:nodoc:
         @attributes[:_id] = Mongo::ObjectID.new.to_s unless id
       end
     end
+
+    # Convenience method to get the document's class
+    def klass
+      self.class
+    end
   end
 end