mongoid 0.4.5 → 0.4.7

data/.watchr

@@ -8,4 +8,4 @@ def spec(file)
 end
 
 watch("spec/.*/*_spec\.rb")  {|md| p md[0]; spec(md[0]) }
-watch('lib/.*/(.*)\.rb')     {|md| p md[1]; spec("spec/unit/mongoid/#{md[1]}_spec.rb") }
+watch('lib/(.*/.*)\.rb')     {|md| p md[1]; spec("spec/unit/#{md[1]}_spec.rb") }

data/README.textile

@@ -18,6 +18,11 @@
   Mongoid is developed against Ruby 1.8.6, 1.8.7, 1.9.1, 1.9.2
 </p>
 
+<p>
+  Note API changes will be frequent until the 1.0 release, and do not expect
+  the gem to be of full production quality until that point.
+</p>
+
 <h2>Mongoid in Action</h2>
 
 Initialize Mongoid:

data/VERSION

@@ -1 +1 @@
-0.4.5
+0.4.7

data/lib/mongoid.rb

@@ -25,10 +25,11 @@ gem "mongo", "0.15.1"
 gem "durran-validatable", "1.7.5"
 gem "will_paginate", "2.3.11"
 
+require "delegate"
+require "observer"
 require "validatable"
 require "active_support/callbacks"
 require "active_support/core_ext"
-require "delegate"
 require "will_paginate/collection"
 require "mongo"
 require "mongoid/associations"
@@ -37,6 +38,7 @@ require "mongoid/criteria"
 require "mongoid/extensions"
 require "mongoid/field"
 require "mongoid/document"
+require "mongoid/timestamps"
 
 module Mongoid
 

data/lib/mongoid/associations.rb

@@ -2,4 +2,87 @@ require "mongoid/associations/decorator"
 require "mongoid/associations/factory"
 require "mongoid/associations/belongs_to_association"
 require "mongoid/associations/has_many_association"
-require "mongoid/associations/has_one_association"
+require "mongoid/associations/has_one_association"
+
+module Mongoid # :nodoc:
+  module Associations
+
+    # 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:
+    #
+    # association_name: A +Symbol+ that matches the name of the parent class.
+    #
+    # Example:
+    #
+    #   class Person < Mongoid::Document
+    #     has_many :addresses
+    #   end
+    #
+    #   class Address < Mongoid::Document
+    #     belongs_to :person
+    #   end
+    def belongs_to(association_name)
+      @embedded = true
+      add_association(:belongs_to, association_name.to_s.classify, association_name)
+    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:
+    #
+    # association_name: A +Symbol+ that is the plural child class name.
+    #
+    # Example:
+    #
+    #   class Person < Mongoid::Document
+    #     has_many :addresses
+    #   end
+    #
+    #   class Address < Mongoid::Document
+    #     belongs_to :person
+    #   end
+    def has_many(association_name)
+      add_association(:has_many, association_name.to_s.classify, association_name)
+    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:
+    #
+    # association_name: A +Symbol+ that is the plural child class name.
+    #
+    # Example:
+    #
+    #   class Person < Mongoid::Document
+    #     has_many :addresses
+    #   end
+    #
+    #   class Address < Mongoid::Document
+    #     belongs_to :person
+    #   end
+    def has_one(association_name)
+      add_association(:has_one, association_name.to_s.titleize, association_name)
+    end
+
+    private
+    # Adds the association to the associations hash with the type as the key,
+    # then adds the accessors for the association.
+    def add_association(type, class_name, name)
+      define_method(name) do
+        Associations::Factory.create(type, name, self)
+      end
+      define_method("#{name}=") do |object|
+        object.parentize(self, name)
+        @attributes[name] = object.mongoidize
+      end
+    end
+  end
+end

data/lib/mongoid/associations/has_many_association.rb

@@ -2,10 +2,12 @@ module Mongoid #:nodoc:
   module Associations #:nodoc:
     class HasManyAssociation < DelegateClass(Array) #:nodoc:
 
+      attr_accessor :association_name
+
       # Appends the object to the +Array+, setting its parent in
       # the process.
       def <<(object)
-        object.parentize(@parent)
+        object.parentize(@parent, @association_name)
         @documents << object
       end
 
@@ -28,6 +30,7 @@ module Mongoid #:nodoc:
       # Returns the newly created object.
       def build(attributes)
         object = @klass.new(attributes)
+        object.parentize(@parent, @association_name)
         push(object)
         object
       end
@@ -49,11 +52,12 @@ module Mongoid #:nodoc:
       # essentially a proxy to an array itself.
       def initialize(association_name, document)
         @parent = document
-        @klass = association_name.to_s.classify.constantize
-        attributes = document.attributes[association_name]
+        @association_name = association_name
+        @klass = @association_name.to_s.classify.constantize
+        attributes = document.attributes[@association_name]
         @documents = attributes ? attributes.collect do |attribute|
           child = @klass.new(attribute)
-          child.parent = document
+          child.parentize(@parent, @association_name)
           child
         end : []
         super(@documents)

data/lib/mongoid/commands.rb

@@ -57,15 +57,15 @@ module Mongoid #:nodoc:
 
       # Update the attributes of the +Document+. Will call save after the
       # attributes have been updated.
-      def update_attributes(attributes = {})
-        self.attributes = attributes; save
+      def update_attributes(attrs = {})
+        write_attributes(attrs); save
       end
 
       # Update the attributes of the +Document+. Will call save! after the
       # attributes have been updated, causing a +ValidationError+ if the
       # +Document+ failed validation.
-      def update_attributes!(attribtues = {})
-        self.attributes = attributes; save!
+      def update_attributes!(attrs = {})
+        write_attributes(attrs); save!
       end
 
     end

data/lib/mongoid/criteria.rb

@@ -14,8 +14,23 @@ module Mongoid #:nodoc:
   #
   # <tt>criteria.execute</tt>
   class Criteria
+    attr_accessor :klass
     attr_reader :selector, :options, :type
 
+    AGGREGATE_REDUCE = "function(obj, prev) { prev.count++; }"
+    # Aggregate the criteria. This will take the internally built selector and options
+    # and pass them on to the Ruby driver's +group()+ method on the collection. The
+    # collection itself will be retrieved from the class provided, and once the
+    # query has returned it will provided a grouping of keys with counts.
+    #
+    # Example:
+    # 
+    # <tt>criteria.select(:field1).where(:field1 => "Title").aggregate(Person)</tt>
+    def aggregate(klass = nil)
+      @klass = klass if klass
+      @klass.collection.group(@options[:fields], @selector, { :count => 0 }, AGGREGATE_REDUCE)
+    end
+
     # Adds a criterion to the +Criteria+ that specifies values that must all
     # be matched in order to return results. Similar to an "in" clause but the
     # underlying conditional logic is an "AND" and not an "OR". The MongoDB
@@ -67,9 +82,10 @@ module Mongoid #:nodoc:
     #
     # If this is a +Criteria+ to find multiple results, will return an +Array+ of
     # objects of the type of class provided.
-    def execute(klass)
-      return klass.new(klass.collection.find_one(@selector, @options)) if type == :first
-      return klass.collection.find(@selector, @options).collect { |doc| klass.new(doc) }
+    def execute(klass = nil)
+      @klass = klass if klass
+      return @klass.new(klass.collection.find_one(@selector, @options)) if type == :first
+      return @klass.collection.find(@selector, @options).collect { |doc| @klass.new(doc) }
     end
 
     # Adds a criterion to the +Criteria+ that specifies additional options
@@ -88,6 +104,27 @@ module Mongoid #:nodoc:
       @options = extras; self
     end
 
+    GROUP_REDUCE = "function(obj, prev) { prev.group.push(obj); }"
+    # Groups the criteria. This will take the internally built selector and options
+    # and pass them on to the Ruby driver's +group()+ method on the collection. The
+    # collection itself will be retrieved from the class provided, and once the
+    # query has returned it will provided a grouping of keys with objects.
+    #
+    # Example:
+    # 
+    # <tt>criteria.select(:field1).where(:field1 => "Title").group(Person)</tt>
+    def group(klass = nil)
+      @klass = klass if klass
+      @klass.collection.group(
+        @options[:fields],
+        @selector,
+        { :group => [] },
+        GROUP_REDUCE
+      ).collect do |docs|
+        docs["group"] = docs["group"].collect { |attrs| @klass.new(attrs) }; docs
+      end
+    end
+
     # Adds a criterion to the +Criteria+ that specifies values where any can
     # be matched in order to return results. This is similar to an SQL "IN"
     # clause. The MongoDB conditional operator that will be used is "$in".
@@ -129,8 +166,9 @@ module Mongoid #:nodoc:
     # Options:
     #
     # type: One of :all, :first:, or :last
-    def initialize(type)
-      @selector, @options, @type = {}, {}, type
+    # klass: The class to execute on.
+    def initialize(type, klass = nil)
+      @selector, @options, @type, @klass = {}, {}, type, klass
     end
 
     # Adds a criterion to the +Criteria+ that specifies the maximum number of
@@ -170,6 +208,14 @@ module Mongoid #:nodoc:
       exclusions.each { |key, value| @selector[key] = { "$nin" => value } }; self
     end
 
+    # Returns the offset option. If a per_page option is in the list then it
+    # will replace it with a skip parameter and return the same value. Defaults
+    # to 20 if nothing was provided.
+    def offset
+      offset = @options.delete(:per_page) || 20
+      @options[:skip] ||= offset
+    end
+
     # Adds a criterion to the +Criteria+ that specifies the sort order of
     # the returned documents in the database. Similar to a SQL "ORDER BY".
     #
@@ -186,6 +232,12 @@ module Mongoid #:nodoc:
       @options[:sort] = params; self
     end
 
+    # Either returns the page option and removes it from the options, or
+    # returns a default value of 1.
+    def page
+      @options.delete(:page) || 1
+    end
+
     # Adds a criterion to the +Criteria+ that specifies the fields that will
     # get returned from the Document. Used mainly for list views that do not
     # require all fields to be present. This is similar to SQL "SELECT" values.

data/lib/mongoid/document.rb

@@ -1,13 +1,11 @@
 module Mongoid #:nodoc:
   class Document
     include ActiveSupport::Callbacks
-    include Validatable
-    include Commands
+    include Commands, Observable, Validatable
+    extend Associations
 
-    AGGREGATE_REDUCE = "function(obj, prev) { prev.count++; }"
-    GROUP_BY_REDUCE = "function(obj, prev) { prev.group.push(obj); }"
-
-    attr_accessor :attributes, :parent
+    attr_accessor :association_name, :parent
+    attr_reader :attributes
 
     define_callbacks \
       :after_create,
@@ -19,37 +17,22 @@ module Mongoid #:nodoc:
 
     class << self
 
-      # Get an aggregate count for the supplied group of fields and the
-      # selector that is provided.
-      def aggregate(fields, params = {})
-        selector = params[:conditions]
-        collection.group(fields, selector, { :count => 0 }, AGGREGATE_REDUCE)
-      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.
+      # Find +Documents+ given the conditions.
       #
       # Options:
       #
-      # association_name: A +Symbol+ that matches the name of the parent class.
-      #
-      # Example:
-      #
-      #   class Person < Mongoid::Document
-      #     has_many :addresses
-      #   end
+      # args: A +Hash+ with a conditions key and other options
       #
-      #   class Address < Mongoid::Document
-      #     belongs_to :person
-      #   end
-      def belongs_to(association_name)
-        @embedded = true
-        add_association(:belongs_to, association_name.to_s.classify, association_name)
+      # <tt>Person.all(:conditions => { :attribute => "value" })</tt>
+      def all(*args)
+        find(:all, *args)
       end
 
-      # Get the Mongo::Collection associated with this Document.
+      # Returns the collection associated with this +Document+. If the
+      # document is embedded, there will be no collection associated
+      # with it.
+      #
+      # Returns: <tt>Mongo::Collection</tt>
       def collection
         return nil if @embedded
         @collection_name = self.to_s.demodulize.tableize
@@ -97,85 +80,57 @@ module Mongoid #:nodoc:
         Criteria.translate(*args).execute(self)
       end
 
-      # Find a single Document given the passed selector, which is a Hash of attributes that
-      # must match the Document in the database exactly.
+      # Find the first +Document+ given the conditions.
+      #
+      # Options:
+      #
+      # args: A +Hash+ with a conditions key and other options
+      #
+      # <tt>Person.first(:conditions => { :attribute => "value" })</tt>
       def first(*args)
         find(:first, *args)
       end
 
-      # Find all Documents given the passed selector, which is a Hash of attributes that
-      # must match the Document in the database exactly.
-      def all(*args)
-        find(:all, *args)
+      # Adds an index on the field specified. Options can be :unique => true or
+      # :unique => false. It will default to the latter.
+      def index(name, options = { :unique => false })
+        collection.create_index(name, options)
       end
 
-      # Find all Documents given the supplied criteria, grouped by the fields
-      # provided.
-      def group_by(fields, params = {})
-        selector = params[:condition]
-        collection.group(fields, selector, { :group => [] }, GROUP_BY_REDUCE).collect do |docs|
-          docs["group"] = docs["group"].collect { |attrs| new(attrs) }; docs
-        end
+      # Defines the field that will be used for the id of this +Document+. This
+      # set the id of this +Document+ before save to a parameterized version of
+      # the field that was supplied. This is good for use for readable URLS in
+      # web applications and *MUST* be defined on documents that are embedded
+      # in order for proper updates in has_may associations.
+      def key(*fields)
+        @primary_key = fields
+        before_save :generate_key
       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.
+      # Returns the primary key field of the +Document+
+      def primary_key
+        @primary_key
+      end
+
+      # Find all documents in paginated fashion given the supplied arguments.
+      # If no parameters are passed just default to offset 0 and limit 20.
       #
       # Options:
       #
-      # association_name: A +Symbol+ that is the plural child class name.
+      # params: A +Hash+ of params to pass to the Criteria API.
       #
       # Example:
       #
-      #   class Person < Mongoid::Document
-      #     has_many :addresses
-      #   end
+      # <tt>Person.paginate(:conditions => { :field => "Test" }, :page => 1,
+      # :per_page => 20)</tt>
       #
-      #   class Address < Mongoid::Document
-      #     belongs_to :person
-      #   end
-      def has_many(association_name)
-        add_association(:has_many, association_name.to_s.classify, association_name)
-      end
-
-      # Create a one-to-many association between Documents.
-      def has_one(association_name)
-        add_association(:has_one, association_name.to_s.titleize, association_name)
-      end
-
-      # Adds timestamps on the Document in the form of the fields 'created_on'
-      # and 'last_modified'
-      def has_timestamps
-        field :created_at
-        field :last_modified
-        class_eval do
-          before_create \
-            :update_created_at,
-            :update_last_modified
-          before_save :update_last_modified
-        end
-      end
-
-      # Adds an index on the field specified. Options can be :unique => true or
-      # :unique => false. It will default to the latter.
-      def index(name, options = { :unique => false })
-        collection.create_index(name, options)
-      end
-
-      # Find all documents in paginated fashion given the supplied arguments.
-      # If no parameters are passed just default to offset 0 and limit 20.
+      # Returns paginated array of docs.
       def paginate(params = {})
-        selector = params[:conditions]
-        WillPaginate::Collection.create(
-          params[:page] || 1,
-          params[:per_page] || 20,
-          0) do |pager|
-            results = collection.find(selector, { :sort => params[:sort],
-                                                  :limit => pager.per_page,
-                                                  :skip => pager.offset })
-            pager.total_entries = results.count
-            pager.replace(results.collect { |doc| new(doc) })
+        criteria = Criteria.translate(:all, params)
+        WillPaginate::Collection.create(criteria.page, criteria.offset, 0) do |pager|
+          results = criteria.execute(self)
+          pager.total_entries = results.size
+          pager.replace(results)
         end
       end
 
@@ -193,7 +148,7 @@ module Mongoid #:nodoc:
       #
       # Returns: <tt>Criteria</tt>
       def select(*args)
-        Criteria.new(:all).select(*args)
+        Criteria.new(:all, self).select(*args)
       end
 
     end
@@ -219,6 +174,12 @@ module Mongoid #:nodoc:
     def initialize(attributes = {})
       @attributes = attributes.symbolize_keys if attributes
       @attributes = {} unless attributes
+      generate_key
+    end
+
+    # Return the +Document+ primary key.
+    def primary_key
+      self.class.primary_key
     end
 
     # Returns true is the Document has not been persisted to the database, false if it has.
@@ -226,27 +187,10 @@ module Mongoid #:nodoc:
       @attributes[:_id].nil?
     end
 
-    # Returns the id of the Document
-    def to_param
-      id.to_s
-    end
-
-    private
-
-    class << self
-
-      # Adds the association to the associations hash with the type as the key,
-      # then adds the accessors for the association.
-      def add_association(type, class_name, name)
-        define_method(name) do
-          Mongoid::Associations::Factory.create(type, name, self)
-        end
-        define_method("#{name}=") do |object|
-          object.parentize(self)
-          @attributes[name] = object.mongoidize
-        end
-      end
-
+    # Notify observers that this Document has changed.
+    def notify
+      changed(true)
+      notify_observers(self)
     end
 
     # Read from the attributes hash.
@@ -255,23 +199,37 @@ module Mongoid #:nodoc:
       fields[symbol].value(@attributes[symbol])
     end
 
-    # Update the created_at field on the Document to the current time. This is
-    # only called on create.
-    def update_created_at
-      self.created_at = Time.now
+    # Returns the id of the Document
+    def to_param
+      id.to_s
     end
 
-    # Update the last_modified field on the Document to the current time.
-    # This is only called on create and on save.
-    def update_last_modified
-      self.last_modified = Time.now
+    # Update the document based on notify from child
+    def update(child)
+      @attributes.insert(child.association_name, child.attributes)
+      notify
     end
 
     # Write to the attributes hash.
     def write_attribute(name, value)
       symbol = name.to_sym
-      @attributes[name.to_sym] = fields[symbol].value(value)
+      @attributes[name.to_sym] = value
+      notify
+    end
+
+    # Writes all the attributes of this Document, and delegate up to 
+    # the parent.
+    def write_attributes(attrs)
+      @attributes = attrs
+      notify
     end
 
+    private
+    def generate_key
+      if primary_key
+        values = primary_key.collect { |key| @attributes[key] }
+        @attributes[:_id] = values.join(" ").parameterize.to_s
+      end
+    end
   end
 end