required, required_when

   has_field 'section' => ( required => 1,
       messages => { required => 'Please provide a section' } );

Note that a required flag on a subfield -- a field inside a compound field or repeatable field -- does not cause the containing field to be required. You need to set 'required' all the way up, if that's the behavior that you want.

If a field is empty and *not* required, no other field validation will be performed unless the 'validate_when_empty' flag (see below) is set. The form's 'validate' method, however, will always be called.

There is also the 'required_when' attribute, which works the same way as the 'when' key on the apply actions.

    has_field 'fee' => ( required_when => { 'fie' => 2 } );

When a 'required' or 'required_when' check fails, a 'missing' flag is set in the result:

    if ( $field->missing ) { ... }

range_start, range_end

unique

validate_when_empty

validate_method

    has_field 'fox' => ( validate_method => \&check_fox );
    sub check_fox {
        my $self = shift; # self is the fox field
        unless( $self->value eq .... ) {
            $self->add_error('....');
        }
    }

validate_<field_name>

    has_field 'cat';
    sub validate_cat {
        my ( $self, $field ) = @_; # self is the form
        unless ( $field->value eq  ... ) {
            $field->add_error( '...' );
        }
    }

If the field name has periods in it, they should be replaced with underscores.

form validate method

    sub validate {
        my $self = shift;
        $self->field('foo')->add_error('....')
            if( $self->field('foo')->value eq '..' &&
                    $self->field('bar')->value eq '..' );
    }

field validate method

    package MyApp::Form::Field::Custom;
    use HTML::FormHandler::Moose;
    extends 'HTML::FormHandler::Field'; # or a subclass of Field

    sub validate {
        ....
    }

Moose types

FormHandler supplies a library of Moose types in HTML::FormHandler::Types.

    use HTML::FormHandler::Types ('NotAllDigits');
    has_field 'foo' => ( apply => [ NotAllDigits ] );

You can create your own library of types, too. Or you can create a type constraint in the form:

  use Moose::Util::TypeConstraints;
  subtype 'GreaterThan10'
     => as 'Int'
     => where { $_ > 10 }
     => message { "This number ($_) is not greater than 10" };

  has_field 'text_gt' => ( apply=> [ 'GreaterThan10' ] );

Moose types can also be used for their coercions to do transformations.

  subtype 'MyInt'
      => as 'Int';
  coerce 'MyInt'
      => from 'MyStr'
      => via { return $1 if /(\d+)/ };

You can also use the 'type' keyword with a Moose type if you want to change the message:

    has_field 'text_gt' => ( apply => [
        { type => 'GreaterThan10',
          message => 'Number is too small' } ] );

transform

   has_field 'another_field' => (
      apply => [ { transform => sub{ sprintf '<%.1g>', $_[0] } } ]
   );

Note that transformed values are not displayed in the HTML form unless the 'fif_from_value' flag is set. The transformed values are saved to the database or returned in "$form->value".

'check' regex

   has_field 'some_field' => (
      apply => [ { check => qr/aaa/, message => 'Must contain aaa' } ],
   );

You can use regex libraries like Regexp::Common too:

    use Regexp::Common ('URI');
    ...
    has_field 'my_url' => ( apply => [
        { check => qr/$RE{URI}{HTTP}/,
           message => 'Invalid URL' } ] );

'check' arrayref (matches)

   has_field 'set_error' => (
      apply => [
         { check   => [ 'abc', 'bbb' ],
            message => 'Must be "aaa" or "bbb"' }
      ]
   );

'check' coderef

   has_field 'callback_pass' => (
      apply => [
         { check => \&check_callback_pass,
             message => 'Must contain number greater than 10', }
       ]
   );
   sub check_callback_pass {
       my ( $value, $field ) = @_;
       if( $value =~ /(\d+)/ ) {
           return $1 > 10;
       }
   }

message

   has_field 'message_sub' => (
      apply => [
         { check   => [ 'abc' ],
            message => \&err_message }
      ]
   );
   sub err_message {
       my ($value, $field ) = @_;
       return $field->name . ': Must be "abc"';
   }
   has_field 'message_arrayref' => (
      apply => [ { check => qr/aaa/,
          message => ['Must contain [_1]', 'aaa'] } ],
   );
   has_field 'my_moose_type_field' => (
      apply => [ { type => SomeType,
         message => 'Invalid ...' } ] );

actions in a field class

   package MyApp::Field::Test;
   use HTML::FormHandler::Moose;
   extends 'HTML::FormHandler::Field;

   apply [ 'SomeConstraint', { check => ..., message => .... } ];

   1;

Actions specified with apply are cumulative. Actions may be specified in field classes and additional actions added in the 'has_field' declaration.

You can see examples of field classes with 'apply' actions in the source for HTML::FormHandler::Field::Money and HTML::FormHandler::Field::Email, and in t/constraints.t.