viking-sequel 3.10.0

data/lib/sequel/plugins/instance_filters.rb

@@ -0,0 +1,98 @@
+module Sequel
+  module Plugins
+    # This plugin allows you to add filters on a per object basis that
+    # restrict updating or deleting the object.  It's designed for cases
+    # where you would normally have to drop down to the dataset level
+    # to get the necessary control, because you only want to delete or
+    # update the rows in certain cases based on the current status of
+    # the row in the database.
+    # 
+    #   class Item < Sequel::Model
+    #     plugin :instance_filters
+    #   end
+    #
+    #   # These are two separate objects that represent the same
+    #   # database row. 
+    #   i1 = Item.first(:id=>1, :delete_allowed=>false)
+    #   i2 = Item.first(:id=>1, :delete_allowed=>false)
+    #
+    #   # Add an instance filter to the object. This filter is in effect
+    #   # until the object is successfully updated or deleted.
+    #   i1.instance_filter(:delete_allowed=>true)
+    #
+    #   # Attempting to delete the object where the filter doesn't
+    #   # match any rows raises an error.
+    #   i1.delete # raises Sequel::Error
+    #
+    #   # The other object that represents the same row has no
+    #   # instance filters, and can be updated normally.
+    #   i2.update(:delete_allowed=>true)
+    #
+    #   # Even though the filter is now still in effect, since the
+    #   # database row has been updated to allow deleting,
+    #   # delete now works.
+    #   i1.delete
+    #
+    # This plugin sets the require_modification flag on the model,
+    # so if the model's dataset doesn't provide an accurate number
+    # of matched rows, this could result in invalid exceptions being raised.
+    module InstanceFilters
+      # Exception class raised when updating or deleting an object does
+      # not affect exactly one row.
+      Error = Sequel::NoExistingObject
+      
+      # Set the require_modification flag to true for the model.
+      def self.configure(model)
+        model.require_modification = true
+      end
+
+      module InstanceMethods
+        # Clear the instance filters after successfully destroying the object.
+        def after_destroy
+          super
+          clear_instance_filters
+        end
+        
+        # Clear the instance filters after successfully updating the object.
+        def after_update
+          super
+          clear_instance_filters
+        end
+      
+        # Add an instance filter to the array of instance filters
+        # Both the arguments given and the block are passed to the
+        # dataset's filter method.
+        def instance_filter(*args, &block)
+          instance_filters << [args, block]
+        end
+      
+        private
+        
+        # Lazily initialize the instance filter array.
+        def instance_filters
+          @instance_filters ||= []
+        end
+        
+        # Apply the instance filters to the given dataset
+        def apply_instance_filters(ds)
+          instance_filters.inject(ds){|ds, i| ds.filter(*i[0], &i[1])}
+        end
+        
+        # Clear the instance filters.
+        def clear_instance_filters
+          instance_filters.clear
+        end
+        
+        # Apply the instance filters to the dataset returned by super.
+        def _delete_dataset
+          apply_instance_filters(super)
+        end
+        
+        # Apply the instance filters to the dataset returned by super.
+        def _update_dataset
+          apply_instance_filters(super)
+        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

@@ -0,0 +1,77 @@
+module Sequel
+  module Plugins
+    # The lazy_attributes plugin allows users to easily set that some attributes
+    # should not be loaded by default when loading model objects.  If the attribute
+    # is needed after the instance has been retrieved, a database query is made to
+    # retreive the value of the attribute.
+    #
+    # This plugin depends on the identity_map and tactical_eager_loading plugin, and allows you to
+    # eagerly load lazy attributes for all objects retrieved with the current object.
+    # So the following code should issue one query to get the albums and one query to
+    # get the reviews for all of those albums:
+    #
+    #   Album.plugin :lazy_attributes, :review
+    #   Sequel::Model.with_identity_map do
+    #     Album.filter{id<100}.all do |a|
+    #       a.review
+    #     end
+    #   end
+    module LazyAttributes
+      # Lazy attributes requires the identity map and tactical eager loading plugins
+      def self.apply(model, *attrs)
+        model.plugin :identity_map
+        model.plugin :tactical_eager_loading  
+      end
+      
+      # Set the attributes given as lazy attributes
+      def self.configure(model, *attrs)
+        model.lazy_attributes(*attrs) unless attrs.empty?
+      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{|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)
+              else
+                super()
+              end
+            end
+          end
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # If the model was selected with other model objects, eagerly load the
+        # attribute for all of those objects.  If not, query the database for
+        # the attribute for just the current object.  Return the value of
+        # the attribute for the current object.
+        def lazy_attribute_lookup(a)
+          primary_key = model.primary_key
+          model.select(*(Array(primary_key) + [a])).filter(primary_key=>retrieved_with.map{|o| o.pk}.sql_array).all if model.identity_map && retrieved_with
+          values[a] = this.select(a).first[a] unless values.include?(a)
+          values[a]
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/many_through_many.rb

@@ -0,0 +1,208 @@
+module Sequel
+  module Plugins
+    # The many_through_many plugin allow you to create a association to multiple objects using multiple join tables.
+    # For example, assume the following associations:
+    #
+    #    Artist.many_to_many :albums
+    #    Album.many_to_many :tags
+    #
+    # The many_through_many plugin would allow this:
+    #
+    #    Artist.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    #
+    # Which will give you the tags for all of the artist's albums.
+    #
+    # Here are some more examples:
+    #
+    #   # Same as Artist.many_to_many :albums
+    #   Artist.many_through_many :albums, [[:albums_artists, :artist_id, :album_id]]
+    #
+    #   # All artists that are associated to any album that this artist is associated to
+    #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_artists, :album_id, :artist_id]]
+    #
+    #   # All albums by artists that are associated to any album that this artist is associated to
+    #   Artist.many_through_many :artist_albums, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], \
+    #    [:albums_artists, :album_id, :artist_id], [:artists, :id, :id], [:albums_artists, :artist_id, :album_id]], \
+    #    :class=>:Album
+    #
+    #   # All tracks on albums by this artist
+    #   Artist.many_through_many :tracks, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id]], \
+    #    :right_primary_key=>:album_id
+    module ManyThroughMany
+      # The AssociationReflection subclass for many_through_many associations.
+      class ManyThroughManyAssociationReflection < Sequel::Model::Associations::ManyToManyAssociationReflection
+        Sequel::Model::Associations::ASSOCIATION_TYPES[:many_through_many] = self
+
+        # The table containing the column to use for the associated key when eagerly loading
+        def associated_key_table
+          self[:associated_key_table] = self[:final_reverse_edge][:alias]
+        end
+        
+        # The default associated key alias(es) to use when eager loading
+        # associations via eager.
+        def default_associated_key_alias
+          self[:uses_left_composite_keys] ? (0...self[:through].first[:left].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x
+        end
+
+        # The list of joins to use when eager graphing
+        def edges
+          self[:edges] || calculate_edges || self[:edges]
+        end
+
+        # Many through many associations don't have a reciprocal
+        def reciprocal
+          nil
+        end
+
+        # The list of joins to use when lazy loading or eager loading
+        def reverse_edges
+          self[:reverse_edges] || calculate_edges || self[:reverse_edges]
+        end
+
+        private
+
+        # Make sure to use unique table aliases when lazy loading or eager loading
+        def calculate_reverse_edge_aliases(reverse_edges)
+          aliases = [associated_class.table_name]
+          reverse_edges.each do |e|
+            table_alias = e[:table]
+            if aliases.include?(table_alias)
+              i = 0
+              table_alias = loop do
+                ta = :"#{table_alias}_#{i}"
+                break ta unless aliases.include?(ta)
+                i += 1
+              end
+            end
+            aliases.push(e[:alias] = table_alias)
+          end
+        end
+
+        # Transform the :through option into a list of edges and reverse edges to use to join tables when loading the association.
+        def calculate_edges
+          es = [{:left_table=>self[:model].table_name, :left_key=>self[:left_primary_key]}]
+          self[:through].each do |t|
+            es.last.merge!(:right_key=>t[:left], :right_table=>t[:table], :join_type=>t[:join_type]||self[:graph_join_type], :conditions=>(t[:conditions]||[]).to_a, :block=>t[:block])
+            es.last[:only_conditions] = t[:only_conditions] if t.include?(:only_conditions)
+            es << {:left_table=>t[:table], :left_key=>t[:right]}
+          end
+          es.last.merge!(:right_key=>right_primary_key, :right_table=>associated_class.table_name)
+          edges = es.map do |e| 
+            h = {:table=>e[:right_table], :left=>e[:left_key], :right=>e[:right_key], :conditions=>e[:conditions], :join_type=>e[:join_type], :block=>e[:block]}
+            h[:only_conditions] = e[:only_conditions] if e.include?(:only_conditions)
+            h
+          end
+          reverse_edges = es.reverse.map{|e| {:table=>e[:left_table], :left=>e[:left_key], :right=>e[:right_key]}}
+          reverse_edges.pop
+          calculate_reverse_edge_aliases(reverse_edges)
+          self[:final_edge] = edges.pop
+          self[:final_reverse_edge] = reverse_edges.pop
+          self[:edges] = edges
+          self[:reverse_edges] = reverse_edges
+          nil
+        end
+      end
+      module ClassMethods
+        # Create a many_through_many association.  Arguments:
+        # * name - Same as associate, the name of the association.
+        # * through - The tables and keys to join between the current table and the associated table.
+        #   Must be an array, with elements that are either 3 element arrays, or hashes with keys :table, :left, and :right.
+        #   The required entries in the array/hash are:
+        #   * :table (first array element) - The name of the table to join.
+        #   * :left (middle array element) - The key joining the table to the previous table. Can use an
+        #     array of symbols for a composite key association.
+        #   * :right (last array element) - The key joining the table to the next table. Can use an
+        #     array of symbols for a composite key association.
+        #   If a hash is provided, the following keys are respected when using eager_graph:
+        #   * :block - A proc to use as the block argument to join.
+        #   * :conditions - Extra conditions to add to the JOIN ON clause.  Must be a hash or array of two pairs.
+        #   * :join_type - The join type to use for the join, defaults to :left_outer.
+        #   * :only_conditions - Conditions to use for the join instead of the ones specified by the keys.
+        # * opts - The options for the associaion.  Takes the same options as associate, and supports these additional options:
+        #   * :left_primary_key - column in current table that the first :left option in
+        #     through points to, as a symbol. Defaults to primary key of current table. Can use an
+        #     array of symbols for a composite key association.
+        #   * :right_primary_key - column in associated table that the final :right option in 
+        #     through points to, as a symbol. Defaults to primary key of the associated table.  Can use an
+        #     array of symbols for a composite key association.
+        #   * :uniq - Adds a after_load callback that makes the array of objects unique.
+        def many_through_many(name, through, opts={}, &block)
+          associate(:many_through_many, name, opts.merge(:through=>through), &block)
+        end 
+
+        private
+
+        # Create the association methods and :eager_loader and :eager_grapher procs.
+        def def_many_through_many(opts)
+          name = opts[:name]
+          model = self
+          opts[:read_only] = true
+          opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
+          opts[:cartesian_product_number] ||= 2
+          opts[:through] = opts[:through].map do |e|
+            case e
+            when Array
+              raise(Error, "array elements of the through option/argument for many_through_many associations must have at least three elements") unless e.length == 3
+              {:table=>e[0], :left=>e[1], :right=>e[2]}
+            when Hash
+              raise(Error, "hash elements of the through option/argument for many_through_many associations must contain :table, :left, and :right keys") unless e[:table] && e[:left] && e[:right]
+              e
+            else
+              raise(Error, "the through option/argument for many_through_many associations must be an enumerable of arrays or hashes")
+            end
+          end
+
+          left_key = opts[:left_key] = opts[:through].first[:left]
+          uses_lcks = opts[:uses_left_composite_keys] = left_key.is_a?(Array)
+          left_keys = Array(left_key)
+          left_pk = (opts[:left_primary_key] ||= self.primary_key)
+          left_pks = opts[:left_primary_keys] = Array(left_pk)
+          opts[:dataset] ||= lambda do
+            ds = opts.associated_class
+            opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
+            ft = opts[:final_reverse_edge]
+            ds.join(ft[:table],  Array(ft[:left]).zip(Array(ft[:right])) + left_keys.zip(left_pks.map{|k| send(k)}), :table_alias=>ft[:alias])
+          end
+
+          left_key_alias = opts[:left_key_alias] ||= opts.default_associated_key_alias
+          opts[:eager_loader] ||= lambda do |key_hash, records, associations|
+            h = key_hash[left_pk]
+            records.each{|object| object.associations[name] = []}
+            ds = opts.associated_class 
+            opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
+            ft = opts[:final_reverse_edge]
+            conds = uses_lcks ? [[left_keys.map{|k| SQL::QualifiedIdentifier.new(ft[:table], k)}, SQL::SQLArray.new(h.keys)]] : [[left_key, h.keys]]
+            ds = ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + conds, :table_alias=>ft[:alias])
+            model.eager_loading_dataset(opts, ds, Array(opts.select), associations).all do |assoc_record|
+              hash_key = if uses_lcks
+                left_key_alias.map{|k| assoc_record.values.delete(k)}
+              else
+                assoc_record.values.delete(left_key_alias)
+              end
+              next unless objects = h[hash_key]
+              objects.each{|object| object.associations[name].push(assoc_record)}
+            end
+          end
+
+          join_type = opts[:graph_join_type]
+          select = opts[:graph_select]
+          graph_block = opts[:graph_block]
+          only_conditions = opts[:graph_only_conditions]
+          use_only_conditions = opts.include?(:graph_only_conditions)
+          conditions = opts[:graph_conditions]
+          opts[:eager_grapher] ||= proc do |ds, assoc_alias, table_alias|
+            iq = table_alias
+            opts.edges.each do |t|
+              ds = ds.graph(t[:table], t.fetch(:only_conditions, (Array(t[:right]).zip(Array(t[:left])) + t[:conditions])), :select=>false, :table_alias=>ds.unused_table_alias(t[:table]), :join_type=>t[:join_type], :implicit_qualifier=>iq, &t[:block])
+              iq = nil
+            end
+            fe = opts[:final_edge]
+            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>assoc_alias, :join_type=>join_type, &graph_block)
+          end
+
+          def_association_dataset_methods(opts)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/nested_attributes.rb

@@ -0,0 +1,206 @@
+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.
+        # * :fields - If provided, should be an Array.  Restricts the fields allowed to be
+        #   modified through the association_attributes= method to the specific fields given.
+        # * :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
+        private
+        
+        # Check that the keys related to the association are not modified inside the block.  Does
+        # not use an ensure block, so callers should be careful.
+        def nested_attributes_check_key_modifications(reflection, obj)
+          keys = reflection.associated_object_keys.map{|x| obj.send(x)}
+          yield
+          raise(Error, "Modifying association dependent key(s) when updating associated objects is not allowed") unless keys == reflection.associated_object_keys.map{|x| obj.send(x)}
+        end
+        
+        # Create a new associated object with the given attributes, validate
+        # it when the parent is validated, and save it when the object is saved.
+        # Returns the object created.
+        def nested_attributes_create(reflection, attributes)
+          obj = reflection.associated_class.new
+          nested_attributes_set_attributes(reflection, obj, attributes)
+          after_validation_hook{validate_associated_object(reflection, obj)}
+          if reflection.returns_array?
+            send(reflection[:name]) << obj
+            after_save_hook{send(reflection.add_method, obj)}
+          else
+            associations[reflection[:name]] = obj
+            # Don't need to validate the object twice if :validate association option is not false
+            # and don't want to validate it at all if it is false.
+            send(reflection[:type] == :many_to_one ? :before_save_hook : :after_save_hook){send(reflection.setter_method, obj.save(:validate=>false))}
+          end
+          obj
+        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 matching associated object with given primary key (association: #{reflection[:name]}, pk: #{pk})") 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.
+        # Returns the object removed, if it exists.
+        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]
+            obj
+          end
+        end
+        
+        # Set the fields in the obj based on the association, only allowing
+        # specific :fields if configured.
+        def nested_attributes_set_attributes(reflection, obj, attributes)
+          if fields = reflection[:nested_attributes][:fields]
+            obj.set_only(attributes, fields)
+          else
+            obj.set(attributes)
+          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)
+          modified!
+          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.
+        # Returns the object updated, if it exists.
+        def nested_attributes_update(reflection, pk, attributes)
+          if obj = nested_attributes_find(reflection, pk)
+            nested_attributes_update_attributes(reflection, obj, attributes)
+            after_validation_hook{validate_associated_object(reflection, obj)}
+            # Don't need to validate the object twice if :validate association option is not false
+            # and don't want to validate it at all if it is false.
+            after_save_hook{obj.save_changes(:validate=>false)}
+            obj
+          end
+        end
+
+        # Update the attributes for the given object related to the current object through the association.
+        def nested_attributes_update_attributes(reflection, obj, attributes)
+          nested_attributes_check_key_modifications(reflection, obj) do
+            nested_attributes_set_attributes(reflection, obj, attributes)
+          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)
+          return if reflection[:validate] == false
+          association = reflection[:name]
+          obj.errors.full_messages.each{|m| errors.add(association, m)} unless obj.valid?
+        end
+      end
+    end
+  end
+end