sequel 3.3.0 → 3.4.0

data/lib/sequel/extensions/inflector.rb

@@ -80,57 +80,8 @@ class String
       (@uncountables << words).flatten!
     end
 
-    # Setup the default inflections
-    plural(/$/, 's')
-    plural(/s$/i, 's')
-    plural(/(ax|test)is$/i, '\1es')
-    plural(/(octop|vir)us$/i, '\1i')
-    plural(/(alias|status)$/i, '\1es')
-    plural(/(bu)s$/i, '\1ses')
-    plural(/(buffal|tomat)o$/i, '\1oes')
-    plural(/([ti])um$/i, '\1a')
-    plural(/sis$/i, 'ses')
-    plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
-    plural(/(hive)$/i, '\1s')
-    plural(/([^aeiouy]|qu)y$/i, '\1ies')
-    plural(/(x|ch|ss|sh)$/i, '\1es')
-    plural(/(matr|vert|ind)ix|ex$/i, '\1ices')
-    plural(/([m|l])ouse$/i, '\1ice')
-    plural(/^(ox)$/i, '\1en')
-    plural(/(quiz)$/i, '\1zes')
-
-    singular(/s$/i, '')
-    singular(/(n)ews$/i, '\1ews')
-    singular(/([ti])a$/i, '\1um')
-    singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis')
-    singular(/(^analy)ses$/i, '\1sis')
-    singular(/([^f])ves$/i, '\1fe')
-    singular(/(hive)s$/i, '\1')
-    singular(/(tive)s$/i, '\1')
-    singular(/([lr])ves$/i, '\1f')
-    singular(/([^aeiouy]|qu)ies$/i, '\1y')
-    singular(/(s)eries$/i, '\1eries')
-    singular(/(m)ovies$/i, '\1ovie')
-    singular(/(x|ch|ss|sh)es$/i, '\1')
-    singular(/([m|l])ice$/i, '\1ouse')
-    singular(/(bus)es$/i, '\1')
-    singular(/(o)es$/i, '\1')
-    singular(/(shoe)s$/i, '\1')
-    singular(/(cris|ax|test)es$/i, '\1is')
-    singular(/(octop|vir)i$/i, '\1us')
-    singular(/(alias|status)es$/i, '\1')
-    singular(/^(ox)en/i, '\1')
-    singular(/(vert|ind)ices$/i, '\1ex')
-    singular(/(matr)ices$/i, '\1ix')
-    singular(/(quiz)zes$/i, '\1')
-
-    irregular('person', 'people')
-    irregular('man', 'men')
-    irregular('child', 'children')
-    irregular('sex', 'sexes')
-    irregular('move', 'moves')
-
-    uncountable(%w(equipment information rice money species series fish sheep))
+    Sequel.require('default_inflections', 'model')
+    instance_eval(&Sequel::DEFAULT_INFLECTIONS_PROC)
   end
 
   # Yield the Inflections module if a block is given, and return

data/lib/sequel/model.rb

@@ -17,7 +17,13 @@ module Sequel
   #     table_name # => :something
   #   end
   def self.Model(source)
-    Model::ANONYMOUS_MODEL_CLASSES[source] ||= Class.new(Model).set_dataset(source)
+    Model::ANONYMOUS_MODEL_CLASSES[source] ||= if source.is_a?(Database)
+      c = Class.new(Model)
+      c.db = source
+      c
+    else
+      Class.new(Model).set_dataset(source)
+    end
   end
 
   # Sequel::Model is an object relational mapper built on top of Sequel core.  Each
@@ -38,15 +44,15 @@ module Sequel
     ANONYMOUS_MODEL_CLASSES = {}
 
     # Class methods added to model that call the method of the same name on the dataset
-    DATASET_METHODS = %w'<< all avg count delete distinct eager eager_graph
-       each each_page empty? except exclude filter first from from_self
+    DATASET_METHODS = %w'<< add_graph_aliases all avg count delete distinct
+       each each_page eager eager_graph empty? except exclude filter first from from_self
        full_outer_join get graph grep group group_and_count group_by having import
-       inner_join insert insert_multiple intersect interval join join_table
-       last left_outer_join limit map multi_insert naked order order_by
-       order_more paginate print qualify query range reverse_order right_outer_join
-       select select_all select_more server set set_graph_aliases 
-       single_value to_csv to_hash union unfiltered unordered 
-       update where with with_sql'.map{|x| x.to_sym}
+       inner_join insert insert_multiple intersect interval invert join join_table
+       last left_outer_join limit map max min multi_insert naked order order_by
+       order_more paginate print qualify query range reverse reverse_order right_outer_join
+       select select_all select_more server set set_defaults set_graph_aliases set_overrides
+       single_value sum to_csv to_hash truncate unfiltered ungraphed ungrouped union unlimited unordered 
+       update where with with_recursive with_sql'.map{|x| x.to_sym}
   
     # Class instance variables to set to nil when a subclass is created, for -w compliance
     EMPTY_INSTANCE_VARIABLES = [:@overridable_methods_module, :@db]
@@ -102,7 +108,7 @@ module Sequel
     @use_transactions = true
   end
 
-  require %w"inflections plugins base exceptions errors", "model"
+  require %w"default_inflections inflections plugins base exceptions errors", "model"
   if !defined?(::SEQUEL_NO_ASSOCIATIONS) && !ENV.has_key?('SEQUEL_NO_ASSOCIATIONS')
     require 'associations', 'model'
     Model.plugin Model::Associations

data/lib/sequel/model/associations.rb

@@ -882,7 +882,10 @@ module Sequel
         # Add the given associated object to the given association
         def add_associated_object(opts, o, *args)
           raise(Sequel::Error, "model object #{model} does not have a primary key") unless pk
-          raise(Sequel::Error, "associated object #{o.model} does not have a primary key") if opts.need_associated_primary_key? && !o.pk
+          if opts.need_associated_primary_key?
+            o.save if o.new?
+            raise(Sequel::Error, "associated object #{o.model} does not have a primary key") unless o.pk
+          end
           return if run_association_callbacks(opts, :before_add, o) == false
           send(opts._add_method, o, *args)
           associations[opts[:name]].push(o) if associations.include?(opts[:name])

data/lib/sequel/model/base.rb

@@ -184,10 +184,10 @@ module Sequel
         unless ivs.include?("@dataset")
           db
           begin
-            if self == Model
+            if self == Model || !@dataset
               subclass.set_dataset(subclass.implicit_table_name) unless subclass.name.empty?
-            elsif ds = instance_variable_get(:@dataset)
-              subclass.set_dataset(ds.clone, :inherited=>true)
+            elsif @dataset
+              subclass.set_dataset(@dataset.clone, :inherited=>true)
             end
           rescue
             nil
@@ -260,6 +260,7 @@ module Sequel
       # If a dataset is used, the model's database is changed to the given
       # dataset.  If a symbol is used, a dataset is created from the current
       # database with the table name given. Other arguments raise an Error.
+      # Returns self.
       #
       # This changes the row_proc of the given dataset to return
       # model objects, extends the dataset with the dataset_method_modules,
@@ -652,6 +653,12 @@ module Sequel
       def keys
         @values.keys
       end
+      
+      # Whether this object has been modified since last saved, used by
+      # save_changes to determine whether changes should be saved
+      def modified?
+        !changed_columns.empty?
+      end
   
       # Returns true if the current instance represents a new record.
       def new?
@@ -705,11 +712,11 @@ module Sequel
         use_transaction ? db.transaction(opts){_save(columns, opts)} : _save(columns, opts)
       end
 
-      # Saves only changed columns or does nothing if no columns are marked as 
-      # chanaged.  If no columns have been changed, returns nil.  If unable to
+      # Saves only changed columns if the object has been modified.
+      # If the object has not been modified, returns nil.  If unable to
       # save, returns false unless raise_on_save_failure is true.
       def save_changes
-        save(:changed=>true) || false unless changed_columns.empty?
+        save(:changed=>true) || false if modified? 
       end
   
       # Updates the instance with the supplied values with support for virtual

data/lib/sequel/model/default_inflections.rb

@@ -0,0 +1,46 @@
+module Sequel
+  # Proc that is instance evaled to create the default inflections for both the
+  # model inflector and the inflector extension.
+  DEFAULT_INFLECTIONS_PROC = lambda do
+    plural(/$/, 's')
+    plural(/s$/i, 's')
+    plural(/(alias|(?:stat|octop|vir|b)us)$/i, '\1es')
+    plural(/(buffal|tomat)o$/i, '\1oes')
+    plural(/([ti])um$/i, '\1a')
+    plural(/sis$/i, 'ses')
+    plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+    plural(/(hive)$/i, '\1s')
+    plural(/([^aeiouy]|qu)y$/i, '\1ies')
+    plural(/(x|ch|ss|sh)$/i, '\1es')
+    plural(/(matr|vert|ind)ix|ex$/i, '\1ices')
+    plural(/([m|l])ouse$/i, '\1ice')
+
+    singular(/s$/i, '')
+    singular(/([ti])a$/i, '\1um')
+    singular(/(analy|ba|cri|diagno|parenthe|progno|synop|the)ses$/i, '\1sis')
+    singular(/([^f])ves$/i, '\1fe')
+    singular(/([h|t]ive)s$/i, '\1')
+    singular(/([lr])ves$/i, '\1f')
+    singular(/([^aeiouy]|qu)ies$/i, '\1y')
+    singular(/(m)ovies$/i, '\1ovie')
+    singular(/(x|ch|ss|sh)es$/i, '\1')
+    singular(/([m|l])ice$/i, '\1ouse')
+    singular(/buses$/i, 'bus')
+    singular(/oes$/i, 'o')
+    singular(/shoes$/i, 'shoe')
+    singular(/(alias|(?:stat|octop|vir|b)us)es$/i, '\1')
+    singular(/(vert|ind)ices$/i, '\1ex')
+    singular(/matrices$/i, 'matrix')
+
+    irregular('person', 'people')
+    irregular('man', 'men')
+    irregular('child', 'children')
+    irregular('sex', 'sexes')
+    irregular('move', 'moves')
+    irregular('ox', 'oxen')
+    irregular('quiz', 'quizzes')
+    irregular('testis', 'testes')
+
+    uncountable(%w(equipment information rice money species series fish sheep news))
+  end
+end

data/lib/sequel/model/inflections.rb

@@ -96,57 +96,7 @@ module Sequel
       (@uncountables << words).flatten!
     end
 
-    # Setup the default inflections
-    plural(/$/, 's')
-    plural(/s$/i, 's')
-    plural(/(ax|test)is$/i, '\1es')
-    plural(/(octop|vir)us$/i, '\1i')
-    plural(/(alias|status)$/i, '\1es')
-    plural(/(bu)s$/i, '\1ses')
-    plural(/(buffal|tomat)o$/i, '\1oes')
-    plural(/([ti])um$/i, '\1a')
-    plural(/sis$/i, 'ses')
-    plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
-    plural(/(hive)$/i, '\1s')
-    plural(/([^aeiouy]|qu)y$/i, '\1ies')
-    plural(/(x|ch|ss|sh)$/i, '\1es')
-    plural(/(matr|vert|ind)ix|ex$/i, '\1ices')
-    plural(/([m|l])ouse$/i, '\1ice')
-    plural(/^(ox)$/i, '\1en')
-    plural(/(quiz)$/i, '\1zes')
-
-    singular(/s$/i, '')
-    singular(/(n)ews$/i, '\1ews')
-    singular(/([ti])a$/i, '\1um')
-    singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis')
-    singular(/(^analy)ses$/i, '\1sis')
-    singular(/([^f])ves$/i, '\1fe')
-    singular(/(hive)s$/i, '\1')
-    singular(/(tive)s$/i, '\1')
-    singular(/([lr])ves$/i, '\1f')
-    singular(/([^aeiouy]|qu)ies$/i, '\1y')
-    singular(/(s)eries$/i, '\1eries')
-    singular(/(m)ovies$/i, '\1ovie')
-    singular(/(x|ch|ss|sh)es$/i, '\1')
-    singular(/([m|l])ice$/i, '\1ouse')
-    singular(/(bus)es$/i, '\1')
-    singular(/(o)es$/i, '\1')
-    singular(/(shoe)s$/i, '\1')
-    singular(/(cris|ax|test)es$/i, '\1is')
-    singular(/(octop|vir)i$/i, '\1us')
-    singular(/(alias|status)es$/i, '\1')
-    singular(/^(ox)en/i, '\1')
-    singular(/(vert|ind)ices$/i, '\1ex')
-    singular(/(matr)ices$/i, '\1ix')
-    singular(/(quiz)zes$/i, '\1')
-
-    irregular('person', 'people')
-    irregular('man', 'men')
-    irregular('child', 'children')
-    irregular('sex', 'sexes')
-    irregular('move', 'moves')
-
-    uncountable(%w(equipment information rice money species series fish sheep))
+    instance_eval(&DEFAULT_INFLECTIONS_PROC)
 
     private
 

data/lib/sequel/plugins/boolean_readers.rb

@@ -0,0 +1,52 @@
+module Sequel
+  module Plugins
+    # The BooleaReaders plugin allows for the creation of attribute? methods
+    # for boolean columns, which provide a nicer API.  By default, the accessors
+    # are created for all columns of type :boolean.  However, you can provide a
+    # block to the plugin to change the criteria used to determine if a
+    # column is boolean:
+    #
+    #   Sequel::Model.plugin(:boolean_readers){|c| db_schema[c][:db_type] =~ /\Atinyint/}
+    #
+    # This may be useful if you are using MySQL and have some tinyint columns
+    # that represent booleans and others that represent integers.  You can turn
+    # the convert_tinyint_to_bool setting off and use the attribute methods for
+    # the integer value and the attribute? methods for the boolean value.
+    module BooleanReaders
+      # Default proc for determining if given column is a boolean, which
+      # just checks that the :type is boolean.
+      DEFAULT_BOOLEAN_ATTRIBUTE_PROC = lambda{|c| db_schema[c][:type] == :boolean}
+
+      # Add the boolean_attribute? class method to the model, and create
+      # attribute? boolean reader methods for the class's columns if the class has a dataset.
+      def self.configure(model, &block)
+        model.meta_def(:boolean_attribute?, &(block || DEFAULT_BOOLEAN_ATTRIBUTE_PROC))
+        model.instance_eval{send(:create_boolean_readers) if @dataset}
+      end
+
+      module ClassMethods
+        # Create boolean readers for the class using the columns from the new dataset.
+        def set_dataset(*args)
+          super
+          create_boolean_readers
+          self
+        end
+
+        private
+
+        # Add a attribute? method for the column to a module included in the class.
+        def create_boolean_reader(column)
+          overridable_methods_module.module_eval do
+            define_method("#{column}?"){model.db.typecast_value(:boolean, send(column))}
+          end
+        end
+
+        # Add attribute? methods for all of the boolean attributes for this model.
+        def create_boolean_readers
+          im = instance_methods.collect{|x| x.to_s}
+          columns.each{|c| create_boolean_reader(c) if boolean_attribute?(c) && !im.include?("#{c}?")}
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/instance_hooks.rb

@@ -0,0 +1,57 @@
+module Sequel
+  module Plugins
+    # The instance_hooks plugin allows you to add hooks to specific instances,
+    # by passing a block to a _hook method (e.g. before_save_hook{do_something}).
+    # The block executed when the hook is called (e.g. before_save).
+    #
+    # All of the standard hooks are supported, except for after_initialize.
+    # Instance level before hooks are executed in reverse order of addition before
+    # calling super.  Instance level after hooks are executed in order of addition
+    # after calling super.  If any of the instance level before hook blocks return
+    # false, no more instance level before hooks are called and false is returned.
+    #
+    # Instance level hooks are cleared when the object is saved successfully.
+    module InstanceHooks
+      module InstanceMethods 
+        HOOKS = Sequel::Model::HOOKS - [:after_initialize]
+        HOOKS.each{|h| class_eval("def #{h}_hook(&block); add_instance_hook(:#{h}, &block) end", __FILE__, __LINE__)}
+        
+        BEFORE_HOOKS, AFTER_HOOKS = HOOKS.partition{|hook| hook.to_s =~ /\Abefore_/}
+        BEFORE_HOOKS.each{|h| class_eval("def #{h}; run_instance_hooks(:#{h}) == false ? false : super end", __FILE__, __LINE__)}
+        AFTER_HOOKS.each{|h| class_eval("def #{h}; super; run_instance_hooks(:#{h}) end", __FILE__, __LINE__)}
+        
+        # Clear the instance level hooks after saving the object.
+        def after_save
+          super
+          run_instance_hooks(:after_save)
+          @instance_hooks.clear if @instance_hooks
+        end
+        
+        private
+        
+        # Add the block as an instance level hook.  For before hooks, add it to
+        # the beginning of the instance hook's array.  For after hooks, add it
+        # to the end.
+        def add_instance_hook(hook, &block)
+          instance_hooks(hook).send(BEFORE_HOOKS.include?(hook) ? :unshift : :push, block)
+        end
+        
+        # An array of instance level hook blocks for the given hook type.
+        def instance_hooks(hook)
+          @instance_hooks ||= {}
+          @instance_hooks[hook] ||= []
+        end
+        
+        # Run all hook blocks of the given hook type.  If a before hook,
+        # immediately return false if any hook block call returns false.
+        def run_instance_hooks(hook)
+          if BEFORE_HOOKS.include?(hook)
+            instance_hooks(hook).each{|b| return false if b.call == false}
+          else
+            instance_hooks(hook).each{|b| b.call}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/lazy_attributes.rb

@@ -29,12 +29,24 @@ module Sequel
       end
       
       module ClassMethods
+        # Module to store the lazy attribute getter methods, so they can
+        # be overridden and call super to get the lazy attribute behavior
+        attr_accessor :lazy_attributes_module
+
         # Remove the given attributes from the list of columns selected by default.
         # For each attribute given, create an accessor method that allows a lazy
         # lookup of the attribute.  Each attribute should be given as a symbol.
         def lazy_attributes(*attrs)
           set_dataset(dataset.select(*(columns - attrs)))
-          attrs.each do |a|
+          attrs.each{|a| define_lazy_attribute_getter(a)}
+        end
+        
+        private
+
+        # Add a lazy attribute getter method to the lazy_attributes_module
+        def define_lazy_attribute_getter(a)
+          include(self.lazy_attributes_module ||= Module.new) unless lazy_attributes_module
+          lazy_attributes_module.class_eval do
             define_method(a) do
               if !values.include?(a) && !new?
                 lazy_attribute_lookup(a)

data/lib/sequel/plugins/nested_attributes.rb

@@ -0,0 +1,171 @@
+module Sequel
+  module Plugins
+    # The nested_attributes plugin allows you to update attributes for associated
+    # objects directly through the parent object, similar to ActiveRecord's
+    # Nested Attributes feature.
+    #
+    # Nested attributes are created using the nested_attributes method:
+    #
+    #   Artist.one_to_many :albums
+    #   Artist.nested_attributes :albums
+    #   a = Artist.new(:name=>'YJM',
+    #    :albums_attributes=>[{:name=>'RF'}, {:name=>'MO'}])
+    #   # No database activity yet
+    #
+    #   a.save # Saves artist and both albums
+    #   a.albums.map{|x| x.name} # ['RF', 'MO']
+    module NestedAttributes
+      # Depend on the instance_hooks plugin.
+      def self.apply(model)
+        model.plugin(:instance_hooks)
+      end
+      
+      module ClassMethods
+        # Module to store the nested_attributes setter methods, so they can
+        # call be overridden and call super to get the default behavior
+        attr_accessor :nested_attributes_module
+        
+        # Allow nested attributes to be set for the given associations.  Options:
+        # * :destroy - Allow destruction of nested records.
+        # * :limit - For *_to_many associations, a limit on the number of records
+        #   that will be processed, to prevent denial of service attacks.
+        # * :remove - Allow disassociation of nested records (can remove the associated
+        #   object from the parent object, but not destroy the associated object).
+        # * :strict - Set to false to not raise an error message if a primary key
+        #   is provided in a record, but it doesn't match an existing associated
+        #   object.
+        #
+        # If a block is provided, it is passed each nested attribute hash.  If
+        # the hash should be ignored, the block should return anything except false or nil.
+        def nested_attributes(*associations, &block)
+          include(self.nested_attributes_module ||= Module.new) unless nested_attributes_module
+          opts = associations.last.is_a?(Hash) ? associations.pop : {}
+          reflections = associations.map{|a| association_reflection(a) || raise(Error, "no association named #{a} for #{self}")}
+          reflections.each do |r|
+            r[:nested_attributes] = opts
+            r[:nested_attributes][:reject_if] ||= block
+            def_nested_attribute_method(r)
+          end
+        end
+        
+        private
+        
+        # Add a nested attribute setter method to a module included in the
+        # class.
+        def def_nested_attribute_method(reflection)
+          nested_attributes_module.class_eval do
+            if reflection.returns_array?
+              define_method("#{reflection[:name]}_attributes=") do |array|
+                nested_attributes_list_setter(reflection, array)
+              end
+            else
+             define_method("#{reflection[:name]}_attributes=") do |h|
+                nested_attributes_setter(reflection, h)
+              end
+            end
+          end
+        end
+      end
+      
+      module InstanceMethods
+        # Assume if an instance has nested attributes set on it, that it has
+        # been modified even if none of the instance's columns have been modified.
+        def modified?
+          super || @has_nested_attributes
+        end
+        
+        private
+        
+        # Create a new associated object with the given attributes, validate
+        # it when the parent is validated, and save it when the object is saved.
+        def nested_attributes_create(reflection, attributes)
+          obj = reflection.associated_class.new(attributes)
+          after_validation_hook{validate_associated_object(reflection, obj)}
+          if reflection.returns_array?
+            after_save_hook{send(reflection.add_method, obj)}
+          else
+            before_save_hook{send(reflection.setter_method, obj.save)}
+          end
+        end
+        
+        # Find an associated object with the matching pk.  If a matching option
+        # is not found and the :strict option is not false, raise an Error.
+        def nested_attributes_find(reflection, pk)
+          pk = pk.to_s
+          unless obj = Array(associated_objects = send(reflection[:name])).find{|x| x.pk.to_s == pk}
+            raise(Error, 'no associated object with that primary key does not exist') unless reflection[:nested_attributes][:strict] == false
+          end
+          obj
+        end
+        
+        # Take an array or hash of attribute hashes and set each one individually.
+        # If a hash is provided it, sort it by key and then use the values.
+        # If there is a limit on the nested attributes for this association,
+        # make sure the length of the attributes_list is not greater than the limit.
+        def nested_attributes_list_setter(reflection, attributes_list)
+          attributes_list = attributes_list.sort_by{|x| x.to_s}.map{|k,v| v} if attributes_list.is_a?(Hash)
+          if (limit = reflection[:nested_attributes][:limit]) && attributes_list.length > limit
+            raise(Error, "number of nested attributes (#{attributes_list.length}) exceeds the limit (#{limit})")
+          end
+          attributes_list.each{|a| nested_attributes_setter(reflection, a)}
+        end
+        
+        # Remove the matching associated object from the current object.
+        # If the :destroy option is given, destroy the object after disassociating it.
+        def nested_attributes_remove(reflection, pk, opts={})
+          if obj = nested_attributes_find(reflection, pk)
+            before_save_hook do
+              if reflection.returns_array?
+                send(reflection.remove_method, obj)
+              else
+                send(reflection.setter_method, nil)
+              end
+            end
+            after_save_hook{obj.destroy} if opts[:destroy]
+          end
+        end
+        
+        # Modify the associated object based on the contents of the attribtues hash:
+        # * If a block was given to nested_attributes, call it with the attributes and return immediately if the block returns true.
+        # * If no primary key exists in the attributes hash, create a new object.
+        # * If _delete is a key in the hash and the :destroy option is used, destroy the matching associated object.
+        # * If _remove is a key in the hash and the :remove option is used, disassociated the matching associated object.
+        # * Otherwise, update the matching associated object with the contents of the hash.
+        def nested_attributes_setter(reflection, attributes)
+          return if (b = reflection[:nested_attributes][:reject_if]) && b.call(attributes)
+          @has_nested_attributes = true
+          klass = reflection.associated_class
+          if pk = attributes.delete(klass.primary_key) || attributes.delete(klass.primary_key.to_s)
+            if klass.db.send(:typecast_value_boolean, attributes[:_delete] || attributes['_delete']) && reflection[:nested_attributes][:destroy]
+              nested_attributes_remove(reflection, pk, :destroy=>true)
+            elsif klass.db.send(:typecast_value_boolean, attributes[:_remove] || attributes['_remove']) && reflection[:nested_attributes][:remove]
+              nested_attributes_remove(reflection, pk)
+            else
+              nested_attributes_update(reflection, pk, attributes)
+            end
+          else
+            nested_attributes_create(reflection, attributes)
+          end
+        end
+        
+        # Update the matching associated object with the attributes,
+        # validating it when the parent object is validated and saving it
+        # when the parent is saved.
+        def nested_attributes_update(reflection, pk, attributes)
+          if obj = nested_attributes_find(reflection, pk)
+            obj.set(attributes)
+            after_validation_hook{validate_associated_object(reflection, obj)}
+            after_save_hook{obj.save}
+          end
+        end
+        
+        # Validate the given associated object, adding any validation error messages from the
+        # given object to the parent object.
+        def validate_associated_object(reflection, obj)
+          association = reflection[:name]
+          obj.errors.full_messages.each{|m| errors.add(association, m)} unless obj.valid?
+        end
+      end
+    end
+  end
+end