mongoid 2.0.0.beta.20 → 2.0.0.rc.1

data/lib/mongoid/criterion/selector.rb

@@ -21,6 +21,15 @@ module Mongoid #:nodoc:
       end
       alias update merge!
 
+      if RUBY_VERSION < '1.9'
+        def inspect
+          ret = self.keys.inject([]) do |ret, key|
+            ret << "#{key.inspect}=>#{self[key].inspect}"
+          end
+          "{#{ret.sort.join(', ')}}"
+        end
+      end
+
       private
 
       def try_to_typecast(key, value)

data/lib/mongoid/default_scope.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # This module handles functionality for creating default scopes.
+  module DefaultScope
+
+    # Creates a default_scope for the +Document+, similar to ActiveRecord's
+    # default_scope. +DefaultScopes+ are proxied +Criteria+ objects that are
+    # applied by default to all queries for the class.
+    #
+    # @example Create a default scope.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     field :active, :type => Boolean
+    #     field :count, :type => Integer
+    #
+    #     default_scope :where => { :active => true }
+    #   end
+    #
+    # @param [ Hash ] conditions The conditions to create with.
+    #
+    # @since 2.0.0.rc.1
+    def default_scope(conditions = {}, &block)
+      self.scope_stack << criteria.fuse(Scope.new(conditions, &block).conditions.scoped)
+    end
+  end
+end

data/lib/mongoid/deprecation.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 module Mongoid #:nodoc:
-  class Deprecation #:nodoc
-    include Singleton
+  module Deprecation #:nodoc
+    extend self
 
     # Alert of a deprecation. This will delegate to the logger and call warn on
     # it.
@@ -10,12 +10,12 @@ module Mongoid #:nodoc:
     #
     # <tt>deprecation.alert("Method no longer used")</tt>
     def alert(message)
-      @logger.warn("Deprecation: #{message}")
+      logger.warn("Deprecation: #{message}")
     end
 
     protected
-    def initialize
-      @logger = Mongoid::Logger.new
+    def logger
+      @logger ||= Mongoid::Logger.new
     end
   end
 end

data/lib/mongoid/dirty.rb

@@ -46,7 +46,7 @@ module Mongoid #:nodoc:
     # The old field value.
     def attribute_was(name)
       change = modifications[name]
-      change ? change[0] : nil
+      change ? change[0] : @attributes[name]
     end
 
     # Gets the names of all the fields that have changed in the document.
@@ -156,10 +156,8 @@ module Mongoid #:nodoc:
     # The old field value.
     def reset_attribute!(name)
       value = attribute_was(name)
-      if value
-        @attributes[name] = value
-        modifications.delete(name)
-      end
+      value ? @attributes[name] = value : @attributes.delete(name)
+      modifications.delete(name)
     end
 
     # Sets up the modifications hash. This occurs just after the document is
@@ -208,6 +206,7 @@ module Mongoid #:nodoc:
     #
     # 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

data/lib/mongoid/document.rb

@@ -1,90 +1,99 @@
 # encoding: utf-8
 module Mongoid #:nodoc:
+
+  # This is the base module for all domain objects that need to be persisted to
+  # the database as documents.
   module Document
     extend ActiveSupport::Concern
-    included do
-      include Mongoid::Components
+    include Mongoid::Components
+    include Mongoid::MultiDatabase
 
-      attr_accessor :association_name
+    included do
       attr_reader :new_record
     end
 
-    module ClassMethods #:nodoc:
-
-      # Instantiate a new object, only when loaded from the database or when
-      # the attributes have already been typecast.
-      #
-      # Example:
-      #
-      # <tt>Person.instantiate(:title => "Sir", :age => 30)</tt>
-      def instantiate(attrs = nil, allocating = false)
-        attributes = attrs || {}
-        if attributes["_id"] || allocating
-          document = allocate
-          document.instance_variable_set(:@attributes, attributes)
-          document.setup_modifications
-          document
-        else
-          new(attrs)
-        end
-      end
-
-      # Returns all types to query for when using this class as the base.
-      # *subclasses* is from activesupport. Note that a bug in *subclasses*
-      # causes the first call to only return direct children, hence
-      # the double call and unique.
-      def _types
-        @_type ||= [descendants + [self]].flatten.uniq.map(&:to_s)
-      end
+    # Default comparison is via the string version of the id.
+    #
+    # @example Compare two documents.
+    #   person <=> other_person
+    #
+    # @param [ Document ] other The document to compare with.
+    #
+    # @return [ Integer ] -1, 0, 1.
+    def <=>(other)
+      id.to_s <=> other.id.to_s
     end
 
     # Performs equality checking on the document ids. For more robust
     # equality checking please override this method.
+    #
+    # @example Compare for equality.
+    #   document == other
+    #
+    # @param [ Document, Object ] other The other object to compare with.
+    #
+    # @return [ true, false ] True if the ids are equal, false if not.
     def ==(other)
       return false unless other.is_a?(Document)
-      id == other.id
+      id == other.id || equal?(other)
     end
 
-    # Delegates to ==
-    def eql?(comparison_object)
-      self == (comparison_object)
+    # Performs class equality checking.
+    #
+    # @example Compare the classes.
+    #   document === other
+    #
+    # @param [ Document, Object ] other The other object to compare with.
+    #
+    # @return [ true, false ] True if the classes are equal, false if not.
+    def ===(other)
+      self.class == other.class
+    end
+
+    # Delegates to ==. Used when needing checks in hashes.
+    #
+    # @example Perform equality checking.
+    #   document.eql?(other)
+    #
+    # @param [ Document, Object ] other The object to check against.
+    #
+    # @return [ true, false ] True if equal, false if not.
+    def eql?(other)
+      self == (other)
     end
 
     # Delegates to id in order to allow two records of the same type and id to
     # work with something like:
-    #   [ Person.find(1),
-    #     Person.find(2),
-    #     Person.find(3) ] &
-    #   [ Person.find(1),
-    #     Person.find(4) ] # => [ Person.find(1) ]
+    #
+    #   [ Person.find(1), Person.find(2), Person.find(3) ] &
+    #   [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
+    #
+    # @example Get the hash.
+    #   document.hash
+    #
+    # @return [ Integer ] The hash of the document's id.
     def hash
       id.hash
     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+.
+    # Return the attributes hash with indifferent access. Used mostly for
+    # convenience - use +Document#raw_attributes+ where you dont care if the
+    # keys are all strings.
     #
-    # Options:
+    # @example Get the attributes.
+    #   person.attributes
     #
-    # parent: The +Document+ to assimilate with.
-    # options: The association +Options+ for the child.
-    def assimilate(parent, options)
-      parentize(parent, options.name); notify; self
-    end
-
-    # Return the attributes hash with indifferent access.
+    # @return [ HashWithIndifferentAccess ] The attributes.
     def attributes
       @attributes.with_indifferent_access
     end
 
-    # Clone the current +Document+. This will return all attributes with the
-    # exception of the document's id and versions.
-    def clone
-      self.class.instantiate(@attributes.except("_id").except("versions").dup, true)
-    end
-
     # Generate an id for this +Document+.
+    #
+    # @example Create the id.
+    #   person.identify
+    #
+    # @return [ BSON::ObjectId, String ] A newly created id.
     def identify
       Identity.new(self).create
     end
@@ -96,96 +105,134 @@ module Mongoid #:nodoc:
     # If a primary key is defined, the document's id will be set to that key,
     # otherwise it will be set to a fresh +BSON::ObjectId+ string.
     #
-    # Options:
+    # @example Create a new document.
+    #   Person.new(:title => "Sir")
+    #
+    # @param [ Hash ] attrs The attributes to set up the document with.
     #
-    # attrs: The attributes +Hash+ to set up the document with.
+    # @return [ Document ] A new document.
     def initialize(attrs = nil)
       @new_record = true
       @attributes = default_attributes
-      process(attrs)
-      document = yield self if block_given?
-      identify
-      run_callbacks(:initialize) do
-        document
+      process(attrs) do |document|
+        yield self if block_given?
+        identify
+        run_callbacks(:initialize) { document }
       end
     end
 
-    # Returns the class name plus its attributes.
-    def inspect
-      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 parent of an update.
+    # Return the attributes hash.
     #
-    # Example:
+    # @example Get the untouched attributes.
+    #   person.raw_attributes
     #
-    # <tt>person.notify</tt>
-    def notify
-      _parent.update_child(self) if _parent
-    end
-
-    # Return the attributes hash.
+    # @return [ Hash ] This document's attributes.
     def raw_attributes
       @attributes
     end
 
-    # Reloads the +Document+ attributes from the database.
+    # Reloads the +Document+ attributes from the database. If the document has
+    # not been saved then an error will get raised if the configuration option
+    # was set.
+    #
+    # @example Reload the document.
+    #   person.reload
+    #
+    # @raise [ Errors::DocumentNotFound ] If the document was deleted.
+    #
+    # @return [ Document ] The document, reloaded.
     def reload
       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
+      tap do
+        relations.keys.each do |name|
+          if relation_exists?(name)
+            remove_instance_variable("@#{name}")
+          end
+        end
+      end
     end
 
-    # Remove a child document from this parent +Document+. Will reset the
-    # memoized association and notify the parent of the change.
-    def remove(child)
-      name = child.association_name
-      if @building_nested
-        @attributes.remove(name, child.raw_attributes)
+    # 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
-        reset(name) do
-          @attributes.remove(name, child.raw_attributes)
-          @attributes[name]
-        end
-        notify
+        send(name).delete(child)
       end
     end
 
-    # def remove_without_reset
-    #   name = child.association_name
-    #   @attributes.remove(name, child.raw_attributes)
-    #   notify
-    # end
-
     # Return an array with this +Document+ only in it.
+    #
+    # @example Return the document in an array.
+    #   document.to_a
+    #
+    # @return [ Array<Document> ] An array with the document as its only item.
     def to_a
       [ self ]
     end
 
-    # Recieve a notify call from a child +Document+. This will either update
-    # existing attributes on the +Document+ or clear them out for the child if
-    # the clear boolean is provided.
+    # Return a hash of the entire document hierarchy from this document and
+    # below. Used when the attributes are needed for everything and not just
+    # the current document.
     #
-    # Options:
+    # @example Get the full hierarchy.
+    #   person.to_hash
     #
-    # child: The child +Document+ that sent the notification.
-    # clear: Will clear out the child's attributes if set to true.
-    def update_child(child, clear = false)
-      name = child.association_name
-      attrs = child.instance_variable_get(:@attributes)
-      if clear
-        @attributes.delete(name)
-      else
-        # check good for array only
-        @attributes.insert(name, attrs) unless @attributes[name] && @attributes[name].include?(attrs)
+    # @return [ Hash ] A hash of all attributes in the hierarchy.
+    def to_hash
+      attributes = @attributes
+      attributes.tap do |attrs|
+        relations.select { |name, meta| meta.embedded? }.each do |name, meta|
+          relation = send(name, false, :continue => false)
+          attrs[name] = relation.to_hash unless relation.blank?
+        end
+      end
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Instantiate a new object, only when loaded from the database or when
+      # the attributes have already been typecast.
+      #
+      # @example Create the document.
+      #   Person.instantiate(:title => "Sir", :age => 30)
+      #
+      # @param [ Hash ] attrs The hash of attributes to instantiate with.
+      #
+      # @return [ Document ] A new document.
+      def instantiate(attrs = nil)
+        attributes = attrs || {}
+        if attributes["_id"]
+          allocate.tap do |doc|
+            doc.instance_variable_set(:@attributes, attributes)
+            doc.setup_modifications
+          end
+        else
+          new(attrs)
+        end
+      end
+
+      # Returns all types to query for when using this class as the base.
+      #
+      # @example Get the types.
+      #   document._types
+      #
+      # @return [ Array<Class> ] All subclasses of the current document.
+      def _types
+        @_type ||= [descendants + [self]].flatten.uniq.map(&:to_s)
       end
     end
   end

data/lib/mongoid/extensions.rb

@@ -1,7 +1,5 @@
 # encoding: utf-8
 require "mongoid/extensions/time_conversions"
-require "mongoid/extensions/array/accessors"
-require "mongoid/extensions/array/assimilation"
 require "mongoid/extensions/array/conversions"
 require "mongoid/extensions/array/parentization"
 require "mongoid/extensions/set/conversions"
@@ -12,14 +10,14 @@ require "mongoid/extensions/date/conversions"
 require "mongoid/extensions/datetime/conversions"
 require "mongoid/extensions/false_class/equality"
 require "mongoid/extensions/float/conversions"
-require "mongoid/extensions/hash/accessors"
-require "mongoid/extensions/hash/assimilation"
 require "mongoid/extensions/hash/conversions"
 require "mongoid/extensions/hash/criteria_helpers"
 require "mongoid/extensions/hash/scoping"
 require "mongoid/extensions/integer/conversions"
-require "mongoid/extensions/nil/assimilation"
+require "mongoid/extensions/nil/collectionization"
 require "mongoid/extensions/object/conversions"
+require "mongoid/extensions/object/reflections"
+require "mongoid/extensions/object/yoda"
 require "mongoid/extensions/proc/scoping"
 require "mongoid/extensions/string/conversions"
 require "mongoid/extensions/string/inflections"
@@ -29,8 +27,6 @@ require "mongoid/extensions/true_class/equality"
 require "mongoid/extensions/object_id/conversions"
 
 class Array #:nodoc
-  include Mongoid::Extensions::Array::Accessors
-  include Mongoid::Extensions::Array::Assimilation
   include Mongoid::Extensions::Array::Conversions
   include Mongoid::Extensions::Array::Parentization
 end
@@ -70,8 +66,6 @@ class Float #:nodoc
 end
 
 class Hash #:nodoc
-  include Mongoid::Extensions::Hash::Accessors
-  include Mongoid::Extensions::Hash::Assimilation
   include Mongoid::Extensions::Hash::CriteriaHelpers
   include Mongoid::Extensions::Hash::Scoping
   include Mongoid::Extensions::Hash::Conversions
@@ -82,11 +76,13 @@ class Integer #:nodoc
 end
 
 class NilClass #:nodoc
-  include Mongoid::Extensions::Nil::Assimilation
+  include Mongoid::Extensions::Nil::Collectionization
 end
 
 class Object #:nodoc:
   include Mongoid::Extensions::Object::Conversions
+  include Mongoid::Extensions::Object::Reflections
+  include Mongoid::Extensions::Object::Yoda
 end
 
 class Proc #:nodoc:
@@ -95,7 +91,7 @@ end
 
 class String #:nodoc
   include Mongoid::Extensions::String::Inflections
-  extend Mongoid::Extensions::String::Conversions
+  include Mongoid::Extensions::String::Conversions
 end
 
 class Symbol #:nodoc