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

data/lib/mongoid/associations/references_many_as_array.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Associations #:nodoc:
+    # Represents an relational one-to-many association with an object in a
+    # separate collection or database, stored as an array of ids on the parent
+    # document.
+    class ReferencesManyAsArray < ReferencesMany
+
+      # Append a document to this association. This will also set the appended
+      # document's id on the inverse association as well.
+      #
+      # Example:
+      #
+      # <tt>person.preferences << Preference.new(:name => "VGA")</tt>
+      def <<(*objects)
+        @target = @target.entries
+        objects.flatten.each do |object|
+          # First set the documents id on the parent array of ids.
+          @parent.send(@foreign_key) << object.id
+          # Then we need to set the parent's id on the documents array of ids
+          # to get the inverse side of the association as well. Note, need a
+          # clean way to handle this with new documents - we want to set the
+          # actual objects as well, but dont want to get in an infinite loop
+          # while doing so.
+          object.send(reverse_key(object)) << @parent.id
+          @target << object
+        end
+      end
+
+      alias :concat :<<
+      alias :push :<<
+
+      # Builds a new Document and adds it to the association collection. The
+      # document created will be of the same class as the others in the
+      # association, and the attributes will be passed into the constructor.
+      #
+      # Returns the newly created object.
+      def build(attributes = nil)
+        load_target
+        document = @klass.instantiate(attributes || {})
+        push(document); document
+      end
+
+      protected
+      # Find the inverse key for the supplied document.
+      def reverse_key(document)
+        document.send(@options.inverse_of).options.foreign_key
+      end
+
+      # The default query used for retrieving the documents from the database.
+      def query
+        @query ||= lambda { @klass.any_in(:_id => @parent.send(@foreign_key)) }
+      end
+
+      class << self
+        # Perform an update of the relationship of the parent and child. This
+        # will assimilate the child +Document+ into the parent's object graph.
+        #
+        # Options:
+        #
+        # related: The related object
+        # parent: The parent +Document+ to update.
+        # options: The association +Options+
+        #
+        # Example:
+        #
+        # <tt>RelatesToManyAsArray.update(preferences, person, options)</tt>
+        def update(target, document, options)
+          target.each do |child|
+            name = child.associations[options.inverse_of.to_s].options.name
+            child.send(name) << document
+          end
+          instantiate(document, options, target)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/associations/{has_one_related.rb → references_one.rb}

@@ -3,7 +3,7 @@ module Mongoid #:nodoc:
   module Associations #:nodoc:
     # Represents an relational one-to-one association with an object in a
     # separate collection or database.
-    class HasOneRelated < Proxy
+    class ReferencesOne < Proxy
 
       delegate :nil?, :to => :target
 
@@ -42,6 +42,20 @@ module Mongoid #:nodoc:
         extends(options)
       end
 
+      # Used for setting the association via a nested attributes setter on the
+      # parent +Document+. Called when using accepts_nested_attributes_for.
+      #
+      # Options:
+      #
+      # attributes: The attributes for the new association
+      #
+      # Returns:
+      #
+      # A new target document.
+      def nested_build(attributes, options = nil)
+        build(attributes) unless @target.blank? && options[:update_only]
+      end
+
       class << self
         # Preferred method for creating the new +RelatesToMany+ association.
         #
@@ -55,7 +69,7 @@ module Mongoid #:nodoc:
 
         # Returns the macro used to create the association.
         def macro
-          :has_one_related
+          :references_one
         end
 
         # Perform an update of the relationship of the parent and child. This

data/lib/mongoid/atomicity.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Atomicity #:nodoc:
+    extend ActiveSupport::Concern
+
+    # Get all the atomic updates that need to happen for the current
+    # +Document+. This will include all changes that need to happen in the
+    # entire hierarchy that exists below where the save call was made.
+    #
+    # Example:
+    #
+    # <tt>person.save</tt> # Saves entire tree
+    #
+    # Returns:
+    #
+    # A +Hash+ of all atomic updates that need to occur.
+    def _updates
+      _children.inject({ "$set" => _sets, "$push" => {}}) do |updates, child|
+        updates["$set"].update(child._sets)
+        updates["$push"].update(child._pushes)
+        updates
+      end.delete_if do |key, value|
+        value.empty?
+      end
+    end
+
+    protected
+    # Get all the push attributes that need to occur.
+    def _pushes
+      (new_record? && embedded_many? && !_parent.new_record?) ? { _path => raw_attributes } : {}
+    end
+
+    # Get all the attributes that need to be set.
+    def _sets
+      if changed? && !new_record?
+        setters
+      else
+        embedded_one? && new_record? ? { _path => raw_attributes } : {}
+      end
+    end
+  end
+end

data/lib/mongoid/attributes.rb

@@ -2,172 +2,174 @@
 module Mongoid #:nodoc:
   module Attributes
     extend ActiveSupport::Concern
-    module InstanceMethods
-      # Get the id associated with this object. This will pull the _id value out
-      # of the attributes +Hash+.
-      def id
-        @attributes["_id"]
-      end
 
-      # Set the id of the +Document+ to a new one.
-      def id=(new_id)
-        @attributes["_id"] = new_id
-      end
+    # Get the id associated with this object. This will pull the _id value out
+    # of the attributes +Hash+.
+    def id
+      @attributes["_id"]
+    end
 
-      alias :_id :id
-      alias :_id= :id=
-
-      # Used for allowing accessor methods for dynamic attributes.
-      def method_missing(name, *args)
-        attr = name.to_s
-        return super unless @attributes.has_key?(attr.reader)
-        if attr.writer?
-          # "args.size > 1" allows to simulate 1.8 behavior of "*args"
-          @attributes[attr.reader] = (args.size > 1) ? args : args.first
-        else
-          @attributes[attr.reader]
-        end
+    # Set the id of the +Document+ to a new one.
+    def id=(new_id)
+      @attributes["_id"] = new_id
+    end
+
+    alias :_id :id
+    alias :_id= :id=
+
+    # Used for allowing accessor methods for dynamic attributes.
+    def method_missing(name, *args)
+      attr = name.to_s
+      return super unless @attributes.has_key?(attr.reader)
+      if attr.writer?
+        # "args.size > 1" allows to simulate 1.8 behavior of "*args"
+        write_attribute(attr.reader, (args.size > 1) ? args : args.first)
+      else
+        read_attribute(attr.reader)
       end
+    end
 
-      # Process the provided attributes casting them to their proper values if a
-      # field exists for them on the +Document+. This will be limited to only the
-      # attributes provided in the suppied +Hash+ so that no extra nil values get
-      # put into the document's attributes.
-      def process(attrs = nil)
-        (attrs || {}).each_pair do |key, value|
-          if set_allowed?(key)
-            @attributes[key.to_s] = value
-          elsif write_allowed?(key)
-            send("#{key}=", value)
-          end
+    # Process the provided attributes casting them to their proper values if a
+    # field exists for them on the +Document+. This will be limited to only the
+    # attributes provided in the suppied +Hash+ so that no extra nil values get
+    # put into the document's attributes.
+    def process(attrs = nil)
+      (attrs || {}).each_pair do |key, value|
+        if set_allowed?(key)
+          write_attribute(key, value)
+        elsif write_allowed?(key)
+          send("#{key}=", value)
         end
-        setup_modifications
       end
+      setup_modifications
+    end
 
-      # Read a value from the +Document+ attributes. If the value does not exist
-      # it will return nil.
-      #
-      # Options:
-      #
-      # name: The name of the attribute to get.
-      #
-      # Example:
-      #
-      # <tt>person.read_attribute(:title)</tt>
-      def read_attribute(name)
-        access = name.to_s
-        accessed(access, fields[access].get(@attributes[access]))
-      end
+    # Read a value from the +Document+ attributes. If the value does not exist
+    # it will return nil.
+    #
+    # Options:
+    #
+    # name: The name of the attribute to get.
+    #
+    # Example:
+    #
+    # <tt>person.read_attribute(:title)</tt>
+    def read_attribute(name)
+      access = name.to_s
+      value = @attributes[access]
+      typed_value = fields.has_key?(access) ? fields[access].get(value) : value
+      accessed(access, typed_value)
+    end
 
-      # Remove a value from the +Document+ attributes. If the value does not exist
-      # it will fail gracefully.
-      #
-      # Options:
-      #
-      # name: The name of the attribute to remove.
-      #
-      # Example:
-      #
-      # <tt>person.remove_attribute(:title)</tt>
-      def remove_attribute(name)
-        access = name.to_s
-        modify(access, @attributes.delete(name.to_s), nil)
-      end
+    # Remove a value from the +Document+ attributes. If the value does not exist
+    # it will fail gracefully.
+    #
+    # Options:
+    #
+    # name: The name of the attribute to remove.
+    #
+    # Example:
+    #
+    # <tt>person.remove_attribute(:title)</tt>
+    def remove_attribute(name)
+      access = name.to_s
+      modify(access, @attributes.delete(name.to_s), nil)
+    end
 
-      # Returns the object type. This corresponds to the name of the class that
-      # this +Document+ is, which is used in determining the class to
-      # instantiate in various cases.
-      def _type
-        @attributes["_type"]
-      end
+    # Returns the object type. This corresponds to the name of the class that
+    # this +Document+ is, which is used in determining the class to
+    # instantiate in various cases.
+    def _type
+      @attributes["_type"]
+    end
 
-      # Set the type of the +Document+. This should be the name of the class.
-      def _type=(new_type)
-        @attributes["_type"] = new_type
-      end
+    # Set the type of the +Document+. This should be the name of the class.
+    def _type=(new_type)
+      @attributes["_type"] = new_type
+    end
 
-      # Write a single attribute to the +Document+ attribute +Hash+. This will
-      # also fire the before and after update callbacks, and perform any
-      # necessary typecasting.
-      #
-      # Options:
-      #
-      # name: The name of the attribute to update.
-      # value: The value to set for the attribute.
-      #
-      # Example:
-      #
-      # <tt>person.write_attribute(:title, "Mr.")</tt>
-      #
-      # This will also cause the observing +Document+ to notify it's parent if
-      # there is any.
-      def write_attribute(name, value)
-        access = name.to_s
-        modify(access, @attributes[access], fields[access].set(value))
-        notify if !id.blank? && new_record?
-      end
+    # Write a single attribute to the +Document+ attribute +Hash+. This will
+    # also fire the before and after update callbacks, and perform any
+    # necessary typecasting.
+    #
+    # Options:
+    #
+    # name: The name of the attribute to update.
+    # value: The value to set for the attribute.
+    #
+    # Example:
+    #
+    # <tt>person.write_attribute(:title, "Mr.")</tt>
+    #
+    # This will also cause the observing +Document+ to notify it's parent if
+    # there is any.
+    def write_attribute(name, value)
+      access = name.to_s
+      typed_value = fields.has_key?(access) ? fields[access].set(value) : value
+      modify(access, @attributes[access], typed_value)
+      notify if !id.blank? && new_record?
+    end
 
-      # Writes the supplied attributes +Hash+ to the +Document+. This will only
-      # overwrite existing attributes if they are present in the new +Hash+, all
-      # others will be preserved.
-      #
-      # Options:
-      #
-      # attrs: The +Hash+ of new attributes to set on the +Document+
-      #
-      # Example:
-      #
-      # <tt>person.write_attributes(:title => "Mr.")</tt>
-      #
-      # This will also cause the observing +Document+ to notify it's parent if
-      # there is any.
-      def write_attributes(attrs = nil)
-        process(attrs || {})
-        identified = !id.blank?
-        if new_record? && !identified
-          identify; notify
-        end
-      end
-      alias :attributes= :write_attributes
-
-      protected
-      # apply default values to attributes - calling procs as required
-      def default_attributes
-        default_values = defaults
-        default_values.each_pair do |key, val|
-          default_values[key] = val.call if val.respond_to?(:call)
-        end
-        default_values || {}
+    # Writes the supplied attributes +Hash+ to the +Document+. This will only
+    # overwrite existing attributes if they are present in the new +Hash+, all
+    # others will be preserved.
+    #
+    # Options:
+    #
+    # attrs: The +Hash+ of new attributes to set on the +Document+
+    #
+    # Example:
+    #
+    # <tt>person.write_attributes(:title => "Mr.")</tt>
+    #
+    # This will also cause the observing +Document+ to notify it's parent if
+    # there is any.
+    def write_attributes(attrs = nil)
+      process(attrs || {})
+      identified = !id.blank?
+      if new_record? && !identified
+        identify; notify
       end
+    end
+    alias :attributes= :write_attributes
 
-      # Return true if dynamic field setting is enabled.
-      def set_allowed?(key)
-        Mongoid.allow_dynamic_fields && !respond_to?("#{key}=")
+    protected
+    # apply default values to attributes - calling procs as required
+    def default_attributes
+      default_values = defaults
+      default_values.each_pair do |key, val|
+        default_values[key] = val.call if val.respond_to?(:call)
       end
+      default_values || {}
+    end
 
-      # Used when supplying a :reject_if block as an option to
-      # accepts_nested_attributes_for
-      def reject(attributes, options)
-        rejector = options[:reject_if]
-        if rejector
-          attributes.delete_if do |key, value|
-            rejector.call(value)
-          end
+    # Return true if dynamic field setting is enabled.
+    def set_allowed?(key)
+      Mongoid.allow_dynamic_fields && !respond_to?("#{key}=")
+    end
+
+    # Used when supplying a :reject_if block as an option to
+    # accepts_nested_attributes_for
+    def reject(attributes, options)
+      rejector = options[:reject_if]
+      if rejector
+        attributes.delete_if do |key, value|
+          rejector.call(value)
         end
       end
+    end
 
-      # Used when supplying a :limit as an option to accepts_nested_attributes_for
-      def limit(attributes, name, options)
-        raise Mongoid::Errors::TooManyNestedAttributeRecords.new(name, options[:limit]) if options[:limit] && attributes.size > options[:limit]
-      end
+    # Used when supplying a :limit as an option to accepts_nested_attributes_for
+    def limit(attributes, name, options)
+      raise Mongoid::Errors::TooManyNestedAttributeRecords.new(name, options[:limit]) if options[:limit] && attributes.size > options[:limit]
+    end
 
-      # Return true if writing to the given field is allowed
-      def write_allowed?(key)
-        name = key.to_s
-        existing = fields[name]
-        return true unless existing
-        existing.accessible?
-      end
+    # Return true if writing to the given field is allowed
+    def write_allowed?(key)
+      name = key.to_s
+      existing = fields[name]
+      return true unless existing
+      existing.accessible?
     end
 
     module ClassMethods