mongoid 1.2.14 → 1.9.0

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/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

@@ -1,23 +1,17 @@
 # encoding: utf-8
 module Mongoid #:nodoc:
   module Document
-    def self.included(base)
-      base.class_eval do
-        include Components
-        include InstanceMethods
-        extend ClassMethods
+    extend ActiveSupport::Concern
+    include Mongoid::Components
+    included do
+      include Mongoid::Components
 
-        cattr_accessor :_collection, :collection_name, :embedded, :primary_key, :hereditary
+      cattr_accessor :primary_key, :hereditary
+      self.hereditary = false
 
-        self.embedded = false
-        self.hereditary = false
-        self.collection_name = self.name.collectionize
+      attr_accessor :association_name, :_parent
 
-        attr_accessor :association_name, :_parent
-        attr_reader :new_record
-
-        delegate :collection, :db, :embedded, :primary_key, :to => "self.class"
-      end
+      delegate :db, :primary_key, :to => "self.class"
     end
 
     module ClassMethods
@@ -26,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)
@@ -63,6 +46,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)
@@ -85,30 +69,31 @@ module Mongoid #:nodoc:
         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)
-      end
-
       # Returns all types to query for when using this class as the base.
       def _types
         @_type ||= (self.subclasses + [ self.name ])
       end
 
+      # 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"))
+              subclasses << k
+            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 ==
@@ -122,6 +107,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+.
@@ -155,33 +149,35 @@ 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
 
-      # Set the changed state of the +Document+ then notify observers that it has changed.
+      # Notify observers of an update.
       #
       # Example:
       #
       # <tt>person.notify</tt>
       def notify
-        changed(true)
         notify_observers(self)
       end
 
@@ -210,8 +206,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
@@ -246,6 +246,30 @@ module Mongoid #:nodoc:
         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
+      end
+
       # Returns the id of the Document, used in Rails compatibility.
       def to_param
         id
@@ -262,20 +286,25 @@ 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)
+        if clear
+          @attributes.delete(name)
+        else
+          @attributes.insert(name, attrs) unless @attributes[name] && @attributes[name].include?(attrs)
+        end
         notify
       end
 
       protected
       # apply default values to attributes - calling procs as required
       def attributes_with_defaults(attributes = {})
-        default_values = defaults.merge(attributes)
+        default_values = defaults
         default_values.each_pair do |key, val|
           default_values[key] = val.call if val.respond_to?(:call)
         end
+        default_values.merge(attributes)
       end
     end
   end