mongoid 2.0.0.alpha → 2.0.0.beta.5

data/lib/mongoid/contexts.rb

@@ -15,11 +15,10 @@ module Mongoid
     #
     # <tt>Contexts.context_for(criteria)</tt>
     def self.context_for(criteria)
-      if criteria.klass.embedded
+      if criteria.klass.embedded?
         return Contexts::Enumerable.new(criteria)
       end
       Contexts::Mongo.new(criteria)
     end
-
   end
 end

data/lib/mongoid/contexts/enumerable.rb

@@ -6,7 +6,7 @@ module Mongoid #:nodoc:
       attr_reader :criteria
 
       delegate :blank?, :empty?, :first, :last, :to => :execute
-      delegate :documents, :options, :selector, :to => :criteria
+      delegate :klass, :documents, :options, :selector, :to => :criteria
 
       # Return aggregation counts of the grouped documents. This will count by
       # the first field provided in the fields array.

data/lib/mongoid/contexts/mongo.rb

@@ -133,7 +133,7 @@ module Mongoid #:nodoc:
       # <tt>Mongoid::Contexts::Mongo.new(criteria)</tt>
       def initialize(criteria)
         @criteria = criteria
-        if klass.hereditary && Mongoid.persist_types
+        if klass.hereditary
           criteria.in(:_type => criteria.klass._types)
         end
         criteria.enslave if klass.enslaved?

data/lib/mongoid/contexts/paging.rb

@@ -6,12 +6,20 @@ module Mongoid #:nodoc:
       #
       # Example:
       #
-      # <tt>context.paginate</tt>
+      # <tt>context.paginate(:page => 6, :per_page => 25)</tt>
       #
       # Returns:
       #
       # A collection of documents paginated.
-      def paginate
+      # All previous <tt>limit</tt> and <tt>skip</tt> call will be ignored.
+      def paginate(pager_options={})
+        if pager_options[:per_page]
+          options[:limit] = pager_options[:per_page].to_i
+          if pager_options[:page]
+            options[:skip]  = (pager_options[:page].to_i - 1) * pager_options[:per_page].to_i
+          end
+        end
+
         @collection ||= execute(true)
         WillPaginate::Collection.create(page, per_page, count) do |pager|
           pager.replace(@collection.to_a)

data/lib/mongoid/criteria.rb

@@ -28,25 +28,9 @@ module Mongoid #:nodoc:
     attr_reader :collection, :ids, :klass, :options, :selector
     attr_accessor :documents
 
-    delegate \
-      :aggregate,
-      :avg,
-      :blank?,
-      :count,
-      :distinct,
-      :empty?,
-      :execute,
-      :first,
-      :group,
-      :id_criteria,
-      :last,
-      :max,
-      :min,
-      :one,
-      :page,
-      :paginate,
-      :per_page,
-      :sum, :to => :context
+    delegate :aggregate, :avg, :blank?, :count, :distinct, :empty?,
+             :execute, :first, :group, :id_criteria, :last, :max,
+             :min, :one, :page, :paginate, :per_page, :sum, :to => :context
 
     # Concatinate the criteria with another enumerable. If the other is a
     # +Criteria+ then it needs to get the collection from it.
@@ -190,14 +174,14 @@ module Mongoid #:nodoc:
       klass = args[0]
       params = args[1] || {}
       unless params.is_a?(Hash)
-        return new(klass).id_criteria(params)
+        return klass.criteria.id_criteria(params)
       end
       conditions = params.delete(:conditions) || {}
       if conditions.include?(:id)
         conditions[:_id] = conditions[:id]
         conditions.delete(:id)
       end
-      return new(klass).where(conditions).extras(params)
+      return klass.criteria.where(conditions).extras(params)
     end
 
     protected
@@ -233,7 +217,14 @@ module Mongoid #:nodoc:
     #
     # <tt>criteria.update_selector({ :field => "value" }, "$in")</tt>
     def update_selector(attributes, operator)
-      attributes.each { |key, value| @selector[key] = { operator => value } }; self
+      attributes.each do |key, value|
+        unless @selector[key]
+          @selector[key] = { operator => value }
+        else
+          new_value = @selector[key].values.first + value
+          @selector[key] = { operator => new_value }
+        end
+      end; self
     end
   end
 end

data/lib/mongoid/criterion/exclusion.rb

@@ -30,7 +30,7 @@ module Mongoid #:nodoc:
       #
       # Options:
       #
-      # exclusions: A +Hash+ where the key is the field name and the value is an
+      # attributes: A +Hash+ where the key is the field name and the value is an
       # +Array+ of values that none can match.
       #
       # Example:
@@ -40,8 +40,8 @@ module Mongoid #:nodoc:
       # <tt>criteria.not_in(:field1 => ["value1", "value2"], :field2 => ["value1"])</tt>
       #
       # Returns: <tt>self</tt>
-      def not_in(exclusions)
-        exclusions.each { |key, value| @selector[key] = { "$nin" => value } }; self
+      def not_in(attributes)
+        update_selector(attributes, "$nin")
       end
 
       # Adds a criterion to the +Criteria+ that specifies the fields that will

data/lib/mongoid/criterion/inclusion.rb

@@ -64,6 +64,23 @@ module Mongoid #:nodoc:
       end
       alias :any_in :in
 
+      # Adds a criterion to the +Criteria+ that specifies values to do
+      # geospacial searches by. The field must be indexed with the "2d" option.
+      #
+      # Options:
+      #
+      # attributes: A +Hash+ where the keys are the field names and the values are
+      # +Arrays+ of [latitude, longitude] pairs.
+      #
+      # Example:
+      #
+      # <tt>criteria.near(:field1 => [30, -44])</tt>
+      #
+      # Returns: <tt>self</tt>
+      def near(attributes = {})
+        update_selector(attributes, "$near")
+      end
+
       # Adds a criterion to the +Criteria+ that specifies values that must
       # be matched in order to return results. This is similar to a SQL "WHERE"
       # clause. This is the actual selector that will be provided to MongoDB,

data/lib/mongoid/criterion/optional.rb

@@ -62,7 +62,7 @@ module Mongoid #:nodoc:
       #
       # Options:
       #
-      # object_id: A +String+ representation of a <tt>Mongo::ObjectID</tt>
+      # object_id: A +String+ representation of a <tt>BSON::ObjectID</tt>
       #
       # Example:
       #

data/lib/mongoid/dirty.rb

@@ -0,0 +1,253 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Dirty #:nodoc:
+    extend ActiveSupport::Concern
+    module InstanceMethods #:nodoc:
+      # Gets the changes for a specific field.
+      #
+      # Example:
+      #
+      #   person = Person.new(:title => "Sir")
+      #   person.title = "Madam"
+      #   person.attribute_change("title") # [ "Sir", "Madam" ]
+      #
+      # Returns:
+      #
+      # An +Array+ containing the old and new values.
+      def attribute_change(name)
+        modifications[name]
+      end
+
+      # Determines if a specific field has chaged.
+      #
+      # Example:
+      #
+      #   person = Person.new(:title => "Sir")
+      #   person.title = "Madam"
+      #   person.attribute_changed?("title") # true
+      #
+      # Returns:
+      #
+      # +true+ if changed, +false+ if not.
+      def attribute_changed?(name)
+        modifications.include?(name)
+      end
+
+      # Gets the old value for a specific field.
+      #
+      # Example:
+      #
+      #   person = Person.new(:title => "Sir")
+      #   person.title = "Madam"
+      #   person.attribute_was("title") # "Sir"
+      #
+      # Returns:
+      #
+      # The old field value.
+      def attribute_was(name)
+        change = modifications[name]
+        change ? change[0] : nil
+      end
+
+      # Gets the names of all the fields that have changed in the document.
+      #
+      # Example:
+      #
+      #   person = Person.new(:title => "Sir")
+      #   person.title = "Madam"
+      #   person.changed # returns [ "title" ]
+      #
+      # Returns:
+      #
+      # An +Array+ of changed field names.
+      def changed
+        modifications.keys
+      end
+
+      # Alerts to whether the document has been modified or not.
+      #
+      # Example:
+      #
+      #   person = Person.new(:title => "Sir")
+      #   person.title = "Madam"
+      #   person.changed? # returns true
+      #
+      # Returns:
+      #
+      # +true+ if changed, +false+ if not.
+      def changed?
+        !modifications.empty?
+      end
+
+      # Gets all the modifications that have happened to the object as a +Hash+
+      # with the keys being the names of the fields, and the values being an
+      # +Array+ with the old value and new value.
+      #
+      # Example:
+      #
+      #   person = Person.new(:title => "Sir")
+      #   person.title = "Madam"
+      #   person.changes # returns { "title" => [ "Sir", "Madam" ] }
+      #
+      # Returns:
+      #
+      # A +Hash+ of changes.
+      def changes
+        modifications
+      end
+
+      # Call this method after save, so the changes can be properly switched.
+      #
+      # Example:
+      #
+      # <tt>person.move_changes</tt>
+      def move_changes
+        @previous_modifications = modifications.dup
+        @modifications = {}
+      end
+
+      # Gets all the new values for each of the changed fields, to be passed to
+      # a MongoDB $set modifier.
+      #
+      # Example:
+      #
+      #   person = Person.new(:title => "Sir")
+      #   person.title = "Madam"
+      #   person.setters # returns { "title" => "Madam" }
+      #
+      # Returns:
+      #
+      # A +Hash+ of new values.
+      def setters
+        modifications.inject({}) do |sets, (field, changes)|
+          key = embedded? ? "#{_position}.#{field}" : field
+          sets[key] = changes[1]; sets
+        end
+      end
+
+      # Gets all the modifications that have happened to the object before the
+      # object was saved.
+      #
+      # Example:
+      #
+      #   person = Person.new(:title => "Sir")
+      #   person.title = "Madam"
+      #   person.save!
+      #   person.previous_changes # returns { "title" => [ "Sir", "Madam" ] }
+      #
+      # Returns:
+      #
+      # A +Hash+ of changes before save.
+      def previous_changes
+        @previous_modifications
+      end
+
+      # Resets a changed field back to its old value.
+      #
+      # Example:
+      #
+      #   person = Person.new(:title => "Sir")
+      #   person.title = "Madam"
+      #   person.reset_attribute!("title")
+      #   person.title # "Sir"
+      #
+      # Returns:
+      #
+      # The old field value.
+      def reset_attribute!(name)
+        value = attribute_was(name)
+        if value
+          @attributes[name] = value
+          modifications.delete(name)
+        end
+      end
+
+      # Sets up the modifications hash. This occurs just after the document is
+      # instantiated.
+      #
+      # Example:
+      #
+      # <tt>document.setup_notifications</tt>
+      def setup_modifications
+        @accessed ||= {}
+        @modifications ||= {}
+        @previous_modifications ||= {}
+      end
+
+      # Reset all modifications for the document. This will wipe all the marked
+      # changes, but not reset the values.
+      #
+      # Example:
+      #
+      # <tt>document.reset_modifications</tt>
+      def reset_modifications
+        @accessed = {}
+        @modifications = {}
+      end
+
+      protected
+
+      # Audit the original value for a field that can be modified in place.
+      #
+      # Example:
+      #
+      # <tt>person.accessed("aliases", [ "007" ])</tt>
+      def accessed(name, value)
+        @accessed ||= {}
+        @accessed[name] = value.dup if (value.is_a?(Array) || value.is_a?(Hash)) && !@accessed.has_key?(name)
+        value
+      end
+
+      # Get all normal modifications plus in place potential changes.
+      #
+      # Example:
+      #
+      # <tt>person.modifications</tt>
+      #
+      # Returns:
+      #
+      # All changes to the document.
+      def modifications
+        @accessed.each_pair do |field, value|
+          current = @attributes[field]
+          @modifications[field] = [ value, current ] if current != value
+        end
+        @accessed.clear
+        @modifications
+      end
+
+      # Audit the change of a field's value.
+      #
+      # Example:
+      #
+      # <tt>person.modify("name", "Jack", "John")</tt>
+      def modify(name, old_value, new_value)
+        @attributes[name] = new_value
+        if @modifications && (old_value != new_value)
+          original = @modifications[name].first if @modifications[name]
+          @modifications[name] = [ (original || old_value), new_value ]
+        end
+      end
+    end
+
+    module ClassMethods #:nodoc:
+      # Add the dynamic dirty methods. These are custom methods defined on a
+      # field by field basis that wrap the dirty attribute methods.
+      #
+      # Example:
+      #
+      #   person = Person.new(:title => "Sir")
+      #   person.title = "Madam"
+      #   person.title_change # [ "Sir", "Madam" ]
+      #   person.title_changed? # true
+      #   person.title_was # "Sir"
+      #   person.reset_title!
+      def add_dirty_methods(name)
+        define_method("#{name}_change") { attribute_change(name) }
+        define_method("#{name}_changed?") { attribute_changed?(name) }
+        define_method("#{name}_was") { attribute_was(name) }
+        define_method("reset_#{name}!") { reset_attribute!(name) }
+      end
+    end
+  end
+end

data/lib/mongoid/document.rb

@@ -5,16 +5,13 @@ module Mongoid #:nodoc:
     included do
       include Mongoid::Components
 
-      cattr_accessor :_collection, :collection_name, :embedded, :primary_key, :hereditary
-
-      self.embedded = false
+      cattr_accessor :primary_key, :hereditary
       self.hereditary = false
-      self.collection_name = self.name.collectionize
 
       attr_accessor :association_name, :_parent
       attr_reader :new_record
 
-      delegate :collection, :db, :embedded, :primary_key, :to => "self.class"
+      delegate :db, :primary_key, :to => "self.class"
     end
 
     module ClassMethods
@@ -23,17 +20,6 @@ module Mongoid #:nodoc:
         collection.db
       end
 
-      # 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
-        raise Errors::InvalidCollection.new(self) if embedded
-        self._collection ||= Mongoid::Collection.new(self, self.collection_name)
-        add_indexes; self._collection
-      end
-
       # Perform default behavior but mark the hierarchy as being hereditary.
       def inherited(subclass)
         super(subclass)
@@ -51,6 +37,7 @@ module Mongoid #:nodoc:
         if attributes["_id"] || allocating
           document = allocate
           document.instance_variable_set(:@attributes, attributes)
+          document.setup_modifications
           return document
         else
           return new(attrs)
@@ -70,17 +57,7 @@ module Mongoid #:nodoc:
       #   end
       def key(*fields)
         self.primary_key = fields
-        before_save :identify
-      end
-
-      # Macro for setting the collection name to store in.
-      #
-      # Example:
-      #
-      # <tt>Person.store_in :populdation</tt>
-      def store_in(name)
-        self.collection_name = name.to_s
-        self._collection = Mongoid::Collection.new(self, name.to_s)
+        set_callback :save, :before, :identify
       end
 
       # Returns all types to query for when using this class as the base.
@@ -91,7 +68,6 @@ module Mongoid #:nodoc:
       # return the list of subclassses for an object
       def subclasses_of(*superclasses) #:nodoc:
         subclasses = []
-
         superclasses.each do |sup|
           ObjectSpace.each_object(class << sup; self; end) do |k|
             if k != sup && (k.name.blank? || eval("defined?(::#{k}) && ::#{k}.object_id == k.object_id"))
@@ -99,18 +75,16 @@ module Mongoid #:nodoc:
             end
           end
         end
-
         subclasses
       end
     end
 
     module InstanceMethods
-      # Performs equality checking on the attributes. For now we chack against
-      # all attributes excluding timestamps on the object.
+      # Performs equality checking on the document ids. For more robust
+      # equality checking please override this method.
       def ==(other)
         return false unless other.is_a?(Document)
-        attributes.except(:modified_at).except(:created_at) ==
-          other.attributes.except(:modified_at).except(:created_at)
+        id == other.id
       end
 
       # Delegates to ==
@@ -124,6 +98,15 @@ module Mongoid #:nodoc:
         id.hash
       end
 
+      # Is inheritance in play here?
+      #
+      # Returns:
+      #
+      # <tt>true</tt> if inheritance used, <tt>false</tt> if not.
+      def hereditary?
+        !!self.hereditary
+      end
+
       # Introduces a child object into the +Document+ object graph. This will
       # set up the relationships between the parent and child and update the
       # attributes of the parent +Document+.
@@ -157,24 +140,27 @@ module Mongoid #:nodoc:
       # an empty +Hash+.
       #
       # If a primary key is defined, the document's id will be set to that key,
-      # otherwise it will be set to a fresh +Mongo::ObjectID+ string.
+      # otherwise it will be set to a fresh +BSON::ObjectID+ string.
       #
       # Options:
       #
       # attrs: The attributes +Hash+ to set up the document with.
       def initialize(attrs = nil)
-        @attributes = {}
+        @attributes = default_attributes
         process(attrs)
-        @attributes = attributes_with_defaults(@attributes)
-        @new_record = true if id.nil?
+        @new_record = true
         document = yield self if block_given?
         identify
       end
 
       # Returns the class name plus its attributes.
       def inspect
-        attrs = fields.map { |name, field| "#{name}: #{@attributes[name].inspect}" } * ", "
-        "#<#{self.class.name} _id: #{id}, #{attrs}>"
+        attrs = fields.map { |name, field| "#{name}: #{@attributes[name].inspect}" }
+        if Mongoid.allow_dynamic_fields
+          dynamic_keys = @attributes.keys - fields.keys - associations.keys - ["_id", "_type"]
+          attrs += dynamic_keys.map { |name| "#{name}: #{@attributes[name].inspect}" }
+        end
+        "#<#{self.class.name} _id: #{id}, #{attrs * ', '}>"
       end
 
       # Notify observers of an update.
@@ -211,8 +197,12 @@ module Mongoid #:nodoc:
 
       # Reloads the +Document+ attributes from the database.
       def reload
-        @attributes = collection.find_one(:_id => id)
-        self
+        reloaded = collection.find_one(:_id => id)
+        if Mongoid.raise_not_found_error
+          raise Errors::DocumentNotFound.new(self.class, id) if reloaded.nil?
+        end
+        @attributes = {}.merge(reloaded || {})
+        self.associations.keys.each { |association_name| unmemoize(association_name) }; self
       end
 
       # Remove a child document from this parent +Document+. Will reset the
@@ -236,39 +226,9 @@ module Mongoid #:nodoc:
         [ self ]
       end
 
-      # Return this document as a JSON string. Nothing special is required here
-      # since Mongoid bubbles up all the child associations to the parent
-      # attribute +Hash+ using observers throughout the +Document+ lifecycle.
-      #
-      # Example:
-      #
-      # <tt>person.to_json</tt>
-      def to_json(options = nil)
-        attributes.to_json(options)
-      end
-
-      # Return an object to be encoded into a JSON string.
-      # Used by Rails 3's object->JSON chain to create JSON
-      # in a backend-agnostic way
-      #
-      # Example:
-      #
-      # <tt>person.as_json</tt>
-      def as_json(options = nil)
-        attributes
-      end
-
-      # Return this document as an object to be encoded as JSON,
-      # with any particular items modified on a per-encoder basis.
-      # Nothing special is required here since Mongoid bubbles up
-      # all the child associations to the parent attribute +Hash+
-      # using observers throughout the +Document+ lifecycle.
-      #
-      # Example:
-      #
-      # <tt>person.encode_json(encoder)</tt>
-      def encode_json(encoder)
-        attributes
+      # Returns nil if document is new, or an array of primary keys if not.
+      def to_key
+        new_record? ? nil : [ id ]
       end
 
       # Returns the id of the Document, used in Rails compatibility.
@@ -287,20 +247,15 @@ module Mongoid #:nodoc:
       #
       # This will also cause the observing +Document+ to notify it's parent if
       # there is any.
-      def update(child, clear = false)
+      def observe(child, clear = false)
         name = child.association_name
         attrs = child.instance_variable_get(:@attributes)
-        clear ? @attributes.delete(name) : @attributes.insert(name, attrs)
-        notify
-      end
-
-      protected
-      # apply default values to attributes - calling procs as required
-      def attributes_with_defaults(attributes = {})
-        default_values = defaults.merge(attributes)
-        default_values.each_pair do |key, val|
-          default_values[key] = val.call if val.respond_to?(:call)
+        if clear
+          @attributes.delete(name)
+        else
+          @attributes.insert(name, attrs) unless @attributes[name] && @attributes[name].include?(attrs)
         end
+        notify
       end
     end
   end