mongoid 2.0.0.beta.5 → 2.0.0.beta.7

data/lib/mongoid/document.rb

@@ -5,22 +5,20 @@ module Mongoid #:nodoc:
     included do
       include Mongoid::Components
 
-      cattr_accessor :primary_key, :hereditary
-      self.hereditary = false
+      cattr_accessor :primary_key
 
-      attr_accessor :association_name, :_parent
+      attr_accessor :association_name
       attr_reader :new_record
 
-      delegate :db, :primary_key, :to => "self.class"
+      delegate :primary_key, :to => "self.class"
     end
 
-    module ClassMethods
-      # Return the database associated with this class.
-      def db
-        collection.db
-      end
+    module ClassMethods #:nodoc:
 
       # Perform default behavior but mark the hierarchy as being hereditary.
+      #
+      # This method must remain in the +Document+ module, even though its
+      # behavior affects items in the Hierarchy module.
       def inherited(subclass)
         super(subclass)
         self.hereditary = true
@@ -61,202 +59,145 @@ module Mongoid #:nodoc:
       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 ||= (subclasses_of(self).map { |o| o.to_s } + [ 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
+        @_type ||= [subclasses + subclasses + [self.name]].flatten.uniq
       end
     end
 
-    module InstanceMethods
-      # 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)
-        id == other.id
-      end
-
-      # Delegates to ==
-      def eql?(comparison_object)
-        self == (comparison_object)
-      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) ]
-      def hash
-        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+.
-      #
-      # Options:
-      #
-      # 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.
-      def attributes
-        @attributes.with_indifferent_access
-      end
+    # 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)
+      id == other.id
+    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
+    # Delegates to ==
+    def eql?(comparison_object)
+      self == (comparison_object)
+    end
 
-      # Generate an id for this +Document+.
-      def identify
-        Identity.create(self)
-      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) ]
+    def hash
+      id.hash
+    end
 
-      # Instantiate a new +Document+, setting the Document's attributes if
-      # given. If no attributes are provided, they will be initialized with
-      # 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 +BSON::ObjectID+ string.
-      #
-      # Options:
-      #
-      # attrs: The attributes +Hash+ to set up the document with.
-      def initialize(attrs = nil)
-        @attributes = default_attributes
-        process(attrs)
-        @new_record = true
-        document = yield self if block_given?
-        identify
-      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+.
+    #
+    # Options:
+    #
+    # parent: The +Document+ to assimilate with.
+    # options: The association +Options+ for the child.
+    def assimilate(parent, options)
+      parentize(parent, options.name); notify; self
+    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
+    # Return the attributes hash with indifferent access.
+    def attributes
+      @attributes.with_indifferent_access
+    end
 
-      # Notify observers of an update.
-      #
-      # Example:
-      #
-      # <tt>person.notify</tt>
-      def notify
-        notify_observers(self)
-      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
 
-      # Sets up a child/parent association. This is used for newly created
-      # objects so they can be properly added to the graph and have the parent
-      # observers set up properly.
-      #
-      # Options:
-      #
-      # abject: The parent object that needs to be set for the child.
-      # association_name: The name of the association for the child.
-      #
-      # Example:
-      #
-      # <tt>address.parentize(person, :addresses)</tt>
-      def parentize(object, association_name)
-        self._parent = object
-        self.association_name = association_name.to_s
-        add_observer(object)
-      end
+    # Generate an id for this +Document+.
+    def identify
+      Identity.new(self).create
+    end
 
-      # Return the attributes hash.
-      def raw_attributes
-        @attributes
-      end
+    # Instantiate a new +Document+, setting the Document's attributes if
+    # given. If no attributes are provided, they will be initialized with
+    # 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 +BSON::ObjectID+ string.
+    #
+    # Options:
+    #
+    # attrs: The attributes +Hash+ to set up the document with.
+    def initialize(attrs = nil)
+      @attributes = default_attributes
+      process(attrs)
+      @new_record = true
+      document = yield self if block_given?
+      identify
+    end
 
-      # Reloads the +Document+ attributes from the database.
-      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
+    # 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
 
-      # 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
-        reset(name) { @attributes.remove(name, child.raw_attributes) }
-        notify
-      end
+    # Notify observers of an update.
+    #
+    # Example:
+    #
+    # <tt>person.notify</tt>
+    def notify
+      notify_observers(self)
+    end
 
-      # Return the root +Document+ in the object graph. If the current +Document+
-      # is the root object in the graph it will return self.
-      def _root
-        object = self
-        while (object._parent) do object = object._parent; end
-        object || self
-      end
+    # Return the attributes hash.
+    def raw_attributes
+      @attributes
+    end
 
-      # Return an array with this +Document+ only in it.
-      def to_a
-        [ self ]
+    # Reloads the +Document+ attributes from the database.
+    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
+    end
 
-      # Returns nil if document is new, or an array of primary keys if not.
-      def to_key
-        new_record? ? nil : [ id ]
-      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
+      reset(name) { @attributes.remove(name, child.raw_attributes) }
+      notify
+    end
 
-      # Returns the id of the Document, used in Rails compatibility.
-      def to_param
-        id
-      end
+    # Return an array with this +Document+ only in it.
+    def to_a
+      [ self ]
+    end
 
-      # Observe 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.
-      #
-      # Options:
-      #
-      # child: The child +Document+ that sent the notification.
-      # clear: Will clear out the child's attributes if set to true.
-      #
-      # This will also cause the observing +Document+ to notify it's parent if
-      # there is any.
-      def observe(child, clear = false)
-        name = child.association_name
-        attrs = child.instance_variable_get(:@attributes)
-        if clear
-          @attributes.delete(name)
-        else
-          @attributes.insert(name, attrs) unless @attributes[name] && @attributes[name].include?(attrs)
-        end
-        notify
-      end
+    # Observe 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.
+    #
+    # Options:
+    #
+    # child: The child +Document+ that sent the notification.
+    # clear: Will clear out the child's attributes if set to true.
+    #
+    # This will also cause the observing +Document+ to notify it's parent if
+    # there is any.
+    def observe(child, clear = false)
+      name = child.association_name
+      attrs = child.instance_variable_get(:@attributes)
+      if clear
+        @attributes.delete(name)
+      else
+        @attributes.insert(name, attrs) unless @attributes[name] && @attributes[name].include?(attrs)
+      end
+      notify
     end
   end
 end

data/lib/mongoid/extensions.rb

@@ -5,6 +5,7 @@ require "mongoid/extensions/array/aliasing"
 require "mongoid/extensions/array/assimilation"
 require "mongoid/extensions/array/conversions"
 require "mongoid/extensions/array/parentization"
+require "mongoid/extensions/set/conversions"
 require "mongoid/extensions/big_decimal/conversions"
 require "mongoid/extensions/binary/conversions"
 require "mongoid/extensions/boolean/conversions"
@@ -32,6 +33,10 @@ class Array #:nodoc
   include Mongoid::Extensions::Array::Parentization
 end
 
+class Set #:nodoc
+  include Mongoid::Extensions::Set::Conversions
+end
+
 class BigDecimal #:nodoc
   extend Mongoid::Extensions::BigDecimal::Conversions
 end

data/lib/mongoid/extensions/array/conversions.rb

@@ -6,11 +6,9 @@ module Mongoid #:nodoc:
       module Conversions #:nodoc:
         extend ActiveSupport::Concern
 
-        module InstanceMethods #:nodoc:
-          # Converts this array into an array of hashes.
-          def mongoidize
-            collect { |obj| obj.attributes }
-          end
+        # Converts this array into an array of hashes.
+        def mongoidize
+          collect { |obj| obj.attributes }
         end
 
         module ClassMethods #:nodoc:

data/lib/mongoid/extensions/hash/conversions.rb

@@ -5,30 +5,27 @@ module Mongoid #:nodoc:
       module Conversions #:nodoc:
         extend ActiveSupport::Concern
 
-        module InstanceMethods #:nodoc:
-
-          # Get the difference between 2 hashes. This will give back a new hash
-          # with the keys and pairs of [ old, new ] values.
-          #
-          # Example:
-          #
-          #   first = { :field => "value" }
-          #   second = { :field => "new" }
-          #   first.difference(second) # => { :field => [ "value", "new" ] }
-          #
-          # Returns:
-          #
-          # A +Hash+ of modifications.
-          def difference(other)
-            changes = {}
-            each_pair do |key, value|
-              if other.has_key?(key)
-                new_value = other[key]
-                changes[key] = [ value, new_value ] if new_value != value
-              end
+        # Get the difference between 2 hashes. This will give back a new hash
+        # with the keys and pairs of [ old, new ] values.
+        #
+        # Example:
+        #
+        #   first = { :field => "value" }
+        #   second = { :field => "new" }
+        #   first.difference(second) # => { :field => [ "value", "new" ] }
+        #
+        # Returns:
+        #
+        # A +Hash+ of modifications.
+        def difference(other)
+          changes = {}
+          each_pair do |key, value|
+            if other.has_key?(key)
+              new_value = other[key]
+              changes[key] = [ value, new_value ] if new_value != value
             end
-            changes
           end
+          changes
         end
 
         module ClassMethods #:nodoc:

data/lib/mongoid/extensions/object/conversions.rb

@@ -5,11 +5,9 @@ module Mongoid #:nodoc:
       # This module converts objects into mongoid related objects.
       module Conversions #:nodoc:
         extend ActiveSupport::Concern
-        module InstanceMethods
-          # Converts this object to a hash of attributes
-          def mongoidize
-            self.raw_attributes
-          end
+        # Converts this object to a hash of attributes
+        def mongoidize
+          self.raw_attributes
         end
 
         module ClassMethods