mongoid 2.0.2 → 2.1.0

data/lib/mongoid/criterion/selector.rb

@@ -100,7 +100,7 @@ module Mongoid #:nodoc:
       #
       # @since 1.0.0
       def typecast_value_for(field, value)
-        return field.set(value) if field.type === value
+        return field.serialize(value) if field.type === value
         case value
         when Hash
           value = value.dup
@@ -112,7 +112,11 @@ module Mongoid #:nodoc:
         when Regexp
           value
         else
-          field.type == Array ? value.class.set(value) : field.set(value)
+          if field.type == Array
+            Serialization.mongoize(value, value.class)
+          else
+            field.serialize(value)
+          end
         end
       end
 
@@ -131,9 +135,9 @@ module Mongoid #:nodoc:
       def typecast_hash_value(field, key, value)
         case key
         when "$exists"
-          Boolean.set(value)
+          Serialization.mongoize(value, Boolean)
         when "$size"
-          Integer.set(value)
+          Serialization.mongoize(value, Integer)
         else
           typecast_value_for(field, value)
         end

data/lib/mongoid/cursor.rb

@@ -1,8 +1,11 @@
 # encoding: utf-8
 module Mongoid #:nodoc
+
+  # Mongoid wrapper of the Ruby Driver cursor.
   class Cursor
     include Mongoid::Collections::Retry
     include Enumerable
+
     # Operations on the Mongo::Cursor object that will not get overriden by the
     # Mongoid::Cursor are defined here.
     OPERATIONS = [
@@ -24,42 +27,37 @@ module Mongoid #:nodoc
       :timeout
     ]
 
-    attr_reader :collection
+    attr_reader :collection, :cursor, :klass
 
     # The operations above will all delegate to the proxied Mongo::Cursor.
-    #
-    # Example:
-    #
-    # <tt>cursor.close</tt>
     OPERATIONS.each do |name|
-      define_method(name) do |*args|
-        retry_on_connection_failure do
-          @cursor.send(name, *args)
+      class_eval <<-EOS, __FILE__, __LINE__
+        def #{name}(*args)
+          retry_on_connection_failure do
+            cursor.#{name}(*args)
+          end
         end
-      end
+      EOS
     end
 
     # Iterate over each document in the cursor and yield to it.
     #
-    # Example:
-    #
-    # <tt>cursor.each { |doc| p doc.title }</tt>
+    # @example Iterate over the cursor.
+    #   cursor.each { |doc| p doc.title }
     def each
-      @cursor.each do |document|
-        yield Mongoid::Factory.from_db(@klass, document)
+      cursor.each do |document|
+        yield Mongoid::Factory.from_db(klass, document)
       end
     end
 
     # Create the new +Mongoid::Cursor+.
     #
-    # Options:
-    #
-    # collection: The Mongoid::Collection instance.
-    # cursor: The Mongo::Cursor to be proxied.
-    #
-    # Example:
+    # @example Instantiate the cursor.
+    #   Mongoid::Cursor.new(Person, cursor)
     #
-    # <tt>Mongoid::Cursor.new(Person, cursor)</tt>
+    # @param [ Class ] klass The class associated with the cursor.
+    # @param [ Collection ] collection The Mongoid::Collection instance.
+    # @param [ Mongo::Cursor ] cursor The Mongo::Cursor to be proxied.
     def initialize(klass, collection, cursor)
       @klass, @collection, @cursor = klass, collection, cursor
     end
@@ -67,20 +65,22 @@ module Mongoid #:nodoc
     # Return the next document in the cursor. Will instantiate a new Mongoid
     # document with the attributes.
     #
-    # Example:
+    # @example Get the next document.
+    #   cursor.next_document
     #
-    # <tt>cursor.next_document</tt>
+    # @return [ Document ] The next document in the cursor.
     def next_document
-      Mongoid::Factory.from_db(@klass, @cursor.next_document)
+      Mongoid::Factory.from_db(klass, cursor.next_document)
     end
 
     # Returns an array of all the documents in the cursor.
     #
-    # Example:
+    # @example Get the cursor as an array.
+    #   cursor.to_a
     #
-    # <tt>cursor.to_a</tt>
+    # @return [ Array<Document> ] An array of documents.
     def to_a
-      @cursor.to_a.collect { |attrs| Mongoid::Factory.from_db(@klass, attrs) }
+      cursor.to_a.collect { |attrs| Mongoid::Factory.from_db(klass, attrs) }
     end
   end
 end

data/lib/mongoid/dirty.rb

@@ -2,252 +2,92 @@
 module Mongoid #:nodoc:
   module Dirty #:nodoc:
     extend ActiveSupport::Concern
+    include ActiveModel::Dirty
 
-    # Gets the changes for a specific field.
+    # Get the changed values for the document. This is a hash with the name of
+    # the field as the keys, and the values being an array of previous and
+    # current pairs.
     #
-    # Example:
+    # @example Get the changes.
+    #   document.changes
     #
-    #   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] : attributes[name]
-    end
-
-    # Gets the names of all the fields that have changed in the document.
+    # @note This is overriding the AM::Dirty implementation to handle
+    #   enumerable fields being in the hash when not actually changed.
     #
-    # Example:
+    # @return [ Hash ] The changed values.
     #
-    #   person = Person.new(:title => "Sir")
-    #   person.title = "Madam"
-    #   person.changed # returns [ "title" ]
-    #
-    # Returns:
-    #
-    # An +Array+ of changed field names.
-    def changed
-      modifications.keys
+    # @since 2.1.0
+    def changes
+      {}.tap do |hash|
+        changed.each do |name|
+          change = attribute_change(name)
+          hash[name] = change if change[0] != change[1]
+        end
+      end
     end
 
-    # Alerts to whether the document has been modified or not.
+    # Call this method after save, so the changes can be properly switched.
     #
-    # Example:
+    # This will unset the memoized children array, set new record to
+    # false, set the document as validated, and move the dirty changes.
     #
-    #   person = Person.new(:title => "Sir")
-    #   person.title = "Madam"
-    #   person.changed? # returns true
+    # @example Move the changes to previous.
+    #   person.move_changes
     #
-    # Returns:
-    #
-    # +true+ if changed, +false+ if not.
-    def changed?
-      !modifications.empty?
+    # @since 2.1.0
+    def move_changes
+      @_children = nil
+      @previously_changed = changes
+      @validated = false
+      changed_attributes.clear
     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.
+    # Remove a change from the dirty attributes hash. Used by the single field
+    # atomic updators.
     #
-    # Example:
+    # @example Remove a flagged change.
+    #   model.remove_change(:field)
     #
-    #   person = Person.new(:title => "Sir")
-    #   person.title = "Madam"
-    #   person.changes # returns { "title" => [ "Sir", "Madam" ] }
+    # @param [ Symbol, String ] name The name of the field.
     #
-    # 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
-      @validated = false
-      @previous_modifications = modifications.dup
-      @modifications = {}
+    # @since 2.1.0
+    def remove_change(name)
+      changed_attributes.delete(name.to_s)
     end
 
     # Gets all the new values for each of the changed fields, to be passed to
     # a MongoDB $set modifier.
     #
-    # Example:
-    #
+    # @example Get the setters for the atomic updates.
     #   person = Person.new(:title => "Sir")
     #   person.title = "Madam"
     #   person.setters # returns { "title" => "Madam" }
     #
-    # Returns:
-    #
-    # A +Hash+ of new values.
+    # @return [ Hash ] A +Hash+ of atomic setters.
     def setters
-      modifications.inject({}) do |sets, (field, changes)|
-        key = embedded? ? "#{_position}.#{field}" : field
-        sets[key] = changes[1]; sets
+      {}.tap do |modifications|
+        changes.each_pair do |field, changes|
+          key = embedded? ? "#{atomic_position}.#{field}" : field
+          modifications[key] = changes[1]
+        end
       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)
-      value ? attributes[name] = value : attributes.delete(name)
-      modifications.delete(name)
-    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)
-      return value unless value.is_a?(Enumerable)
-      @accessed ||= {}
-      @accessed[name] = value.dup unless @accessed.has_key?(name)
-      value
-    end
+    private
 
-    # Get all normal modifications plus in place potential changes.
+    # Get the current value for the specified attribute, if the attribute has changed.
     #
-    # Example:
+    # @note This is overriding the AM::Dirty implementation to read from the mongoid
+    #   attributes hash, which may contain a serialized version of the attributes data. It is
+    #   necessary to read the serialized version as the changed value, to allow updates to
+    #   the MongoDB document to persist correctly. For example, if a DateTime field is updated
+    #   it must be persisted as a UTC Time.
     #
-    # <tt>person.modifications</tt>
+    # @return [ Object ] The current value of the field, or nil if no change made.
     #
-    # Returns:
-    #
-    # All changes to the document.
-    def modifications
-      reset_modifications unless @modifications && @accessed
-      @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
-
-    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) } unless instance_methods.include?("#{name}_change") || instance_methods.include?(:"#{name}_change") 
-        define_method("#{name}_changed?") { attribute_changed?(name) } unless instance_methods.include?("#{name}_changed?") || instance_methods.include?(:"#{name}_changed?")
-        define_method("#{name}_was") { attribute_was(name) } unless instance_methods.include?("#{name}_was") || instance_methods.include?(:"#{name}_was")
-        define_method("reset_#{name}!") { reset_attribute!(name) } unless instance_methods.include?("reset_#{name}!") || instance_methods.include?(:"reset_#{name}!")
-      end
+    # @since 2.1.0
+    def attribute_change(attr)
+      [changed_attributes[attr], attributes[attr]] if attribute_changed?(attr)
     end
   end
 end

data/lib/mongoid/document.rb

@@ -6,7 +6,6 @@ module Mongoid #:nodoc:
   module Document
     extend ActiveSupport::Concern
     include Mongoid::Components
-    include Mongoid::MultiDatabase
 
     included do
       attr_reader :new_record
@@ -125,13 +124,15 @@ module Mongoid #:nodoc:
     #
     # @return [ Document ] A new document.
     def initialize(attrs = nil)
-      @new_record = true
-      @attributes = apply_default_attributes
-      process(attrs) do |document|
-        yield self if block_given?
-        identify
+      building do
+        @new_record = true
+        @attributes = apply_default_attributes
+        process(attrs) do
+          yield self if block_given?
+          identify
+        end
+        run_callbacks(:initialize) { self }
       end
-      run_callbacks(:initialize) { self }
     end
 
     # Reloads the +Document+ attributes from the database. If the document has
@@ -150,8 +151,8 @@ module Mongoid #:nodoc:
         raise Errors::DocumentNotFound.new(self.class, id) if reloaded.nil?
       end
       @attributes = {}.merge(reloaded || {})
+      changed_attributes.clear
       apply_default_attributes
-      reset_modifications
       tap do
         relations.keys.each do |name|
           if instance_variable_defined?("@#{name}")
@@ -161,24 +162,6 @@ module Mongoid #:nodoc:
       end
     end
 
-    # Remove a child document from this parent. If an embeds one then set to
-    # nil, otherwise remove from the embeds many.
-    #
-    # This is called from the +RemoveEmbedded+ persistence command.
-    #
-    # @example Remove the child.
-    #   document.remove_child(child)
-    #
-    # @param [ Document ] child The child (embedded) document to remove.
-    def remove_child(child)
-      name = child.metadata.name
-      if child.embedded_one?
-        remove_instance_variable("@#{name}") if instance_variable_defined?("@#{name}")
-      else
-        send(name).delete(child)
-      end
-    end
-
     # Return an array with this +Document+ only in it.
     #
     # @example Return the document in an array.
@@ -198,11 +181,12 @@ module Mongoid #:nodoc:
     #
     # @return [ Hash ] A hash of all attributes in the hierarchy.
     def as_document
-      attribs = attributes
-      attribs.tap do |attrs|
-        relations.select { |name, meta| meta.embedded? }.each do |name, meta|
-          relation = send(name, false, :continue => false)
-          attrs[name] = relation.as_document unless relation.blank?
+      attributes.tap do |attrs|
+        relations.each_pair do |name, meta|
+          if meta.embedded?
+            relation = send(name, false, :continue => false)
+            attrs[name] = relation.as_document unless relation.blank?
+          end
         end
       end
     end
@@ -222,12 +206,26 @@ module Mongoid #:nodoc:
       unless klass.include?(Mongoid::Document)
         raise ArgumentError, 'A class which includes Mongoid::Document is expected'
       end
-      became = klass.new
-      became.instance_variable_set('@attributes', @attributes)
-      became.instance_variable_set('@errors', @errors)
-      became.instance_variable_set('@new_record', new_record?)
-      became.instance_variable_set('@destroyed', destroyed?)
-      became
+      klass.new.tap do |became|
+        became.instance_variable_set('@attributes', @attributes)
+        became.instance_variable_set('@errors', @errors)
+        became.instance_variable_set('@new_record', new_record?)
+        became.instance_variable_set('@destroyed', destroyed?)
+      end
+    end
+
+    private
+
+    # Implement this for calls to flatten on array.
+    #
+    # @example Get the document as an array.
+    #   document.to_ary
+    #
+    # @return [ nil ] Always nil.
+    #
+    # @since 2.1.0
+    def to_ary
+      nil
     end
 
     module ClassMethods #:nodoc:
@@ -260,7 +258,7 @@ module Mongoid #:nodoc:
         allocate.tap do |doc|
           doc.instance_variable_set(:@attributes, attributes)
           doc.send(:apply_default_attributes)
-          doc.setup_modifications
+          IdentityMap.set(doc)
           doc.run_callbacks(:initialize) { doc }
         end
       end
@@ -272,7 +270,7 @@ module Mongoid #:nodoc:
       #
       # @return [ Array<Class> ] All subclasses of the current document.
       def _types
-        @_type ||= [descendants + [self]].flatten.uniq.map(&:to_s)
+        @_type ||= [descendants + [self]].flatten.uniq.map { |t| t.to_s }
       end
 
       # Set the i18n scope to overwrite ActiveModel.