This module provides validations for any Ruby class.

== Specifying Validations

There are two primary ways to implement validations

1) Placing validation methods with properties as params in your class

  require 'aequitas'

  class ProgrammingLanguage
    include Aequitas

    attr_accessor :name

    validates_presence_of :name
  end

2) (TODO) Using inferred validations on Virtus attributes, please see Aequitas::Inferred.
Note that not all validations that are provided via validation methods,
are also available as autovalidation options. If they are available,
they're functionally equivalent though.

  class ProgrammingLanguage
    include Virtus
    include Aequitas

    attribute :name, String, :required => true
  end

See Aequitas::Macros to learn about the complete collection of validation rules available.

== Validating

Aequitas validations may be manually evaluated against a resource using the
`#valid?` method, which will return true if the resource is valid,
and false if it is invalid.

== Working with Validation Errors

If an instance fails one or more validation rules, Aequitas::Violation instances
will populate the Aequitas::ViolationSet object that is available through
the #errors method.

For example:

  my_account = Account.new(:name => "Jose")
  if my_account.valid?
    # my_account is valid and has been saved
  else
    my_account.errors.each do |e|
      puts e
    end
  end

See Aequitas::ViolationSet for all you can do with the #errors method.

== Contextual Validation

Aequitas also provide a means of grouping your validations into
contexts. This enables you to run different sets of validations when you
need it. For example, an instance may require separate validation rules
depending on its state: publishing, exporting, importing and so on.

Again, using our example for pure Ruby class validations:

  class ProgrammingLanguage
    include Virtus
    include Aequitas

    attribute :name, String

    def ensure_allows_manual_memory_management
      # ...
    end

    def ensure_allows_optional_parentheses
      # ...
    end

    validates_presence_of :name
    validates_with_method :ensure_allows_optional_parentheses,     :when => [:implementing_a_dsl]
    validates_with_method :ensure_allows_manual_memory_management, :when => [:doing_system_programming]
  end

ProgrammingLanguage instance now use #valid? method with one of two context symbols:

  @ruby.valid?(:implementing_a_dsl)       # => true
  @ruby.valid?(:doing_system_programming) # => false

  @c.valid?(:implementing_a_dsl)       # => false
  @c.valid?(:doing_system_programming) # => true

Each context causes different set of validations to be triggered. If you don't
specify a context using :when, :on or :group options (they are all aliases and do
the same thing), default context name is :default. When you do model.valid? (without
specifying context explicitly), again, :default context is used. One validation
can be used in two, three or five contexts if you like:

  class Book
    include Virtus
    include Aequitas

    attribute :id,           Serial
    attribute :name,         String

    attribute :agreed_title, String
    attribute :finished_toc, Boolean

    # used in all contexts, including default
    validates_presence_of :name,         :when => [:default, :sending_to_print]
    validates_presence_of :agreed_title, :when => [:sending_to_print]

    validates_with_block :toc, :when => [:sending_to_print] do
      if self.finished_toc
        [true]
      else
        [false, "TOC must be finalized before you send a book to print"]
      end
    end
  end

In the example above, name is validated for presence in both :default context and
:sending_to_print context, while TOC related block validation and title presence validation
only take place in :sending_to_print context.