sequel 4.36.0 → 5.61.0

data/lib/sequel/plugins/validate_associated.rb

@@ -16,6 +16,24 @@ module Sequel
     #
     #   # Make the Album class support validating associated objects
     #   Album.plugin :validate_associated
+    #
+    #   class Album
+    #     many_to_one :artist
+    #     many_to_many :tags
+    #
+    #     # Always validate associated artist when saving the album
+    #     def validate
+    #       super
+    #       if artist
+    #         validate_associated_object(model.association_reflection(:artist), artist)
+    #       end
+    #     end
+    #
+    #     # When saving after calling this method, validate the given tag as well.
+    #     def check_tag!(tag)
+    #       delay_validate_associated_object(model.association_reflection(:tags), tag)
+    #     end
+    #   end
     module ValidateAssociated
       # Depend on the instance_hooks plugin.
       def self.apply(mod)

data/lib/sequel/plugins/validation_class_methods.rb

@@ -1,8 +1,6 @@
 # frozen-string-literal: true
 
 module Sequel
-  extension :blank
-
   module Plugins
     # Sequel's built-in validation_class_methods plugin adds backwards compatibility
     # for the legacy class-level validation methods (e.g. validates_presence_of :column).
@@ -11,7 +9,7 @@ module Sequel
     # as it is less complex and more flexible.  However, this plugin provides reflection
     # support, since it is class-level, while the instance-level validation_helpers
     # plugin does not.
-    # 
+    #
     # Usage:
     #
     #   # Add the validation class methods to all model subclasses (called before loading subclasses)
@@ -39,13 +37,26 @@ module Sequel
         # options.
         attr_reader :validation_reflections
 
+        # Freeze validation metadata when freezing model class.
+        def freeze
+          @validations.freeze.each_value(&:freeze)
+          @validation_reflections.freeze.each_value do |vs|
+            vs.freeze.each do |v|
+              v.freeze
+              v.last.freeze
+            end
+          end
+
+          super
+        end
+
         # The Generator class is used to generate validation definitions using 
         # the validates {} idiom.
         class Generator
           # Initializes a new generator.
           def initialize(receiver ,&block)
             @receiver = receiver
-            instance_eval(&block)
+            instance_exec(&block)
           end
       
           # Delegates method calls to the receiver by calling receiver.validates_xxx.
@@ -86,15 +97,16 @@ module Sequel
         #
         #   class MyClass < Sequel::Model
         #     validates do
-        #       length_of :name, :minimum => 6
-        #       length_of :password, :minimum => 8
+        #       length_of :name, minimum: 6
+        #       length_of :password, minimum: 8
         #     end
         #   end
         #
         # is equivalent to:
+        #
         #   class MyClass < Sequel::Model
-        #     validates_length_of :name, :minimum => 6
-        #     validates_length_of :password, :minimum => 8
+        #     validates_length_of :name, minimum: 6
+        #     validates_length_of :password, minimum: 8
         #   end
         def validates(&block)
           Generator.new(self, &block)
@@ -105,7 +117,7 @@ module Sequel
           validations.each do |att, procs|
             v = case att
             when Array
-              att.collect{|a| o.get_column_value(a)}
+              att.map{|a| o.get_column_value(a)}
             else
               o.get_column_value(att)
             end
@@ -176,16 +188,25 @@ module Sequel
         #                   Sequel will attempt to insert a NULL value into the database, instead of using the
         #                   database's default.
         # :allow_nil :: Whether to skip the validation if the value is nil.
-        # :if :: A symbol (indicating an instance_method) or proc (which is instance_evaled)
+        # :if :: A symbol (indicating an instance_method) or proc (which is used to define an instance method)
         #        skipping this validation if it returns nil or false.
         # :tag :: The tag to use for this validation.
         def validates_each(*atts, &block)
           opts = extract_options!(atts)
-          blk = if (i = opts[:if]) || (am = opts[:allow_missing]) || (an = opts[:allow_nil]) || (ab = opts[:allow_blank])
+          blank_meth = db.method(:blank_object?).to_proc
+          i = opts[:if]
+          am = opts[:allow_missing]
+          an = opts[:allow_nil]
+          ab = opts[:allow_blank]
+          blk = if i || am || an || ab
+            if i.is_a?(Proc)
+              i = Plugins.def_sequel_method(self, "validation_class_methods_if", 0, &i)
+            end
+
             proc do |o,a,v|
               next if i && !validation_if_proc(o, i)
               next if an && Array(v).all?(&:nil?)
-              next if ab && Array(v).all?(&:blank?)
+              next if ab && Array(v).all?(&blank_meth)
               next if am && Array(a).all?{|x| !o.values.has_key?(x)}
               block.call(o,a,v)
             end
@@ -261,7 +282,7 @@ module Sequel
               o.errors.add(a, opts[:message] || opts[:wrong_length]) unless v && v.size == i
             end
             if w = opts[:within]
-              o.errors.add(a, opts[:message] || opts[:wrong_length]) unless v && w.send(w.respond_to?(:cover?) ? :cover? : :include?, v.size)
+              o.errors.add(a, opts[:message] || opts[:wrong_length]) unless v && w.public_send(w.respond_to?(:cover?) ? :cover? : :include?, v.size)
             end
           end
         end
@@ -304,7 +325,7 @@ module Sequel
           reflect_validation(:presence, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
-            o.errors.add(a, opts[:message]) if v.blank? && v != false
+            o.errors.add(a, opts[:message]) if db.send(:blank_object?, v) && v != false
           end
         end
         
@@ -323,7 +344,7 @@ module Sequel
           reflect_validation(:inclusion, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
-            o.errors.add(a, opts[:message]) unless n.send(n.respond_to?(:cover?) ? :cover? : :include?, v)
+            o.errors.add(a, opts[:message]) unless n.public_send(n.respond_to?(:cover?) ? :cover? : :include?, v)
           end
         end
     
@@ -378,7 +399,7 @@ module Sequel
             a = Array(a)
             v = Array(v)
             next if v.empty? || !v.all?
-            ds = o.class.filter(a.zip(v))
+            ds = o.class.where(a.zip(v))
             num_dups = ds.count
             allow = if num_dups == 0
               # No unique value in the database
@@ -406,7 +427,7 @@ module Sequel
         # an empty hash is returned This method is useful when writing methods that
         # take an options hash as the last parameter.
         def extract_options!(array)
-          array.last.is_a?(Hash) ? array.pop : {}
+          array.last.is_a?(Hash) ? array.pop : OPTS
         end
 
         # Add the validation reflection to the class's validations.
@@ -421,8 +442,6 @@ module Sequel
           case i
           when Symbol
             o.get_column_value(i)
-          when Proc
-            o.instance_eval(&i)
           else
             raise(::Sequel::Error, "invalid value for :if validation option")
           end

data/lib/sequel/plugins/validation_contexts.rb

@@ -0,0 +1,49 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The validation_contexts plugin adds support for a validation_context method inside a validate
+    # method.  You pass in the validation context to use via the :validation_context option to
+    # Sequel::Model#save && Sequel::Model#valid?:
+    #
+    #   class Album < Sequel::Model
+    #     plugin :validation_contexts
+    #     def validate
+    #       super
+    #       errors.add(:status_id, 'not 1') if status_id != 1 && validation_context == :initial
+    #       errors.add(:status_id, 'not 2') if status_id != 2 && validation_context == :approve
+    #     end
+    #   end
+    #
+    #   Album.new(status_id: 1).valid?(validation_context: :initial) # => true
+    #   Album.new(status_id: 2).valid?(validation_context: :initial) # => false
+    #
+    #   Album.new(status_id: 1).valid?(validation_context: :approve) # => false
+    #   Album.new(status_id: 2).valid?(validation_context: :approve) # => true
+    #
+    # There is no validation context used by default, so validation_context will be
+    # +nil+ if one is not specified.  If you want to differentiate between creating new
+    # objects and updating existing objects, just use +new?+.
+    #
+    # Once this plugin is loaded into a model, after you freeze an instance
+    # of that model, you can no longer specify a validation context when
+    # validating the instance.
+    module ValidationContexts
+      module InstanceMethods 
+        # The validation context to use for the current validation.
+        # Set via the :validation_context option passed to save/valid?.
+        attr_reader :validation_context
+
+        private
+
+        # Set validation context before running validations
+        def _valid?(opts)
+          @validation_context = opts[:validation_context] if opts[:validation_context]
+          super
+        ensure
+          @validation_context = nil if @validation_context
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/validation_helpers.rb

@@ -2,8 +2,8 @@
 
 module Sequel
   module Plugins
-    # The validation_helpers plugin contains instance method equivalents for most of the legacy
-    # class-level validations.  The names and APIs are different, though. Example:
+    # The validation_helpers plugin contains validate_* methods designed to be called inside Model#validate
+    # to perform validations:
     #
     #   Sequel::Model.plugin :validation_helpers
     #   class Album < Sequel::Model
@@ -19,9 +19,7 @@ module Sequel
     # atts :: Single attribute symbol or an array of attribute symbols specifying the
     #         attribute(s) to validate.
     # Options:
-    # :allow_blank :: Whether to skip the validation if the value is blank.  You should
-    #                 make sure all objects respond to blank if you use this option, which you can do by:
-    #                     Sequel.extension :blank
+    # :allow_blank :: Whether to skip the validation if the value is blank.
     # :allow_missing :: Whether to skip the validation if the attribute isn't a key in the
     #                   values hash.  This is different from allow_nil, because Sequel only sends the attributes
     #                   in the values when doing an insert or update.  If the attribute is not present, Sequel
@@ -38,19 +36,27 @@ module Sequel
     # :message :: The message to use.  Can be a string which is used directly, or a
     #             proc which is called.  If the validation method takes a argument before the array of attributes,
     #             that argument is passed as an argument to the proc.
+    # :skip_invalid :: Do not try to validate columns that are already invalid.
     #
     # The default validation options for all models can be modified by
-    # changing the values of the Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS hash.  You
-    # change change the default options on a per model basis
-    # by overriding a private instance method default_validation_helpers_options.
-    #
+    # overridding the Model#default_validation_helpers_options private method.
     # By changing the default options, you can setup internationalization of the
     # error messages.  For example, you would modify the default options:
     #
-    #   Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS.merge!(
-    #     :exact_length=>{:message=>lambda{|exact| I18n.t("errors.exact_length", :exact => exact)}},
-    #     :integer=>{:message=>lambda{I18n.t("errors.integer")}}
-    #   )
+    #   class Sequel::Model
+    #     private
+    #
+    #     def default_validation_helpers_options(type)
+    #       case type
+    #       when :exact_length
+    #         {message: lambda{|exact| I18n.t("errors.exact_length", exact: exact)}}
+    #       when :integer
+    #         {message: lambda{I18n.t("errors.integer")}}
+    #       else
+    #         super
+    #       end
+    #     end
+    #   end
     #
     # and then use something like this in your yaml translation file:
     #
@@ -60,23 +66,16 @@ module Sequel
     #       integer: "is not a number"
     #
     # Note that if you want to support internationalization of Errors#full_messages,
-    # you need to override the method.  Here's an example:
+    # it is easiest to override Errors#full_message (note singular form and not plural form).
+    # Here's an example:
     #   
     #   class Sequel::Model::Errors
-    #     ATTRIBUTE_JOINER = I18n.t('errors.joiner').freeze
-    #     def full_messages
-    #       inject([]) do |m, kv|
-    #         att, errors = *kv
-    #         att.is_a?(Array) ? Array(att).map!{|v| I18n.t("attributes.#{v}")} : att = I18n.t("attributes.#{att}")
-    #         errors.each {|e| m << (e.is_a?(LiteralString) ? e : "#{Array(att).join(ATTRIBUTE_JOINER)} #{e}")}
-    #         m
-    #       end
+    #     private
+    #     def full_message(attribute, error_msg)
+    #       "#{Array(attribute).join(I18n.t('errors.joiner'))} #{error_msg}"
     #     end
     #   end
     module ValidationHelpers
-      # Default validation options used by Sequel.  Can be modified to change the error
-      # messages for all models (e.g. for internationalization), or to set certain
-      # default options for validations (e.g. :allow_nil=>true for all validates_format).
       DEFAULT_OPTIONS = {
         :exact_length=>{:message=>lambda{|exact| "is not #{exact} characters"}},
         :format=>{:message=>lambda{|with| 'is invalid'}},
@@ -86,12 +85,14 @@ module Sequel
         :max_length=>{:message=>lambda{|max| "is longer than #{max} characters"}, :nil_message=>lambda{"is not present"}},
         :min_length=>{:message=>lambda{|min| "is shorter than #{min} characters"}},
         :not_null=>{:message=>lambda{"is not present"}},
+        :no_null_byte=>{:message=>lambda{"contains a null byte"}},
         :numeric=>{:message=>lambda{"is not a number"}},
         :operator=>{:message=>lambda{|operator, rhs| "is not #{operator} #{rhs}"}},
         :type=>{:message=>lambda{|klass| klass.is_a?(Array) ? "is not a valid #{klass.join(" or ").downcase}" : "is not a valid #{klass.to_s.downcase}"}},
         :presence=>{:message=>lambda{"is not present"}},
         :unique=>{:message=>lambda{'is already taken'}}
-      }
+      }.freeze
+      DEFAULT_OPTIONS.each_value(&:freeze)
 
       module InstanceMethods 
         # Check that the attribute values are the given exact length.
@@ -106,7 +107,7 @@ module Sequel
     
         # Check attribute value(s) is included in the given set.
         def validates_includes(set, atts, opts=OPTS)
-          validatable_attributes_for_type(:includes, atts, opts){|a,v,m| validation_error_message(m, set) unless set.send(set.respond_to?(:cover?) ? :cover? : :include?, v)}
+          validatable_attributes_for_type(:includes, atts, opts){|a,v,m| validation_error_message(m, set) unless set.public_send(set.respond_to?(:cover?) ? :cover? : :include?, v)}
         end
     
         # Check attribute value(s) string representation is a valid integer.
@@ -123,7 +124,7 @@ module Sequel
 
         # Check that the attribute values length is in the specified range.
         def validates_length_range(range, atts, opts=OPTS)
-          validatable_attributes_for_type(:length_range, atts, opts){|a,v,m| validation_error_message(m, range) if v.nil? || !range.send(range.respond_to?(:cover?) ? :cover? : :include?, v.length)}
+          validatable_attributes_for_type(:length_range, atts, opts){|a,v,m| validation_error_message(m, range) if v.nil? || !range.cover?(v.length)}
         end
     
         # Check that the attribute values are not longer than the given max length.
@@ -131,7 +132,13 @@ module Sequel
         # Accepts a :nil_message option that is the error message to use when the
         # value is nil instead of being too long.
         def validates_max_length(max, atts, opts=OPTS)
-          validatable_attributes_for_type(:max_length, atts, opts){|a,v,m| v ? validation_error_message(m, max) : validation_error_message(opts[:nil_message] || DEFAULT_OPTIONS[:max_length][:nil_message]) if v.nil? || v.length > max}
+          validatable_attributes_for_type(:max_length, atts, opts) do |a,v,m|
+            if v.nil?
+              validation_error_message(opts[:nil_message] || default_validation_helpers_options(:max_length)[:nil_message])
+            elsif v.length > max
+              validation_error_message(m, max)
+            end
+          end
         end
 
         # Check that the attribute values are not shorter than the given min length.
@@ -143,6 +150,11 @@ module Sequel
         def validates_not_null(atts, opts=OPTS)
           validatable_attributes_for_type(:not_null, atts, opts){|a,v,m| validation_error_message(m) if v.nil?}
         end
+
+        # Check attribute value(s) does not contain a null ("\0", ASCII NUL) byte.
+        def validates_no_null_byte(atts, opts=OPTS)
+          validatable_attributes_for_type(:no_null_byte, atts, opts){|a,v,m| validation_error_message(m) if String === v && v.include?("\0")}
+        end
         
         # Check attribute value(s) string representation is a valid float.
         def validates_numeric(atts, opts=OPTS)
@@ -159,7 +171,7 @@ module Sequel
         # Check attribute value(s) against a specified value and operation, e.g.
         # validates_operator(:>, 3, :value) validates that value > 3.
         def validates_operator(operator, rhs, atts, opts=OPTS)
-          validatable_attributes_for_type(:operator, atts, opts){|a,v,m| validation_error_message(m, operator, rhs) if v.nil? || !v.send(operator, rhs)}
+          validatable_attributes_for_type(:operator, atts, opts){|a,v,m| validation_error_message(m, operator, rhs) if v.nil? || !v.public_send(operator, rhs)}
         end
 
         # Validates for all of the model columns (or just the given columns)
@@ -204,7 +216,7 @@ module Sequel
         # must be unique. So if you are doing a soft delete of records, in which
         # the name must be unique, but only for active records:
         #
-        #   validates_unique(:name){|ds| ds.filter(:active)}
+        #   validates_unique(:name){|ds| ds.where(:active)}
         #
         # You should also add a unique index in the
         # database, as this suffers from a fairly obvious race condition.
@@ -217,7 +229,7 @@ module Sequel
         #             model's dataset.
         # :message :: The message to use (default: 'is already taken')
         # :only_if_modified :: Only check the uniqueness if the object is new or
-        #                      one of the columns has been modified.
+        #                      one of the columns has been modified, true by default.
         # :where :: A callable object where call takes three arguments, a dataset,
         #           the current object, and an array of columns, and should return
         #           a modified dataset that is filtered to include only rows with
@@ -226,9 +238,9 @@ module Sequel
         # If you want to do a case insensitive uniqueness validation on a database that
         # is case sensitive by default, you can use:
         #
-        #   validates_unique :column, :where=>(proc do |ds, obj, cols|
+        #   validates_unique :column, where:(lambda do |ds, obj, cols|
         #     ds.where(cols.map do |c|
-        #       v = obj.send(c)
+        #       v = obj.public_send(c)
         #       v = v.downcase if v
         #       [Sequel.function(:lower, c), v]
         #     end)
@@ -236,7 +248,7 @@ module Sequel
         def validates_unique(*atts)
           opts = default_validation_helpers_options(:unique)
           if atts.last.is_a?(Hash)
-            opts = Hash[opts].merge!(atts.pop)
+            opts = opts.merge(atts.pop)
           end
           message = validation_error_message(opts[:message])
           from_values = opts[:from] == :values
@@ -244,7 +256,8 @@ module Sequel
           atts.each do |a|
             arr = Array(a)
             next if arr.any?{|x| errors.on(x)}
-            next if opts[:only_if_modified] && !new? && !arr.any?{|x| changed_columns.include?(x)}
+            cc = changed_columns
+            next if opts.fetch(:only_if_modified, true) && !new? && !arr.any?{|x| cc.include?(x)}
             ds = opts[:dataset] || model.dataset
             ds = if where
               where.call(ds, self, arr)
@@ -253,7 +266,7 @@ module Sequel
               next if vals.any?(&:nil?)
               ds.where(arr.zip(vals))
             end
-            ds = yield(ds) if block_given?
+            ds = yield(ds) if defined?(yield)
             unless new?
               h = ds.joined_dataset? ? qualified_pk_hash : pk_hash
               ds = ds.exclude(h)
@@ -272,18 +285,21 @@ module Sequel
           DEFAULT_OPTIONS[type]
         end
 
-        # Skip validating any attribute that matches one of the allow_* options.
+        # Skip validating any attribute that matches one of the allow_* options,
+        # or already has an error if the skip_invalid option is given.
+        #
         # Otherwise, yield the attribute, value, and passed option :message to
         # the block.  If the block returns anything except nil or false, add it as
         # an error message for that attributes.
         def validatable_attributes(atts, opts)
-          am, an, ab, m = opts.values_at(:allow_missing, :allow_nil, :allow_blank, :message)
+          am, an, ab, m, si = opts.values_at(:allow_missing, :allow_nil, :allow_blank, :message, :skip_invalid)
           from_values = opts[:from] == :values
           Array(atts).each do |a|
+            next if si && errors.on(a)
             next if am && !values.has_key?(a)
             v = from_values ? values[a] : get_column_value(a)
             next if an && v.nil?
-            next if ab && v.respond_to?(:blank?) && v.blank?
+            next if ab && model.db.send(:blank_object?, v)
             if message = yield(a, v, m)
               errors.add(a, message)
             end
@@ -293,7 +309,7 @@ module Sequel
         # Merge the given options with the default options for the given type
         # and call validatable_attributes with the merged options.
         def validatable_attributes_for_type(type, atts, opts, &block)
-          validatable_attributes(atts, Hash[default_validation_helpers_options(type)].merge!(opts), &block)
+          validatable_attributes(atts, default_validation_helpers_options(type).merge(opts), &block)
         end
         
         # The validation error message to use, as a string.  If message

data/lib/sequel/plugins/whitelist_security.rb

@@ -0,0 +1,122 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The whitelist_security plugin contains whitelist-based support for
+    # mass assignment, explicitly specifying which columns to allow mass assignment for,
+    # disallowing mass assignment for columns not listed.  This exists mostly for backwards
+    # compatibility, it's best to use Sequel::Model#set_fields and Sequel::Model#update_fields
+    # to decide which fields to allow on a per-call basis.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support allowed_columns 
+    #   Sequel::Model.plugin :whitelist_security
+    #
+    #   # Make the Album class support allowed_columns
+    #   Album.plugin :whitelist_security
+    module WhitelistSecurity
+      module ClassMethods
+        # Which columns should be the only columns allowed in a call to a mass assignment method (e.g. set)
+        # (default: not set, so all columns not otherwise restricted are allowed).
+        attr_reader :allowed_columns
+  
+        Plugins.inherited_instance_variables(self, :@allowed_columns=>:dup)
+
+        # Freeze allowed columns when freezing model class.
+        def freeze
+          @allowed_columns.freeze
+          super
+        end
+
+        # Set the columns to allow when using mass assignment (e.g. +set+).  Using this means that
+        # any columns not listed here will not be modified.  If you have any virtual
+        # setter methods (methods that end in =) that you want to be used during
+        # mass assignment, they need to be listed here as well (without the =).
+        #
+        # It may be better to use +set_fields+ which lets you specify
+        # the allowed fields per call.
+        #
+        #   Artist.set_allowed_columns(:name, :hometown)
+        #   Artist.set(name: 'Bob', hometown: 'Sactown') # No Error
+        #   Artist.set(name: 'Bob', records_sold: 30000) # Error
+        def set_allowed_columns(*cols)
+          clear_setter_methods_cache
+          @allowed_columns = cols
+        end
+  
+        private
+
+        # If allowed_columns is set, only allow those columns.
+        def get_setter_methods
+          if allowed_columns
+            allowed_columns.map{|x| "#{x}="}
+          else
+            super
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Set all values using the entries in the hash, ignoring any setting of
+        # allowed_columns in the model.
+        #
+        #   Artist.set_allowed_columns(:num_albums)
+        #   artist.set_all(name: 'Jim')
+        #   artist.name # => 'Jim'
+        def set_all(hash)
+          set_restricted(hash, :all)
+        end
+  
+        # Set the values using the entries in the hash, only if the key
+        # is included in only.  It may be a better idea to use +set_fields+
+        # instead of this method.
+        #
+        #   artist.set_only({name: 'Jim'}, :name)
+        #   artist.name # => 'Jim'
+        #
+        #   artist.set_only({hometown: 'LA'}, :name) # Raise Error
+        def set_only(hash, *only)
+          set_restricted(hash, only.flatten)
+        end
+  
+        # Update all values using the entries in the hash, ignoring any setting of
+        # +allowed_columns+ in the model.
+        #
+        #   Artist.set_allowed_columns(:num_albums)
+        #   artist.update_all(name: 'Jim') # UPDATE artists SET name = 'Jim' WHERE (id = 1)
+        def update_all(hash)
+          update_restricted(hash, :all)
+        end
+  
+        # Update the values using the entries in the hash, only if the key
+        # is included in only.  It may be a better idea to use +update_fields+
+        # instead of this method.
+        #
+        #   artist.update_only({name: 'Jim'}, :name)
+        #   # UPDATE artists SET name = 'Jim' WHERE (id = 1)
+        #
+        #   artist.update_only({hometown: 'LA'}, :name) # Raise Error
+        def update_only(hash, *only)
+          update_restricted(hash, only.flatten)
+        end
+      
+        private
+
+        # If allowed_columns is set and set/update is called, only allow those columns.
+        def setter_methods(type)
+          if type == :default && model.allowed_columns
+            model.setter_methods
+          elsif type.is_a?(Array)
+            type.map{|x| "#{x}="}
+          elsif type == :all && primary_key && model.restrict_primary_key?
+            super + Array(primary_key).map{|x| "#{x}="}
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end
+