Module: Sequel::Plugins::ValidationClassMethods::ClassMethods

### Home Classes Methods

### In Files

- lib/sequel/plugins/validation_class_methods.rb

### Namespace

- CLASS Sequel::Plugins::ValidationClassMethods::ClassMethods::Generator

### Methods

- #has_validations?
- #inherited
- #skip_superclass_validations
- #skip_superclass_validations?
- #validate
- #validates
- #validates_acceptance_of
- #validates_confirmation_of
- #validates_each
- #validates_format_of
- #validates_inclusion_of
- #validates_length_of
- #validates_not_string
- #validates_numericality_of
- #validates_presence_of
- #validates_uniqueness_of

### Files

- CHANGELOG
- COPYING
- README.rdoc
- advanced_associations.rdoc
- association_basics.rdoc
- cheat_sheet.rdoc
- dataset_basics.rdoc
- dataset_filtering.rdoc
- migration.rdoc
- model_hooks.rdoc
- opening_databases.rdoc
- prepared_statements.rdoc
- querying.rdoc
- reflection.rdoc
- 1.0.txt
- 1.1.txt
- 1.3.txt
- 1.4.0.txt
- 1.5.0.txt
- 2.0.0.txt
- 2.1.0.txt
- 2.10.0.txt
- 2.11.0.txt
- 2.12.0.txt
- 2.2.0.txt
- 2.3.0.txt
- 2.4.0.txt
- 2.5.0.txt
- 2.6.0.txt
- 2.7.0.txt
- 2.8.0.txt
- 2.9.0.txt
- 3.0.0.txt
- 3.1.0.txt
- 3.10.0.txt
- 3.11.0.txt
- 3.12.0.txt
- 3.2.0.txt
- 3.3.0.txt
- 3.4.0.txt
- 3.5.0.txt
- 3.6.0.txt
- 3.7.0.txt
- 3.8.0.txt
- 3.9.0.txt
- sharding.rdoc
- sql.rdoc
- virtual_rows.rdoc

### Class/Module Index

Quicksearch

- Sequel
- Sequel::ADO
- Sequel::ADO::Database
- Sequel::ADO::Dataset
- Sequel::ADO::MSSQL
- Sequel::ADO::MSSQL::DatabaseMethods
- Sequel::ADO::MSSQL::Dataset
- Sequel::AdapterNotFound
- Sequel::Amalgalite
- Sequel::Amalgalite::Database
- Sequel::Amalgalite::Dataset
- Sequel::Amalgalite::SequelTypeMap
- Sequel::BasicObject
- Sequel::BeforeHookFailed
- Sequel::ConnectionPool
- Sequel::ConnectionPool::ClassMethods
- Sequel::DB2
- Sequel::DB2::Database
- Sequel::DB2::Dataset
- Sequel::DBI
- Sequel::DBI::Database
- Sequel::DBI::Dataset
- Sequel::DataObjects
- Sequel::DataObjects::Database
- Sequel::DataObjects::Dataset
- Sequel::DataObjects::MySQL
- Sequel::DataObjects::MySQL::DatabaseMethods
- Sequel::DataObjects::MySQL::Dataset
- Sequel::DataObjects::Postgres
- Sequel::DataObjects::Postgres::AdapterMethods
- Sequel::DataObjects::Postgres::DatabaseMethods
- Sequel::DataObjects::Postgres::Dataset
- Sequel::DataObjects::SQLite
- Sequel::DataObjects::SQLite::DatabaseMethods
- Sequel::DataObjects::SQLite::Dataset
- Sequel::Database
- Sequel::DatabaseConnectionError
- Sequel::DatabaseDisconnectError
- Sequel::DatabaseError
- Sequel::Dataset
- Sequel::Dataset::ArgumentMapper
- Sequel::Dataset::Pagination
- Sequel::Dataset::PreparedStatementMethods
- Sequel::Dataset::QueryBlockCopy
- Sequel::Dataset::StoredProcedureMethods
- Sequel::Dataset::StoredProcedures
- Sequel::Dataset::UnnumberedArgumentMapper
- Sequel::Error
- Sequel::Error::AdapterNotFound
- Sequel::Error::InvalidOperation
- Sequel::Error::InvalidValue
- Sequel::Error::PoolTimeoutError
- Sequel::Error::Rollback
- Sequel::Firebird
- Sequel::Firebird::Database
- Sequel::Firebird::Dataset
- Sequel::Inflections
- Sequel::Informix
- Sequel::Informix::Database
- Sequel::Informix::Dataset
- Sequel::IntegerMigrator
- Sequel::InvalidOperation
- Sequel::InvalidValue
- Sequel::JDBC
- Sequel::JDBC::AS400
- Sequel::JDBC::AS400::DatabaseMethods
- Sequel::JDBC::AS400::Dataset
- Sequel::JDBC::Database
- Sequel::JDBC::Dataset
- Sequel::JDBC::Dataset::PreparedStatementMethods
- Sequel::JDBC::Dataset::StoredProcedureMethods
- Sequel::JDBC::H2
- Sequel::JDBC::H2::DatabaseMethods
- Sequel::JDBC::H2::Dataset
- Sequel::JDBC::JavaLang
- Sequel::JDBC::JavaSQL
- Sequel::JDBC::JavaxNaming
- Sequel::JDBC::MSSQL
- Sequel::JDBC::MSSQL::DatabaseMethods
- Sequel::JDBC::MSSQL::Dataset
- Sequel::JDBC::MySQL
- Sequel::JDBC::MySQL::DatabaseMethods
- Sequel::JDBC::MySQL::Dataset
- Sequel::JDBC::Oracle
- Sequel::JDBC::Oracle::DatabaseMethods
- Sequel::JDBC::Oracle::Dataset
- Sequel::JDBC::Postgres
- Sequel::JDBC::Postgres::AdapterMethods
- Sequel::JDBC::Postgres::DatabaseMethods
- Sequel::JDBC::Postgres::Dataset
- Sequel::JDBC::SQLite
- Sequel::JDBC::SQLite::DatabaseMethods
- Sequel::JDBC::SQLite::Dataset
- Sequel::LiteralString
- Sequel::LooserTypecasting
- Sequel::MSSQL
- Sequel::MSSQL::DatabaseMethods
- Sequel::MSSQL::DatasetMethods
- Sequel::Metaprogramming
- Sequel::Migration
- Sequel::MigrationDSL
- Sequel::Migrator
- Sequel::Migrator::Error
- Sequel::Model
- Sequel::Model::Associations
- Sequel::Model::Associations::AssociationDatasetMethods
- Sequel::Model::Associations::AssociationReflection
- Sequel::Model::Associations::ClassMethods
- Sequel::Model::Associations::DatasetMethods
- Sequel::Model::Associations::InstanceMethods
- Sequel::Model::Associations::ManyToManyAssociationReflection
- Sequel::Model::Associations::ManyToOneAssociationReflection
- Sequel::Model::Associations::OneToManyAssociationReflection
- Sequel::Model::Associations::OneToOneAssociationReflection
- Sequel::Model::ClassMethods
- Sequel::Model::DatasetMethods
- Sequel::Model::Errors
- Sequel::Model::InstanceMethods
- Sequel::MySQL
- Sequel::MySQL::Database
- Sequel::MySQL::DatabaseMethods
- Sequel::MySQL::Dataset
- Sequel::MySQL::Dataset::CallableStatementMethods
- Sequel::MySQL::Dataset::PreparedStatementMethods
- Sequel::MySQL::Dataset::StoredProcedureMethods
- Sequel::MySQL::DatasetMethods
- Sequel::NamedTimezones
- Sequel::NoExistingObject
- Sequel::NotImplemented
- Sequel::ODBC
- Sequel::ODBC::Database
- Sequel::ODBC::Dataset
- Sequel::ODBC::MSSQL
- Sequel::ODBC::MSSQL::DatabaseMethods
- Sequel::ODBC::MSSQL::Dataset
- Sequel::OpenBase
- Sequel::OpenBase::Database
- Sequel::OpenBase::Dataset
- Sequel::Oracle
- Sequel::Oracle::Database
- Sequel::Oracle::DatabaseMethods
- Sequel::Oracle::Dataset
- Sequel::Oracle::DatasetMethods
- Sequel::Plugins
- Sequel::Plugins::ActiveModel
- Sequel::Plugins::ActiveModel::InstanceMethods
- Sequel::Plugins::AssociationDependencies
- Sequel::Plugins::AssociationDependencies::ClassMethods
- Sequel::Plugins::AssociationDependencies::InstanceMethods
- Sequel::Plugins::AssociationPks
- Sequel::Plugins::AssociationPks::ClassMethods
- Sequel::Plugins::AssociationProxies
- Sequel::Plugins::AssociationProxies::AssociationProxy
- Sequel::Plugins::AssociationProxies::ClassMethods
- Sequel::Plugins::BooleanReaders
- Sequel::Plugins::BooleanReaders::ClassMethods
- Sequel::Plugins::Caching
- Sequel::Plugins::Caching::ClassMethods
- Sequel::Plugins::Caching::InstanceMethods
- Sequel::Plugins::ClassTableInheritance
- Sequel::Plugins::ClassTableInheritance::ClassMethods
- Sequel::Plugins::ClassTableInheritance::InstanceMethods
- Sequel::Plugins::Composition
- Sequel::Plugins::Composition::ClassMethods
- Sequel::Plugins::Composition::InstanceMethods
- Sequel::Plugins::ForceEncoding
- Sequel::Plugins::ForceEncoding::ClassMethods
- Sequel::Plugins::ForceEncoding::InstanceMethods
- Sequel::Plugins::HookClassMethods
- Sequel::Plugins::HookClassMethods::ClassMethods
- Sequel::Plugins::HookClassMethods::InstanceMethods
- Sequel::Plugins::IdentityMap
- Sequel::Plugins::IdentityMap::ClassMethods
- Sequel::Plugins::IdentityMap::InstanceMethods
- Sequel::Plugins::InstanceFilters
- Sequel::Plugins::InstanceFilters::Error
- Sequel::Plugins::InstanceFilters::InstanceMethods
- Sequel::Plugins::InstanceHooks
- Sequel::Plugins::InstanceHooks::InstanceMethods
- Sequel::Plugins::LazyAttributes
- Sequel::Plugins::LazyAttributes::ClassMethods
- Sequel::Plugins::LazyAttributes::InstanceMethods
- Sequel::Plugins::ManyThroughMany
- Sequel::Plugins::ManyThroughMany::ClassMethods
- Sequel::Plugins::ManyThroughMany::ManyThroughManyAssociationReflection
- Sequel::Plugins::NestedAttributes
- Sequel::Plugins::NestedAttributes::ClassMethods
- Sequel::Plugins::NestedAttributes::InstanceMethods
- Sequel::Plugins::OptimisticLocking
- Sequel::Plugins::OptimisticLocking::ClassMethods
- Sequel::Plugins::OptimisticLocking::InstanceMethods
- Sequel::Plugins::RcteTree
- Sequel::Plugins::Schema
- Sequel::Plugins::Schema::ClassMethods
- Sequel::Plugins::Serialization
- Sequel::Plugins::Serialization::ClassMethods
- Sequel::Plugins::Serialization::InstanceMethods
- Sequel::Plugins::Sharding
- Sequel::Plugins::Sharding::ClassMethods
- Sequel::Plugins::Sharding::DatasetMethods
- Sequel::Plugins::Sharding::InstanceMethods
- Sequel::Plugins::SingleTableInheritance
- Sequel::Plugins::SingleTableInheritance::ClassMethods
- Sequel::Plugins::SingleTableInheritance::InstanceMethods
- Sequel::Plugins::SkipCreateRefresh
- Sequel::Plugins::SkipCreateRefresh::InstanceMethods
- Sequel::Plugins::StringStripper
- Sequel::Plugins::StringStripper::InstanceMethods
- Sequel::Plugins::Subclasses
- Sequel::Plugins::Subclasses::ClassMethods
- Sequel::Plugins::TacticalEagerLoading
- Sequel::Plugins::TacticalEagerLoading::DatasetMethods
- Sequel::Plugins::TacticalEagerLoading::InstanceMethods
- Sequel::Plugins::Timestamps
- Sequel::Plugins::Timestamps::ClassMethods
- Sequel::Plugins::Timestamps::InstanceMethods
- Sequel::Plugins::Touch
- Sequel::Plugins::Touch::ClassMethods
- Sequel::Plugins::Touch::InstanceMethods
- Sequel::Plugins::TypecastOnLoad
- Sequel::Plugins::TypecastOnLoad::ClassMethods
- Sequel::Plugins::TypecastOnLoad::InstanceMethods
- Sequel::Plugins::UpdatePrimaryKey
- Sequel::Plugins::UpdatePrimaryKey::ClassMethods
- Sequel::Plugins::UpdatePrimaryKey::InstanceMethods
- Sequel::Plugins::ValidationClassMethods
- Sequel::Plugins::ValidationClassMethods::ClassMethods
- Sequel::Plugins::ValidationClassMethods::ClassMethods::Generator
- Sequel::Plugins::ValidationClassMethods::InstanceMethods
- Sequel::Plugins::ValidationHelpers
- Sequel::Plugins::ValidationHelpers::InstanceMethods
- Sequel::PoolTimeout
- Sequel::Postgres
- Sequel::Postgres::Adapter
- Sequel::Postgres::AdapterMethods
- Sequel::Postgres::Database
- Sequel::Postgres::DatabaseMethods
- Sequel::Postgres::Dataset
- Sequel::Postgres::Dataset::ArgumentMapper
- Sequel::Postgres::Dataset::BindArgumentMethods
- Sequel::Postgres::Dataset::PreparedStatementMethods
- Sequel::Postgres::DatasetMethods
- Sequel::Postgres::DatasetMethods::PreparedStatementMethods
- Sequel::PrettyTable
- Sequel::Progress
- Sequel::Progress::DatabaseMethods
- Sequel::Progress::DatasetMethods
- Sequel::Rollback
- Sequel::SQL
- Sequel::SQL::AliasMethods
- Sequel::SQL::AliasedExpression
- Sequel::SQL::BitwiseMethods
- Sequel::SQL::Blob
- Sequel::SQL::BooleanConstant
- Sequel::SQL::BooleanExpression
- Sequel::SQL::BooleanMethods
- Sequel::SQL::CaseExpression
- Sequel::SQL::Cast
- Sequel::SQL::CastMethods
- Sequel::SQL::ColumnAll
- Sequel::SQL::ComplexExpression
- Sequel::SQL::ComplexExpressionMethods
- Sequel::SQL::Constant
- Sequel::SQL::Constants
- Sequel::SQL::Expression
- Sequel::SQL::Function
- Sequel::SQL::GenericComplexExpression
- Sequel::SQL::GenericExpression
- Sequel::SQL::Identifier
- Sequel::SQL::IdentifierMethods
- Sequel::SQL::InequalityMethods
- Sequel::SQL::JoinClause
- Sequel::SQL::JoinOnClause
- Sequel::SQL::JoinUsingClause
- Sequel::SQL::NegativeBooleanConstant
- Sequel::SQL::NoBooleanInputMethods
- Sequel::SQL::NumericExpression
- Sequel::SQL::NumericMethods
- Sequel::SQL::OrderMethods
- Sequel::SQL::OrderedExpression
- Sequel::SQL::PlaceholderLiteralString
- Sequel::SQL::QualifiedIdentifier
- Sequel::SQL::QualifyingMethods
- Sequel::SQL::SQLArray
- Sequel::SQL::StringConcatenationMethods
- Sequel::SQL::StringExpression
- Sequel::SQL::StringMethods
- Sequel::SQL::Subscript
- Sequel::SQL::SubscriptMethods
- Sequel::SQL::VirtualRow
- Sequel::SQL::Window
- Sequel::SQL::WindowFunction
- Sequel::SQLite
- Sequel::SQLite::Database
- Sequel::SQLite::DatabaseMethods
- Sequel::SQLite::Dataset
- Sequel::SQLite::Dataset::ArgumentMapper
- Sequel::SQLite::Dataset::PreparedStatementMethods
- Sequel::SQLite::DatasetMethods
- Sequel::Schema
- Sequel::Schema::AlterTableGenerator
- Sequel::Schema::Generator
- Sequel::ShardedSingleConnectionPool
- Sequel::ShardedThreadedConnectionPool
- Sequel::SimpleMigration
- Sequel::SingleConnectionPool
- Sequel::ThreadLocalTimezones
- Sequel::ThreadedConnectionPool
- Sequel::TimestampMigrator
- Sequel::Timezones
- Sequel::ValidationFailed
- String
- String::Inflections
- Array
- FalseClass
- Hash
- NilClass
- Numeric
- Object
- PGconn
- PGresult
- Proc
- Symbol
- TrueClass

No matching classes.

# Sequel::Plugins::ValidationClassMethods::ClassMethods

### Attributes

validations[R]

A hash of associations for this model class. Keys are column symbols, values are arrays of validation procs.

### Public Instance Methods

has_validations?() click to toggle source

Returns true if validations are defined.

    # File lib/sequel/plugins/validation_class_methods.rb, line 48
    def has_validations?
      !validations.empty?
    end

inherited(subclass) click to toggle source

Setup the validations hash in the subclass

    # File lib/sequel/plugins/validation_class_methods.rb, line 53
    def inherited(subclass)
      super
      subclass.class_eval do
        @validation_mutex = Mutex.new
        @validations = {}
      end
    end

skip_superclass_validations() click to toggle source

Instructs the model to skip validations defined in superclasses

    # File lib/sequel/plugins/validation_class_methods.rb, line 62
    def skip_superclass_validations
      @skip_superclass_validations = true
    end

skip_superclass_validations?() click to toggle source

Instructs the model to skip validations defined in superclasses

    # File lib/sequel/plugins/validation_class_methods.rb, line 67
    def skip_superclass_validations?
      defined?(@skip_superclass_validations) && @skip_superclass_validations
    end

validate(o) click to toggle source

Validates the given instance.

    # File lib/sequel/plugins/validation_class_methods.rb, line 91
    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(&block) click to toggle source

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

    # File lib/sequel/plugins/validation_class_methods.rb, line 86
    def validates(&block)
      Generator.new(self, &block)
    end

validates_acceptance_of(*atts) click to toggle source

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’)

    # File lib/sequel/plugins/validation_class_methods.rb, line 111
    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(*atts) click to toggle source

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’)

    # File lib/sequel/plugins/validation_class_methods.rb, line 134
    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

validates_each(*atts, &block) click to toggle source

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.

    # File lib/sequel/plugins/validation_class_methods.rb, line 168
    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_format_of(*atts) click to toggle source

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).

    # File lib/sequel/plugins/validation_class_methods.rb, line 198
    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_inclusion_of(*atts) click to toggle source

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>’)

    # File lib/sequel/plugins/validation_class_methods.rb, line 324
    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_length_of(*atts) click to toggle source

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’)

    # File lib/sequel/plugins/validation_class_methods.rb, line 226
    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_not_string(*atts) click to toggle source

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)

    # File lib/sequel/plugins/validation_class_methods.rb, line 260
    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_numericality_of(*atts) click to toggle source

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)

    # File lib/sequel/plugins/validation_class_methods.rb, line 284
    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_presence_of(*atts) click to toggle source

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’)

    # File lib/sequel/plugins/validation_class_methods.rb, line 308
    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_uniqueness_of(*atts) click to toggle source

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’)

    # File lib/sequel/plugins/validation_class_methods.rb, line 352
    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

[Validate]

Generated with the Darkfish Rdoc Generator 2.