snusnu-dm-accepts_nested_attributes 0.0.6 → 0.10.0

data/Manifest.txt

@@ -7,25 +7,30 @@ Rakefile
 TODO
 CHANGELOG
 lib/dm-accepts_nested_attributes.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/error_collecting.rb
+lib/dm-accepts_nested_attributes/model.rb
 lib/dm-accepts_nested_attributes/resource.rb
+lib/dm-accepts_nested_attributes/save.rb
+lib/dm-accepts_nested_attributes/transactional_save.rb
 lib/dm-accepts_nested_attributes/version.rb
+spec/spec.opts
+spec/spec_helper.rb
+spec/lib/rspec_tmbundle_support.rb
 spec/fixtures/person.rb
 spec/fixtures/profile.rb
 spec/fixtures/project.rb
 spec/fixtures/project_membership.rb
 spec/fixtures/task.rb
+spec/shared/belongs_to_spec.rb
+spec/shared/has_1_spec.rb
+spec/shared/has_n_spec.rb
+spec/shared/has_n_through_spec.rb
+spec/unit/accepts_nested_attributes_for_spec.rb
 spec/integration/belongs_to_spec.rb
 spec/integration/has_1_spec.rb
 spec/integration/has_n_spec.rb
 spec/integration/has_n_through_spec.rb
-spec/shared/rspec_tmbundle_support.rb
-spec/spec.opts
-spec/spec_helper.rb
-spec/unit/accepts_nested_attributes_for_spec.rb
-spec/unit/resource_spec.rb
+tasks/changelog.rb
 tasks/gemspec.rb
 tasks/hoe.rb
 tasks/install.rb

data/Rakefile

@@ -1,5 +1,4 @@
 require 'pathname'
-require 'rubygems'
 require 'rake'
 require 'rake/rdoctask'
  
@@ -16,8 +15,8 @@ GEM_NAME = "dm-accepts_nested_attributes"
 GEM_VERSION = DataMapper::NestedAttributes::VERSION
 
 GEM_DEPENDENCIES = [
-  ["dm-core",         '>=0.9.11'],
-  ['addressable',     '~>2.0.2' ]
+  ["dm-core",        '>=0.10.0'],
+  ["dm-validations", '>=0.10.0']
 ]
 
 GEM_CLEAN = %w[ log pkg coverage ]

data/TODO

@@ -1,3 +1,8 @@
 TODO
 ====
 
+* add specs for :reject_if => :foo option, but think about _where_ first!
+* think about supporting :reject_unless in addition to :reject_if
+* think about generalizing :reject_if to not only work for new? resources
+* think about :allow_destroy accepting the same parameters like :reject_if
+  (Symbol, String, #call)

data/lib/dm-accepts_nested_attributes.rb

@@ -1,20 +1,13 @@
-# Needed to import datamapper and other gems
-require 'rubygems'
 require 'pathname'
-
-# Add all external dependencies for the plugin here
-gem 'dm-core',          '>=0.9.11'
-gem 'dm-validations',   '>=0.9.11'
-
 require 'dm-core'
-require 'dm-validations'
 
-# Require plugin-files
 dir = Pathname(__FILE__).dirname.expand_path / 'dm-accepts_nested_attributes'
+
+require dir / 'model'
+#require dir / 'save'
 require dir / 'resource'
-require dir / 'association_proxies'
-require dir / 'nested_attributes'
 
-# Include the plugin in Model
-DataMapper::Model.append_extensions DataMapper::NestedAttributes::ClassMethods
-DataMapper::Resource.append_inclusions DataMapper::NestedAttributes::CommonInstanceMethods
+# Activate the plugin
+DataMapper::Model.append_extensions(DataMapper::NestedAttributes::Model)
+#DataMapper::Model.append_inclusions(DataMapper::NestedAttributes::Save)
+DataMapper::Model.append_inclusions(DataMapper::NestedAttributes::CommonResourceSupport)

data/lib/dm-accepts_nested_attributes/error_collecting.rb

@@ -0,0 +1,35 @@
+module DataMapper
+  module NestedAttributes
+    
+    module ValidationErrorCollecting
+      
+      # collect errors on parent associations
+      def before_save_parent_association(association, context)
+        if association.respond_to?(:each) 
+          association.each do |r|
+            unless r.valid?(context)
+              r.errors.each { |e| self.errors.add(:general, e) }
+            end
+          end
+        else
+          unless association.valid?(context)
+            association.errors.each { |e| self.errors.add(:general, e) }
+          end
+        end
+      end
+
+      # collect errors on child associations
+      def before_save_child_association(association, context)
+        if association.respond_to?(:valid?)
+          unless association.valid?(context)
+            association.errors.each { |e| self.errors.add(:general, e) }
+          end
+        else
+          self.errors.add(:general, "child association is missing")
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/dm-accepts_nested_attributes/model.rb

@@ -0,0 +1,132 @@
+module DataMapper
+  module NestedAttributes
+    
+    ##
+    # raised by accepts_nested_attributes_for
+    # if the passed options don't make sense
+    class InvalidOptions < ArgumentError; end
+    
+    module Model
+    
+      ##
+      # Allows any association to accept nested attributes.
+      #
+      # @param association_name [Symbol, String]
+      #   The name of the association that should accept nested attributes
+      #
+      # @param options [Hash, nil]
+      #   List of resources to initialize the Collection with
+      #
+      # @option :reject_if [Symbol, String, #call]
+      #   An instance method name or an object that respond_to?(:call), which
+      #   stops a new record from being created, if it evaluates to true.
+      #
+      # @option :allow_destroy [true, false]
+      #   If true, allow destroying the association via the generated writer
+      #   If false, prevent destroying the association via the generated writer
+      #   defaults to false
+      #
+      # @return nil
+      def accepts_nested_attributes_for(association_name, options = {})
+        
+        # ----------------------------------------------------------------------------------
+        #                      try to fail as early as possible
+        # ----------------------------------------------------------------------------------
+      
+        unless relationship = relationships(repository_name)[association_name]
+          raise(ArgumentError, "No relationship #{name.inspect} for #{self.name} in #{repository_name}")
+        end
+
+        # raise InvalidOptions if the given options don't make sense
+        assert_valid_options_for_nested_attributes(options)
+        
+        # by default, nested attributes can't be destroyed
+        options = { :allow_destroy => false }.update(options)
+        
+        # ----------------------------------------------------------------------------------
+        #                       should be safe to go from here
+        # ----------------------------------------------------------------------------------
+        
+        options_for_nested_attributes[relationship] = options
+        
+        include ::DataMapper::NestedAttributes::Resource
+        
+        add_save_behavior
+
+        # TODO i wonder if this is the best place here?
+        # the transactional save behavior is definitely not needed for all resources,
+        # but it's necessary for resources that accept nested attributes
+        # FIXME this leads to weird "no such table" errors when specs are run
+        add_transactional_save_behavior # TODO if repository.adapter.supports_transactions?
+
+        # TODO make this do something
+        # it's only here now to remind me that this is probably the best place to put it
+        add_error_collection_behavior if DataMapper.const_defined?('Validate')
+        
+        type = relationship.max > 1 ? :collection : :resource
+        
+        define_method "#{association_name}_attributes" do
+          instance_variable_get("@#{association_name}_attributes")
+        end
+        
+        define_method "#{association_name}_attributes=" do |attributes|
+          attributes = sanitize_nested_attributes(attributes)
+          instance_variable_set("@#{association_name}_attributes", attributes)
+          send("assign_nested_attributes_for_related_#{type}", relationship, attributes)
+        end
+      
+      end
+      
+      ##
+      # The options given to the accepts_nested_attributes method
+      # They are guaranteed to be valid if they made it this far.
+      #
+      # @return [Hash] The options given to the accepts_nested_attributes method
+      # @see accepts_nested_attributes
+      def options_for_nested_attributes
+        @options_for_nested_attributes ||= {}
+      end
+
+      private
+
+      def add_save_behavior
+        require Pathname(__FILE__).dirname.expand_path + 'save'
+        include ::DataMapper::NestedAttributes::Save
+      end
+
+      def add_transactional_save_behavior
+        require Pathname(__FILE__).dirname.expand_path + 'transactional_save'
+        include ::DataMapper::NestedAttributes::TransactionalSave
+      end
+
+      def add_error_collection_behavior
+        require Pathname(__FILE__).dirname.expand_path + 'error_collecting'
+        include ::DataMapper::NestedAttributes::ValidationErrorCollecting
+      end
+      
+      
+      def assert_valid_options_for_nested_attributes(options)
+        
+        assert_kind_of 'options', options, Hash
+
+        valid_options = [ :allow_destroy, :reject_if ]
+
+        unless options.all? { |k,v| valid_options.include?(k) }
+          raise InvalidOptions, 'options must be one of :allow_destroy or :reject_if'
+        end
+
+        guard = options[:reject_if]
+        if guard.is_a?(Symbol) || guard.is_a?(String)
+          msg = ":reject_if => #{guard.inspect}, but there is no instance method #{guard.inspect} in #{self.name}"
+          raise InvalidOptions, msg unless instance_methods.include?(options[:reject_if].to_s)
+        else
+          msg = ":reject_if must be a Symbol|String or respond_to?(:call) "
+          raise InvalidOptions, msg unless guard.nil? || guard.respond_to?(:call)
+        end
+        
+      end
+  
+    end
+    
+  end
+end

data/lib/dm-accepts_nested_attributes/resource.rb

@@ -1,42 +1,231 @@
 module DataMapper
-  module Resource
-  
-    # basic extract method refactorings to work around a bug in extlib
-    # see http://sick.snusnu.info/2009/04/29/extlibhook-breaks-if-hooked-method-is-redefined/
-    # maybe they are worth considering even when the bug in extlib (hopefully) gets fixed
+  module NestedAttributes
     
-    def save(context = :default)
+    module Resource
       
-      associations_saved = false
-      associations_saved = save_child_associations(associations_saved, context)
-      
-      saved = save_self
-      
-      if saved
-        original_values.clear
+      ##
+      # 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 by overwriting this method.
+      #
+      # @return [Hash] The sanitized attributes
+      def sanitize_nested_attributes(attributes)
+        attributes # noop
       end
       
-      associations_saved = save_parent_associations(associations_saved, context)
+      private
+
+      # 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 resource 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.
+      #
+      # @param relationship [DataMapper::Associations::Relationship]
+      #   The relationship backing the association. 
+      #   Assignment will happen on the target end of the relationship
+      #
+      # @param attributes [Hash]
+      #   The attributes to assign to the relationship's target end
+      #   All attributes except @see UNASSIGNABLE_KEYS will be assigned
+      #
+      # @return nil
+      def assign_nested_attributes_for_related_resource(relationship, attributes)
+        if attributes[:id].blank?
+          return if reject_new_record?(relationship, attributes)
+          new_record = relationship.target_model.new(attributes.except(*UNASSIGNABLE_KEYS))
+          relationship.set(self, new_record)
+        else
+          existing_record = relationship.get(self)
+          if existing_record && existing_record.id.to_s == attributes[:id].to_s
+            assign_to_or_mark_for_destruction(relationship, existing_record, attributes)
+          end
+        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 }
+      # ])
+      #
+      # @param relationship [DataMapper::Associations::Relationship]
+      #   The relationship backing the association. 
+      #   Assignment will happen on the target end of the relationship
+      #
+      # @param attributes [Hash]
+      #   The attributes to assign to the relationship's target end
+      #   All attributes except @see UNASSIGNABLE_KEYS will be assigned
+      #
+      # @return nil
+      def assign_nested_attributes_for_related_collection(relationship, attributes_collection)
       
-      # We should return true if the model (or any of its associations) were saved.
-      (saved | associations_saved) == true
+        normalize_attributes_collection(attributes_collection).each do |attributes|
+          
+          if attributes[:id].blank?
+            next if reject_new_record?(relationship, attributes)
+            relationship.get(self).new(attributes.except(*UNASSIGNABLE_KEYS))
+          else
+            collection = relationship.get(self)
+            if existing_record = collection.detect { |record| record.id.to_s == attributes[:id].to_s }
+              assign_to_or_mark_for_destruction(relationship, existing_record, attributes)
+            end
+          end
+          
+        end
       
-    end
-    
+      end
     
-    def save_child_associations(saved, context)
-      child_associations.each { |a| saved |= a.save }
-      saved
-    end
+      ##
+      # Updates a record with the +attributes+ or marks it for destruction if
+      # +allow_destroy+ is +true+ and has_delete_flag? returns +true+.
+      #
+      # @param relationship [DataMapper::Associations::Relationship]
+      #   The relationship backing the association. 
+      #   Assignment will happen on the target end of the relationship
+      #
+      # @param attributes [Hash]
+      #   The attributes to assign to the relationship's target end
+      #   All attributes except @see UNASSIGNABLE_KEYS will be assigned
+      #
+      # @return nil
+      def assign_to_or_mark_for_destruction(relationship, resource, attributes)
+        allow_destroy = self.class.options_for_nested_attributes[relationship][:allow_destroy]
+        if has_delete_flag?(attributes) && allow_destroy
+          resource.mark_for_destruction
+        else
+          resource.update(attributes.except(*UNASSIGNABLE_KEYS))
+        end
+      end
+
+      ##
+      # Determines if a hash contains a truthy _delete key.
+      #
+      # @param hash [Hash] The hash to test
+      #
+      # @return [Boolean]
+      #   true, if hash containts a truthy _delete key
+      #   false, otherwise
+      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
     
-    def save_self
-      new_record? ? create : update
+      ##
+      # 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+.
+      #
+      # @param relationship [DataMapper::Associations::Relationship]
+      #   The relationship backing the association. 
+      #   Assignment will happen on the target end of the relationship
+      #
+      # @param attributes [Hash]
+      #   The attributes to assign to the relationship's target end
+      #   All attributes except @see UNASSIGNABLE_KEYS will be assigned
+      #
+      # @return [Boolean]
+      #   true, if the given attributes won't be rejected
+      #   false, otherwise
+      def reject_new_record?(relationship, attributes)
+        guard = self.class.options_for_nested_attributes[relationship][:reject_if]
+        return false if guard.nil? # if relationship guard is nil, nothing will be rejected
+        has_delete_flag?(attributes) || evaluate_reject_new_record_guard(guard, attributes)
+      end
+      
+      def evaluate_reject_new_record_guard(guard, attributes)
+        if guard.is_a?(Symbol) || guard.is_a?(String)
+          send(guard)
+        elsif guard.respond_to?(:call)
+          guard.call(attributes)
+        else
+          # never reached when called from inside the plugin
+          raise ArgumentError, "guard must be a Symbol, a String, or respond_to?(:call)"
+        end
+      end
+      
+      def normalize_attributes_collection(attributes_collection)
+        if attributes_collection.is_a?(Hash)
+          attributes_collection.sort_by { |index, _| index.to_i }.map { |_, attributes| attributes }
+        else
+          attributes_collection
+        end
+      end
+      
     end
     
-    def save_parent_associations(saved, context)
-      parent_associations.each { |a| saved |= a.save }
-      saved
+    module CommonResourceSupport
+
+      ##
+      # remove mark for destruction if present
+      # before delegating reload behavior to super
+      #
+      # @return The same value that super returns
+      def reload
+        @marked_for_destruction = false
+        super
+      end
+
+      ##
+      # Test if this resource is marked for destruction
+      #
+      # @return [Boolean]
+      #   true, if this resource is marked for destruction
+      #   false, otherwise
+      def marked_for_destruction?
+        @marked_for_destruction
+      end
+
+      ##
+      # Mark this resource for destruction
+      #
+      # @return true
+      def mark_for_destruction
+        @marked_for_destruction = true
+      end
+
     end
-    
+
   end
-end
+end