viking-sequel 3.10.0

data/lib/sequel/plugins/validation_class_methods.rb

@@ -0,0 +1,405 @@
+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).
+    #
+    # It is recommended to use the validation_helpers plugin instead of this one,
+    # as it is less complex and more flexible.
+    module ValidationClassMethods
+      # Setup the validations hash for the given model.
+      def self.apply(model)
+        model.class_eval do
+          @validation_mutex = Mutex.new
+          @validations = {}
+        end
+      end
+
+      module ClassMethods
+        # A hash of associations for this model class.  Keys are column symbols,
+        # values are arrays of validation procs.
+        attr_reader :validations
+
+        # 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)
+          end
+      
+          # Delegates method calls to the receiver by calling receiver.validates_xxx.
+          def method_missing(m, *args, &block)
+            @receiver.send(:"validates_#{m}", *args, &block)
+          end
+        end
+    
+        # Returns true if validations are defined.
+        def has_validations?
+          !validations.empty?
+        end
+
+        # Setup the validations hash in the subclass
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            @validation_mutex = Mutex.new
+            @validations = {}
+          end
+        end
+    
+        # Instructs the model to skip validations defined in superclasses
+        def skip_superclass_validations
+          @skip_superclass_validations = true
+        end
+        
+        # Instructs the model to skip validations defined in superclasses
+        def skip_superclass_validations?
+          defined?(@skip_superclass_validations) && @skip_superclass_validations
+        end
+
+        # Defines validations by converting a longhand block into a series of 
+        # shorthand definitions. For example:
+        #
+        #   class MyClass < Sequel::Model
+        #     validates do
+        #       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
+        #   end
+        def validates(&block)
+          Generator.new(self, &block)
+        end
+    
+        # Validates the given instance.
+        def validate(o)
+          superclass.validate(o) if superclass.respond_to?(:validate) && !skip_superclass_validations?
+          validations.each do |att, procs|
+            v = case att
+            when Array
+              att.collect{|a| o.send(a)}
+            else
+              o.send(att)
+            end
+            procs.each {|tag, p| p.call(o, att, v)}
+          end
+        end
+        
+        # Validates acceptance of an attribute.  Just checks that the value
+        # is equal to the :accept option. This method is unique in that
+        # :allow_nil is assumed to be true instead of false.
+        #
+        # Possible Options:
+        # * :accept - The value required for the object to be valid (default: '1')
+        # * :message - The message to use (default: 'is not accepted')
+        def validates_acceptance_of(*atts)
+          opts = {
+            :message => 'is not accepted',
+            :allow_nil => true,
+            :accept => '1',
+            :tag => :acceptance,
+          }.merge!(extract_options!(atts))
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            o.errors.add(a, opts[:message]) unless v == opts[:accept]
+          end
+        end
+    
+        # Validates confirmation of an attribute. Checks that the object has
+        # a _confirmation value matching the current value.  For example:
+        #
+        #   validates_confirmation_of :blah
+        #
+        # Just makes sure that object.blah = object.blah_confirmation.  Often used for passwords
+        # or email addresses on web forms.
+        #
+        # Possible Options:
+        # * :message - The message to use (default: 'is not confirmed')
+        def validates_confirmation_of(*atts)
+          opts = {
+            :message => 'is not confirmed',
+            :tag => :confirmation,
+          }.merge!(extract_options!(atts))
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            o.errors.add(a, opts[:message]) unless v == o.send(:"#{a}_confirmation")
+          end
+        end
+    
+        # Adds a validation for each of the given attributes using the supplied
+        # block. The block must accept three arguments: instance, attribute and 
+        # value, e.g.:
+        #
+        #   validates_each :name, :password do |object, attribute, value|
+        #     object.errors.add(attribute, 'is not nice') unless value.nice?
+        #   end
+        #
+        # Possible Options:
+        # * :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
+        #   doesn't specify it, so the database will use the table's default value.  This is different
+        #   from having an attribute in values with a value of nil, which Sequel will send as NULL.
+        #   If your database table has a non NULL default, this may be a good option to use.  You
+        #   don't want to use allow_nil, because if the attribute is in values but has a value nil,
+        #   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)
+        #   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])
+            proc do |o,a,v|
+              next if i && !validation_if_proc(o, i)
+              next if an && Array(v).all?{|x| x.nil?}
+              next if ab && Array(v).all?{|x| x.blank?}
+              next if am && Array(a).all?{|x| !o.values.has_key?(x)}
+              block.call(o,a,v)
+            end
+          else
+            block
+          end
+          tag = opts[:tag]
+          atts.each do |a| 
+            a_vals = @validation_mutex.synchronize{validations[a] ||= []}
+            if tag && (old = a_vals.find{|x| x[0] == tag})
+              old[1] = blk
+            else
+              a_vals << [tag, blk]
+            end
+          end
+        end
+    
+        # Validates the format of an attribute, checking the string representation of the
+        # value against the regular expression provided by the :with option.
+        #
+        # Possible Options:
+        # * :message - The message to use (default: 'is invalid')
+        # * :with - The regular expression to validate the value with (required).
+        def validates_format_of(*atts)
+          opts = {
+            :message => 'is invalid',
+            :tag => :format,
+          }.merge!(extract_options!(atts))
+          
+          unless opts[:with].is_a?(Regexp)
+            raise ArgumentError, "A regular expression must be supplied as the :with option of the options hash"
+          end
+          
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            o.errors.add(a, opts[:message]) unless v.to_s =~ opts[:with]
+          end
+        end
+    
+        # Validates the length of an attribute.
+        #
+        # Possible Options:
+        # * :is - The exact size required for the value to be valid (no default)
+        # * :maximum - The maximum size allowed for the value (no default)
+        # * :message - The message to use (no default, overrides :too_long, :too_short, and :wrong_length
+        #   options if present)
+        # * :minimum - The minimum size allowed for the value (no default)
+        # * :too_long - The message to use use if it the value is too long (default: 'is too long')
+        # * :too_short - The message to use use if it the value is too short (default: 'is too short')
+        # * :within - The array/range that must include the size of the value for it to be valid (no default)
+        # * :wrong_length - The message to use use if it the value is not valid (default: 'is the wrong length')
+        def validates_length_of(*atts)
+          opts = {
+            :too_long     => 'is too long',
+            :too_short    => 'is too short',
+            :wrong_length => 'is the wrong length'
+          }.merge!(extract_options!(atts))
+          
+          opts[:tag] ||= ([:length] + [:maximum, :minimum, :is, :within].reject{|x| !opts.include?(x)}).join('-').to_sym
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            if m = opts[:maximum]
+              o.errors.add(a, opts[:message] || opts[:too_long]) unless v && v.size <= m
+            end
+            if m = opts[:minimum]
+              o.errors.add(a, opts[:message] || opts[:too_short]) unless v && v.size >= m
+            end
+            if i = opts[:is]
+              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.include?(v.size)
+            end
+          end
+        end
+    
+        # Validates whether an attribute is not a string.  This is generally useful
+        # in conjunction with raise_on_typecast_failure = false, where you are
+        # passing in string values for non-string attributes (such as numbers and dates).
+        # If typecasting fails (invalid number or date), the value of the attribute will
+        # be a string in an invalid format, and if typecasting succeeds, the value will
+        # not be a string.
+        #
+        # Possible Options:
+        # * :message - The message to use (default: 'is a string' or 'is not a valid (integer|datetime|etc.)' if the type is known)
+        def validates_not_string(*atts)
+          opts = {
+            :tag => :not_string,
+          }.merge!(extract_options!(atts))
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            if v.is_a?(String)
+              unless message = opts[:message]
+                message = if sch = o.db_schema[a] and typ = sch[:type]
+                  "is not a valid #{typ}"
+                else
+                  "is a string"
+                end
+              end
+              o.errors.add(a, message)
+            end
+          end
+        end
+    
+        # Validates whether an attribute is a number.
+        #
+        # Possible Options:
+        # * :message - The message to use (default: 'is not a number')
+        # * :only_integer - Whether only integers are valid values (default: false)
+        def validates_numericality_of(*atts)
+          opts = {
+            :message => 'is not a number',
+            :tag => :numericality,
+          }.merge!(extract_options!(atts))
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            begin
+              if opts[:only_integer]
+                Kernel.Integer(v.to_s)
+              else
+                Kernel.Float(v.to_s)
+              end
+            rescue
+              o.errors.add(a, opts[:message])
+            end
+          end
+        end
+    
+        # Validates the presence of an attribute.  Requires the value not be blank,
+        # with false considered present instead of absent.
+        #
+        # Possible Options:
+        # * :message - The message to use (default: 'is not present')
+        def validates_presence_of(*atts)
+          opts = {
+            :message => 'is not present',
+            :tag => :presence,
+          }.merge!(extract_options!(atts))
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            o.errors.add(a, opts[:message]) if v.blank? && v != false
+          end
+        end
+        
+        # Validates that an attribute is within a specified range or set of values.
+        #
+        # Possible Options:
+        # * :in - An array or range of values to check for validity (required)
+        # * :message - The message to use (default: 'is not in range or set: <specified range>')
+        def validates_inclusion_of(*atts)
+          opts = extract_options!(atts)
+          unless opts[:in] && opts[:in].respond_to?(:include?) 
+            raise ArgumentError, "The :in parameter is required, and respond to include?"
+          end
+          opts[:message] ||= "is not in range or set: #{opts[:in].inspect}"
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            o.errors.add(a, opts[:message]) unless opts[:in].include?(v)
+          end
+        end
+    
+        # Validates only if the fields in the model (specified by atts) are
+        # unique in the database.  Pass an array of fields instead of multiple
+        # fields to specify that the combination of fields must be unique,
+        # instead of that each field should have a unique value.
+        #
+        # This means that the code:
+        #   validates_uniqueness_of([:column1, :column2])
+        # validates the grouping of column1 and column2 while
+        #   validates_uniqueness_of(:column1, :column2)
+        # validates them separately.
+        #
+        # You should also add a unique index in the
+        # database, as this suffers from a fairly obvious race condition.
+        #
+        # Possible Options:
+        # * :message - The message to use (default: 'is already taken')
+        def validates_uniqueness_of(*atts)
+          opts = {
+            :message => 'is already taken',
+            :tag => :uniqueness,
+          }.merge!(extract_options!(atts))
+    
+          atts << opts
+          validates_each(*atts) do |o, a, v|
+            error_field = a
+            a = Array(a)
+            v = Array(v)
+            ds = o.class.filter(a.zip(v))
+            num_dups = ds.count
+            allow = if num_dups == 0
+              # No unique value in the database
+              true
+            elsif num_dups > 1
+              # Multiple "unique" values in the database!!
+              # Someone didn't add a unique index
+              false
+            elsif o.new?
+              # New record, but unique value already exists in the database
+              false
+            elsif ds.first === o
+              # Unique value exists in database, but for the same record, so the update won't cause a duplicate record
+              true
+            else
+              false
+            end
+            o.errors.add(error_field, opts[:message]) unless allow
+          end
+        end
+    
+        private
+    
+        # Removes and returns the last member of the array if it is a hash. Otherwise,
+        # 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 : {}
+        end
+
+        # Handle the :if option for validations
+        def validation_if_proc(o, i)
+          case i
+          when Symbol then o.send(i)
+          when Proc then o.instance_eval(&i)
+          when nil then true
+          else raise(::Sequel::Error, "invalid value for :if validation option")
+          end
+        end
+      end
+    
+      module InstanceMethods
+        # Validates the object.
+        def validate
+          model.validate(self)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/validation_helpers.rb

@@ -0,0 +1,223 @@
+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:
+    #
+    #   class Album < Sequel::Model
+    #     plugin :validation_helpers
+    #     def validate
+    #       validates_min_length 1, :num_tracks
+    #     end
+    #   end
+    #
+    # The validates_unique validation has a unique API, but the other validations have
+    # the API explained here:
+    #
+    # Arguments:
+    # * 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_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
+    #   doesn't specify it, so the database will use the table's default value.  This is different
+    #   from having an attribute in values with a value of nil, which Sequel will send as NULL.
+    #   If your database table has a non NULL default, this may be a good option to use.  You
+    #   don't want to use allow_nil, because if the attribute is in values but has a value nil,
+    #   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.
+    # * :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.  The exception is the
+    #   validates_not_string method, which doesn't take an argument, but passes
+    #   the schema type symbol as the argument to the proc.
+    #
+    # 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.
+    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'}},
+        :includes=>{:message=>lambda{|set| "is not in range or set: #{set.inspect}"}},
+        :integer=>{:message=>lambda{"is not a number"}},
+        :length_range=>{:message=>lambda{|range| "is too short or too long"}},
+        :max_length=>{:message=>lambda{|max| "is longer than #{max} characters"}},
+        :min_length=>{:message=>lambda{|min| "is shorter than #{min} characters"}},
+        :not_string=>{:message=>lambda{|type| type ? "is not a valid #{type}" : "is a string"}},
+        :numeric=>{:message=>lambda{"is not a number"}},
+        :type=>{:message=>lambda{|klass| "is not a #{klass}"}},
+        :presence=>{:message=>lambda{"is not present"}},
+        :unique=>{:message=>lambda{'is already taken'}}
+      }
+      
+      module InstanceMethods 
+        # Check that the attribute values are the given exact length.
+        def validates_exact_length(exact, atts, opts={})
+          validatable_attributes_for_type(:exact_length, atts, opts){|a,v,m| validation_error_message(m, exact) unless v && v.length == exact}
+        end
+
+        # Check the string representation of the attribute value(s) against the regular expression with.
+        def validates_format(with, atts, opts={})
+          validatable_attributes_for_type(:format, atts, opts){|a,v,m| validation_error_message(m, with) unless v.to_s =~ with}
+        end
+    
+        # Check attribute value(s) is included in the given set.
+        def validates_includes(set, atts, opts={})
+          validatable_attributes_for_type(:includes, atts, opts){|a,v,m| validation_error_message(m, set) unless set.include?(v)}
+        end
+    
+        # Check attribute value(s) string representation is a valid integer.
+        def validates_integer(atts, opts={})
+          validatable_attributes_for_type(:integer, atts, opts) do |a,v,m|
+            begin
+              Kernel.Integer(v.to_s)
+              nil
+            rescue
+              validation_error_message(m)
+            end
+          end
+        end
+
+        # Check that the attribute values length is in the specified range.
+        def validates_length_range(range, atts, opts={})
+          validatable_attributes_for_type(:length_range, atts, opts){|a,v,m| validation_error_message(m, range) unless v && range.include?(v.length)}
+        end
+    
+        # Check that the attribute values are not longer than the given max length.
+        def validates_max_length(max, atts, opts={})
+          validatable_attributes_for_type(:max_length, atts, opts){|a,v,m| validation_error_message(m, max) unless v && v.length <= max}
+        end
+
+        # Check that the attribute values are not shorter than the given min length.
+        def validates_min_length(min, atts, opts={})
+          validatable_attributes_for_type(:min_length, atts, opts){|a,v,m| validation_error_message(m, min) unless v && v.length >= min}
+        end
+
+        # Check that the attribute value(s) is not a string.  This is generally useful
+        # in conjunction with raise_on_typecast_failure = false, where you are
+        # passing in string values for non-string attributes (such as numbers and dates).
+        # If typecasting fails (invalid number or date), the value of the attribute will
+        # be a string in an invalid format, and if typecasting succeeds, the value will
+        # not be a string.
+        def validates_not_string(atts, opts={})
+          validatable_attributes_for_type(:not_string, atts, opts){|a,v,m| validation_error_message(m, (db_schema[a]||{})[:type]) if v.is_a?(String)}
+        end
+
+        # Check attribute value(s) string representation is a valid float.
+        def validates_numeric(atts, opts={})
+          validatable_attributes_for_type(:numeric, atts, opts) do |a,v,m|
+            begin
+              Kernel.Float(v.to_s)
+              nil
+            rescue
+              validation_error_message(m)
+            end
+          end
+        end
+
+        # Check if value is an instance of a class
+        def validates_type(klass, atts, opts={})
+          klass = klass.to_s.constantize if klass.is_a?(String) || klass.is_a?(Symbol)
+          validatable_attributes_for_type(:type, atts, opts){|a,v,m| validation_error_message(m, klass) if v && !v.is_a?(klass)}
+        end
+    
+        # Check attribute value(s) is not considered blank by the database, but allow false values.
+        def validates_presence(atts, opts={})
+          validatable_attributes_for_type(:presence, atts, opts){|a,v,m| validation_error_message(m) if model.db.send(:blank_object?, v) && v != false}
+        end
+        
+        # Checks that there are no duplicate values in the database for the given
+        # attributes.  Pass an array of fields instead of multiple
+        # fields to specify that the combination of fields must be unique,
+        # instead of that each field should have a unique value.
+        #
+        # This means that the code:
+        #   validates_unique([:column1, :column2])
+        # validates the grouping of column1 and column2 while
+        #   validates_unique(:column1, :column2)
+        # validates them separately.
+        #
+        # You can pass a block, which is yielded the dataset in which the columns
+        # 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)}
+        #
+        # You should also add a unique index in the
+        # database, as this suffers from a fairly obvious race condition.
+        #
+        # This validation does not respect the :allow_* options that the other validations accept,
+        # since it can deal with a grouping of multiple attributes.
+        #
+        # Possible Options:
+        # * :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.
+        def validates_unique(*atts)
+          opts = default_validation_helpers_options(:unique)
+          if atts.last.is_a?(Hash)
+            opts = opts.merge(atts.pop)
+          end
+          message = validation_error_message(opts[:message])
+          atts.each do |a|
+            arr = Array(a)
+            next if opts[:only_if_modified] && !new? && !arr.any?{|x| changed_columns.include?(x)}
+            ds = model.filter(arr.map{|x| [x, send(x)]})
+            ds = yield(ds) if block_given?
+            ds = ds.exclude(pk_hash) unless new?
+            errors.add(a, message) unless ds.count == 0
+          end
+        end
+        
+        private
+        
+        # The default options hash for the given type of validation.  Can
+        # be overridden on a per-model basis for different per model defaults.
+        # The hash return must include a :message option that is either a
+        # proc or string.
+        def default_validation_helpers_options(type)
+          DEFAULT_OPTIONS[type]
+        end
+
+        # Skip validating any attribute that matches one of the allow_* options.
+        # 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)
+          Array(atts).each do |a|
+            next if am && !values.has_key?(a)
+            v = send(a)
+            next if an && v.nil?
+            next if ab && v.respond_to?(:blank?) && v.blank?
+            if message = yield(a, v, m)
+              errors.add(a, message)
+            end
+          end
+        end
+        
+        # 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, default_validation_helpers_options(type).merge(opts), &block)
+        end
+        
+        # The validation error message to use, as a string.  If message
+        # is a Proc, call it with the args.  Otherwise, assume it is a string and
+        # return it.
+        def validation_error_message(message, *args)
+          message.is_a?(Proc) ? message.call(*args) : message
+        end
+      end
+    end
+  end
+end