Module Scrivener::Validations
In: lib/scrivener/validations.rb

Provides a base implementation for extensible validation routines. {Scrivener::Validations} currently only provides the following assertions:

The core tenets that Scrivener::Validations advocates can be summed up in a few bullet points:

  1. Validations are much simpler and better done using composition rather than macros.
  2. Error messages should be kept separate and possibly in the view or presenter layer.
  3. It should be easy to write your own validation routine.

Other validations are simply added on a per-model or per-project basis.

@example 

  class Quote
    attr_accessor :title
    attr_accessor :price
    attr_accessor :date

    def validate
      assert_present :title
      assert_numeric :price
      assert_format  :date, /\A[\d]{4}-[\d]{1,2}-[\d]{1,2}\z
    end
  end

  s = Quote.new
  s.valid?
  # => false

  s.errors
  # => { :title => [:not_present],
         :price => [:not_numeric],
         :date  => [:format] }

Methods

assert   assert_decimal   assert_email   assert_equal   assert_format   assert_length   assert_member   assert_numeric   assert_present   assert_url   errors   valid?   validate  

Constants

URL = /\A(http|https):\/\/([a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,12}|(2 5[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3} |localhost)(:[0-9]{1,5})?(\/.*)?\z/ix
EMAIL = /\A([\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)* [\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+@ ((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[a-z])\.)+ [a-z]{2,12})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)\z/ix
DECIMAL = /\A\-?(\d+)?(\.\d+)?\z/

Public Instance methods

errors()

Hash of errors for each attribute in this model.

valid?(*args)

Check if the current model state is valid. Each call to {valid?} will reset the {errors} array.

All validations should be declared in a `validate` method.

@example 

  class Login
    attr_accessor :username
    attr_accessor :password

    def validate
      assert_present :user
      assert_present :password
    end
  end
validate(*args)

Base validate implementation. Override this method in subclasses.

Protected Instance methods

assert(value, error)

The grand daddy of all assertions. If you want to build custom assertions, or even quick and dirty ones, you can simply use this method.

@example 

  class CreatePost
    attr_accessor :slug
    attr_accessor :votes

    def validate
      assert_slug :slug
      assert votes.to_i > 0, [:votes, :not_valid]
    end

  protected
    def assert_slug(att, error = [att, :not_slug])
      assert send(att).to_s =~ /\A[a-z\-0-9]+\z/, error
    end
  end
assert_equal(att, value, error = [att, :not_equal])

Check that the attribute has the expected value. It uses === for comparison, so type checks are possible too. Note that in order to make the case equality work, the check inverts the order of the arguments: `assert_equal :foo, Bar` is translated to the expression `Bar === send(:foo)`.

@example 

  def validate
    assert_equal :status, "pending"
    assert_equal :quantity, Fixnum
  end

@param [Symbol] att The attribute you wish to verify for equality. @param [Object] value The value you want to test against. @param [Array<Symbol, Symbol>] error The error that should be returned 

                               when the validation fails.
assert_format(att, format, error = [att, :format])

Allows you to do a validation check against a regular expression. It‘s important to note that this internally calls {assert_present}, therefore you need not structure your regular expression to check for a non-empty value.

@param [Symbol] att The attribute you want to verify the format of. @param [Regexp] format The regular expression with which to compare 

                the value of att with.

@param [Array<Symbol, Symbol>] error The error that should be returned 

                               when the validation fails.
assert_numeric(att, error = [att, :not_numeric])

Checks if all the characters of an attribute is a digit.

@param [Symbol] att The attribute you wish to verify the numeric format. @param [Array<Symbol, Symbol>] error The error that should be returned 

                               when the validation fails.
assert_present(att, error = [att, :not_present])

The most basic and highly useful assertion. Simply checks if the value of the attribute is empty.

@param [Symbol] att The attribute you wish to verify the presence of. @param [Array<Symbol, Symbol>] error The error that should be returned 

                               when the validation fails.

[Validate]