snusnu-dm-accepts_nested_attributes 0.0.2 → 0.0.3

data/Manifest.txt

@@ -6,21 +6,18 @@ README.textile
 Rakefile
 TODO
 lib/dm-accepts_nested_attributes.rb
-lib/dm-accepts_nested_attributes/associations.rb
+lib/dm-accepts_nested_attributes/association_proxies.rb
+lib/dm-accepts_nested_attributes/association_validation.rb
 lib/dm-accepts_nested_attributes/nested_attributes.rb
 lib/dm-accepts_nested_attributes/version.rb
 spec/fixtures/person.rb
-spec/fixtures/photo.rb
 spec/fixtures/profile.rb
 spec/fixtures/project.rb
 spec/fixtures/project_membership.rb
-spec/fixtures/tag.rb
-spec/fixtures/tagging.rb
 spec/fixtures/task.rb
 spec/integration/belongs_to_spec.rb
 spec/integration/has_1_spec.rb
 spec/integration/has_n_spec.rb
-spec/integration/has_n_through_renamed_spec.rb
 spec/integration/has_n_through_spec.rb
 spec/shared/rspec_tmbundle_support.rb
 spec/spec.opts

data/lib/dm-accepts_nested_attributes.rb

@@ -12,7 +12,8 @@ require 'dm-validations'
 # Require plugin-files
 require Pathname(__FILE__).dirname.expand_path / 'dm-accepts_nested_attributes' / 'nested_attributes'
 # monkeypatches for dm-core/associations/(many_to_one.rb and one_to_many.rb)
-require Pathname(__FILE__).dirname.expand_path / 'dm-accepts_nested_attributes' / 'associations'
+require Pathname(__FILE__).dirname.expand_path / 'dm-accepts_nested_attributes' / 'association_proxies'
 
 # Include the plugin in Model
-DataMapper::Resource.append_inclusions DataMapper::NestedAttributes
+DataMapper::Model.append_extensions DataMapper::NestedAttributes::ClassMethods
+DataMapper::Resource.append_inclusions DataMapper::NestedAttributes::CommonInstanceMethods

data/lib/dm-accepts_nested_attributes/association_validation.rb

@@ -0,0 +1,91 @@
+module DataMapper
+  module NestedAttributes
+
+    module AssociationValidation
+
+      # NOTE: 
+      # overwriting Resource#save like this breaks the before(:save) hook stack
+      # this hopefully is no problem, since the current implementation doesn't rely on
+      # a before(:save) hook, but rather overwrites this hook with a no-op, and adds
+      # the desired behavior via overwriting Resource#save directly. I'd really appreciate
+      # any ideas for doing this differently, though. Anyways, I'm not really sure if this
+      # is the right approach. I don't even know if it works with custom validations,
+      # or maybe breaks other things. It's also really not well specced at all atm.
+      # Use at your own risk :-)
+
+      def save(context = :default)
+
+        # -----------------------------------------------------------------
+        #              ORIGINAL CODE from Resource#save
+        # -----------------------------------------------------------------
+        #
+        # associations_saved = false
+        # child_associations.each { |a| associations_saved |= a.save }
+        # 
+        # saved = new_record? ? create : update
+        # 
+        # if saved
+        #   original_values.clear
+        # end
+        # 
+        # parent_associations.each { |a| associations_saved |= a.save }
+        # 
+        # # We should return true if the model (or any of its associations)
+        # # were saved.
+        # (saved | associations_saved) == true
+        #
+        # -----------------------------------------------------------------
+
+        return super if context.nil? # preserve save! behavior
+
+        associations_saved = false
+
+        child_associations.each do |a|
+  
+          if a.respond_to?(:valid?)
+            a.errors.each { |e| self.errors.add(:general, e) } unless a.valid?(context)
+          else
+            self.errors.add(:general, "child association is missing")
+          end
+  
+          associations_saved |= a.save
+  
+        end
+
+        saved = self.valid? && (new_record? ? create : update)
+
+        if saved
+          original_values.clear
+        end
+
+        parent_associations.each do |a|
+  
+          if a.respond_to?(:each) 
+            a.each do |r|
+              r.errors.each { |e| self.errors.add(:general, e) } unless r.valid?(context)
+            end
+          else                  
+            a.errors.each { |e| self.errors.add(:general, e) } unless a.valid?(context)
+          end
+  
+          associations_saved |= a.save
+  
+        end
+
+        (saved | associations_saved) == true
+
+      end
+
+      # everything works the same if this method isn't overwritten with a no-op
+      # however, i suspect that this is the case because the registered before(:save) hook
+      # somehow gets lost when overwriting Resource#save here in this module.
+      # I'll leave it in for now, to make the purpose clear
+
+      def check_validations(context = :default)
+        true # no-op, validations are checked inside #save
+      end
+
+    end
+    
+  end
+end

data/lib/dm-accepts_nested_attributes/nested_attributes.rb

@@ -1,14 +1,13 @@
 module DataMapper
   module NestedAttributes
     
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.class_inheritable_accessor :autosave_associations
-      base.autosave_associations = {}
-    end
-    
     module ClassMethods
       
+      def self.extended(base)
+        base.class_inheritable_accessor :autosave_associations
+        base.autosave_associations = {}
+      end
+      
       # Defines an attributes reader and writer for the specified association(s).
       # If you are using <tt>attr_protected</tt> or <tt>attr_accessible</tt>,
       # then you will need to add the attribute writer to the allowed list.
@@ -57,17 +56,37 @@ module DataMapper
         
         association_for_name(association_name)
         
+        
+        # should be safe to go on
+        
+        include InstanceMethods
+        
+        if ::DataMapper.const_defined?('Validate')
+
+          require Pathname(__FILE__).dirname.expand_path + 'association_validation'
+
+          include AssociationValidation
+
+        end
+        
         autosave_associations[association_name] = options
         
         type = nr_of_possible_child_instances(association_name) > 1 ? :collection : :one_to_one
         
         class_eval %{
           
+          def save(context = :default)
+            saved = false # preserve Resource#save api contract
+            transaction { |t| t.rollback unless saved = super }
+            saved
+          end
+          
           def #{association_name}_attributes
             @#{association_name}_attributes
           end
           
           def #{association_name}_attributes=(attributes)
+            attributes = sanitize_nested_attributes(attributes)
             @#{association_name}_attributes = attributes
             assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes, #{options[:allow_destroy]})
           end
@@ -151,249 +170,181 @@ module DataMapper
     end
     
     
-    # instance methods
-    
+    module InstanceMethods
     
-    if ::DataMapper.const_defined?('Validate')
-      
-      # NOTE: 
-      # overwriting Resource#save like this breaks the before(:save) hook stack
-      # this hopefully is no problem, since the current implementation doesn't rely on
-      # a before(:save) hook, but rather overwrites this hook with a no-op, and adds
-      # the desired behavior via overwriting Resource#save directly. I'd really appreciate
-      # any ideas for doing this differently, though. Anyways, I'm not really sure if this
-      # is the right approach. I don't even know if it works with custom validations,
-      # or maybe breaks other things. It's also really not well specced at all atm.
-      # Use at your own risk :-)
-      
-      def save(context = :default)
-        
-        # -----------------------------------------------------------------
-        #              ORIGINAL CODE from Resource#save
-        # -----------------------------------------------------------------
-        #
-        # associations_saved = false
-        # child_associations.each { |a| associations_saved |= a.save }
-        # 
-        # saved = new_record? ? create : update
-        # 
-        # if saved
-        #   original_values.clear
-        # end
-        # 
-        # parent_associations.each { |a| associations_saved |= a.save }
-        # 
-        # # We should return true if the model (or any of its associations)
-        # # were saved.
-        # (saved | associations_saved) == true
-        #
-        # -----------------------------------------------------------------
-        
-        
-        return super if context.nil? # preserve save! behavior
-        
-        associations_saved = false
-        
-        child_associations.each do |a|
-          
-          if a.respond_to?(:valid?)
-            a.errors.each { |e| self.errors.add(:general, e) } unless a.valid?(context)
-          else
-            self.errors.add(:general, "child association is missing")
-          end
-          
-          associations_saved |= a.save
-          
-        end
-        
-        saved = self.valid? && (new_record? ? create : update)
-        
-        if saved
-          original_values.clear
-        end
-        
-        parent_associations.each do |a|
-          
-          if a.respond_to?(:each) 
-            a.each do |r|
-              r.errors.each { |e| self.errors.add(:general, e) } unless r.valid?(context)
-            end
-          else                  
-            a.errors.each { |e| self.errors.add(:general, e) } unless a.valid?(context)
-          end
-          
-          associations_saved |= a.save
-          
-        end
-        
-        (saved | associations_saved) == true
-        
-      end
-      
-      # everything works the same if this method isn't overwritten with a no-op
-      # however, i suspect that this is the case because the registered before(:save) hook
-      # somehow gets lost when overwriting Resource#save here in this module.
-      # I'll leave it in for now, to make the purpose clear
-      
-      def check_validations(context = :default)
-        true # no-op, validations are checked inside #save
+      # This method can be used to remove ambiguities from the passed attributes.
+      # Consider a situation with a belongs_to association where both a valid value
+      # for the foreign_key attribute *and* nested_attributes for a new record are
+      # present (i.e. item_type_id and item_type_attributes are present).
+      # Also see http://is.gd/sz2d on the rails-core ml for a discussion on this.
+      # The basic idea is, that there should be a well defined behavior for what
+      # exactly happens when such a situation occurs. I'm currently in favor for 
+      # using the foreign_key if it is present, but this probably needs more thinking.
+      # For now, this method basically is a no-op, but at least it provides a hook where
+      # everyone can perform it's own sanitization (just overwrite this method) 
+      def sanitize_nested_attributes(attrs)
+        attrs
       end
-      
-    end
     
-    # returns nil if no resource has been associated yet
-    def associated_instance_get(association_name, repository = :default)
-      send(self.class.association_for_name(association_name, repository).name)
-    end
-    
-    # Reloads the attributes of the object as usual and removes a mark for destruction.
-    def reload
-      @marked_for_destruction = false
-      super
-    end
-    
-    def marked_for_destruction?
-      @marked_for_destruction
-    end
-    
-    def mark_for_destruction
-      @marked_for_destruction = true
-    end
+      # returns nil if no resource has been associated yet
+      def associated_instance_get(association_name, repository = :default)
+        send(self.class.association_for_name(association_name, repository).name)
+      end
 
 
-    private
+      private
 
-    # Attribute hash keys that should not be assigned as normal attributes.
-    # These hash keys are nested attributes implementation details.
-    UNASSIGNABLE_KEYS = [ :id, :_delete ]
+      # Attribute hash keys that should not be assigned as normal attributes.
+      # These hash keys are nested attributes implementation details.
+      UNASSIGNABLE_KEYS = [ :id, :_delete ]
     
     
-    # Assigns the given attributes to the association.
-    #
-    # If the given attributes include an <tt>:id</tt> that matches the existing
-    # record’s id, then the existing record will be modified. Otherwise a new
-    # record will be built.
-    #
-    # If the given attributes include a matching <tt>:id</tt> attribute _and_ a
-    # <tt>:_delete</tt> key set to a truthy value, then the existing record
-    # will be marked for destruction.
-    def assign_nested_attributes_for_one_to_one_association(association_name, attributes, allow_destroy)
-      if attributes[:id].blank?
-        unless reject_new_record?(association_name, attributes)
-          model = self.class.associated_model_for_name(association_name)
-          send("#{association_name}=", model.new(attributes.except(*UNASSIGNABLE_KEYS)))
+      # Assigns the given attributes to the association.
+      #
+      # If the given attributes include an <tt>:id</tt> that matches the existing
+      # record’s id, then the existing record will be modified. Otherwise a new
+      # record will be built.
+      #
+      # If the given attributes include a matching <tt>:id</tt> attribute _and_ a
+      # <tt>:_delete</tt> key set to a truthy value, then the existing record
+      # will be marked for destruction.
+      def assign_nested_attributes_for_one_to_one_association(association_name, attributes, allow_destroy)
+        if attributes[:id].blank?
+          unless reject_new_record?(association_name, attributes)
+            model = self.class.associated_model_for_name(association_name)
+            send("#{association_name}=", model.new(attributes.except(*UNASSIGNABLE_KEYS)))
+          end
+        else (existing_record = associated_instance_get(association_name)) && existing_record.id.to_s == attributes[:id].to_s
+          assign_to_or_mark_for_destruction(association_name, existing_record, attributes, allow_destroy)
         end
-      else (existing_record = associated_instance_get(association_name)) && existing_record.id.to_s == attributes[:id].to_s
-        assign_to_or_mark_for_destruction(association_name, existing_record, attributes, allow_destroy)
       end
-    end
     
-    # Assigns the given attributes to the collection association.
-    #
-    # Hashes with an <tt>:id</tt> value matching an existing associated record
-    # will update that record. Hashes without an <tt>:id</tt> value will build
-    # a new record for the association. Hashes with a matching <tt>:id</tt>
-    # value and a <tt>:_delete</tt> key set to a truthy value will mark the
-    # matched record for destruction.
-    #
-    # For example:
-    #
-    # assign_nested_attributes_for_collection_association(:people, {
-    # '1' => { :id => '1', :name => 'Peter' },
-    # '2' => { :name => 'John' },
-    # '3' => { :id => '2', :_delete => true }
-    # })
-    #
-    # Will update the name of the Person with ID 1, build a new associated
-    # person with the name `John', and mark the associatied Person with ID 2
-    # for destruction.
-    #
-    # Also accepts an Array of attribute hashes:
-    #
-    # assign_nested_attributes_for_collection_association(:people, [
-    # { :id => '1', :name => 'Peter' },
-    # { :name => 'John' },
-    # { :id => '2', :_delete => true }
-    # ])
-    def assign_nested_attributes_for_collection_association(association_name, attributes_collection, allow_destroy)
+      # Assigns the given attributes to the collection association.
+      #
+      # Hashes with an <tt>:id</tt> value matching an existing associated record
+      # will update that record. Hashes without an <tt>:id</tt> value will build
+      # a new record for the association. Hashes with a matching <tt>:id</tt>
+      # value and a <tt>:_delete</tt> key set to a truthy value will mark the
+      # matched record for destruction.
+      #
+      # For example:
+      #
+      # assign_nested_attributes_for_collection_association(:people, {
+      # '1' => { :id => '1', :name => 'Peter' },
+      # '2' => { :name => 'John' },
+      # '3' => { :id => '2', :_delete => true }
+      # })
+      #
+      # Will update the name of the Person with ID 1, build a new associated
+      # person with the name `John', and mark the associatied Person with ID 2
+      # for destruction.
+      #
+      # Also accepts an Array of attribute hashes:
+      #
+      # assign_nested_attributes_for_collection_association(:people, [
+      # { :id => '1', :name => 'Peter' },
+      # { :name => 'John' },
+      # { :id => '2', :_delete => true }
+      # ])
+      def assign_nested_attributes_for_collection_association(association_name, attributes_collection, allow_destroy)
       
-      assert_kind_of 'association_name',      association_name,      Symbol
-      assert_kind_of 'attributes_collection', attributes_collection, Hash, Array
+        assert_kind_of 'association_name',      association_name,      Symbol
+        assert_kind_of 'attributes_collection', attributes_collection, Hash, Array
        
-      if attributes_collection.is_a? Hash
-        attributes_collection = attributes_collection.sort_by { |index, _| index.to_i }.map { |_, attributes| attributes }
-      end
+        if attributes_collection.is_a? Hash
+          attributes_collection = attributes_collection.sort_by { |index, _| index.to_i }.map { |_, attributes| attributes }
+        end
        
-      attributes_collection.each do |attributes|
-        if attributes[:id].blank?
-          unless reject_new_record?(association_name, attributes)
-            case self.class.association_type(association_name)
-            when :one_to_many
-              build_new_has_n_association(association_name, attributes)
-            when :many_to_many
-              build_new_has_n_through_association(association_name, attributes)
+        attributes_collection.each do |attributes|
+          if attributes[:id].blank?
+            unless reject_new_record?(association_name, attributes)
+              case self.class.association_type(association_name)
+              when :one_to_many
+                build_new_has_n_association(association_name, attributes)
+              when :many_to_many
+                build_new_has_n_through_association(association_name, attributes)
+              end
             end
+          elsif existing_record = send(association_name).detect { |record| record.id.to_s == attributes[:id].to_s }
+            assign_to_or_mark_for_destruction(association_name, existing_record, attributes, allow_destroy)
           end
-        elsif existing_record = send(association_name).detect { |record| record.id.to_s == attributes[:id].to_s }
-          assign_to_or_mark_for_destruction(association_name, existing_record, attributes, allow_destroy)
         end
-      end
       
-    end
+      end
     
-    def build_new_has_n_association(association_name, attributes)
-      send(association_name).build(attributes.except(*UNASSIGNABLE_KEYS))
-    end
+      def build_new_has_n_association(association_name, attributes)
+        send(association_name).build(attributes.except(*UNASSIGNABLE_KEYS))
+      end
         
-    def build_new_has_n_through_association(association_name, attributes)
-      # fetch the association to have the information ready
-      association = self.class.association_for_name(association_name)
+      def build_new_has_n_through_association(association_name, attributes)
+        # fetch the association to have the information ready
+        association = self.class.association_for_name(association_name)
       
-      # do what's done in dm-core/specs/integration/association_through_spec.rb
+        # do what's done in dm-core/specs/integration/association_through_spec.rb
       
-      # explicitly build the join entry and assign it to the join association
-      join_entry = self.class.associated_model_for_name(association.name).new
-      self.send(association.name) << join_entry
-      self.save
-      # explicitly build the child entry and assign the join entry to its join association
-      child_entry = self.class.associated_model_for_name(association_name).new(attributes)
-      child_entry.send(association.name) << join_entry
-      child_entry.save
-    end
+        # explicitly build the join entry and assign it to the join association
+        join_entry = self.class.associated_model_for_name(association.name).new
+        self.send(association.name) << join_entry
+        self.save
+        # explicitly build the child entry and assign the join entry to its join association
+        child_entry = self.class.associated_model_for_name(association_name).new(attributes)
+        child_entry.send(association.name) << join_entry
+        child_entry.save
+      end
     
-    # Updates a record with the +attributes+ or marks it for destruction if
-    # +allow_destroy+ is +true+ and has_delete_flag? returns +true+.
-    def assign_to_or_mark_for_destruction(association_name, record, attributes, allow_destroy)
-      if has_delete_flag?(attributes) && allow_destroy
-        if self.class.association_type(association_name) == :many_to_many
-          # destroy the join record
-          record.send(self.class.association_for_name(association_name).name).destroy!
-          # destroy the child record
-          record.destroy
+      # Updates a record with the +attributes+ or marks it for destruction if
+      # +allow_destroy+ is +true+ and has_delete_flag? returns +true+.
+      def assign_to_or_mark_for_destruction(association_name, record, attributes, allow_destroy)
+        if has_delete_flag?(attributes) && allow_destroy
+          if self.class.association_type(association_name) == :many_to_many
+            # destroy the join record
+            record.send(self.class.association_for_name(association_name).name).destroy!
+            # destroy the child record
+            record.destroy
+          else
+            record.mark_for_destruction
+          end
         else
-          record.mark_for_destruction
-        end
-      else
-        record.attributes = attributes.except(*UNASSIGNABLE_KEYS)
-        if self.class.association_type(association_name) == :many_to_many
-          record.save
+          record.attributes = attributes.except(*UNASSIGNABLE_KEYS)
+          if self.class.association_type(association_name) == :many_to_many
+            record.save
+          end
         end
       end
-    end
     
-    # Determines if a hash contains a truthy _delete key.
-    def has_delete_flag?(hash)
-      # TODO find out if this activerecord code needs to be ported
-      # ConnectionAdapters::Column.value_to_boolean hash['_delete']
-      hash[:_delete]
+      # Determines if a hash contains a truthy _delete key.
+      def has_delete_flag?(hash)
+        # TODO find out if this activerecord code needs to be ported
+        # ConnectionAdapters::Column.value_to_boolean hash['_delete']
+        hash[:_delete]
+      end
+    
+      # Determines if a new record should be build by checking for
+      # has_delete_flag? or if a <tt>:reject_if</tt> proc exists for this
+      # association and evaluates to +true+.
+      def reject_new_record?(association_name, attributes)
+        guard = self.class.reject_new_nested_attributes_proc_for(association_name)
+        has_delete_flag?(attributes) || (guard.respond_to?(:call) && guard.call(attributes))
+      end
+      
     end
     
-    # Determines if a new record should be build by checking for
-    # has_delete_flag? or if a <tt>:reject_if</tt> proc exists for this
-    # association and evaluates to +true+.
-    def reject_new_record?(association_name, attributes)
-      guard = self.class.reject_new_nested_attributes_proc_for(association_name)
-      has_delete_flag?(attributes) || (guard.respond_to?(:call) && guard.call(attributes))
+    module CommonInstanceMethods
+      
+      # Reloads the attributes of the object as usual and removes a mark for destruction.
+      def reload
+        @marked_for_destruction = false
+        super
+      end
+    
+      def marked_for_destruction?
+        @marked_for_destruction
+      end
+    
+      def mark_for_destruction
+        @marked_for_destruction = true
+      end
+      
     end
 
   end