use strict;
use warnings;
use Test::More;
# type || p1 fif || p1 value || p2 validation || p2 fif || p2 value
# (1) none init_obj init_obj params params params
# (2) infl init_obj init_obj inflated params inflated
# (3) defl deflated init_obj params params params
# (4) defl-ffv deflated init_obj params deflated params
# (5) infl-defl deflated init_obj inflated params inflated
# (6) infl_def inflated(d) inflated(d) params params params
# (7) defl_val init_obj init_obj params params deflated(v)
# (8) def-val inflated(d) inflated(d) params params deflated(v)
# inflated => 'inflate_method'
# deflated => 'deflate_method'
# inflated(d) => 'inflate_default_method'
# deflated(v) => 'deflate_value_method'
# An inflation method changes the format of the value used by validation
# A deflation method changes the format of the fill-in-form string
# These two are "conveniences" for munging data passed in and out of a form
# The same effect could be achieved by modifying the value in the init_object or item
# before passing it in, and modifying it once returned, so it's primarily
# useful for database rows.
#
# An inflate_default method changes the 'value' retrieved from a default source
# (default, init_object, item)
# A deflate_value method changes the format of the value available after validation
{
# plain field with no inflation or deflation
# type || p1 fif || p1 value || p2 validation || p2 fif || p2 value
# none init_obj init_obj params params params
{
package Test::Form1;
use HTML::FormHandler::Moose;
extends 'HTML::FormHandler';
has_field 'foo';
sub validate_foo {
my ( $self, $field ) = @_;
$self->add_error unless $field->value eq 'fromparams';
}
}
my $form = Test::Form1->new;
my $init_obj = { foo => 'initialfoo' };
my $params = { foo => 'fromparams' };
$form->process( init_object => $init_obj, params => {} );
is_deeply( $form->fif, $init_obj, 'fif matches init_object' );
is_deeply( $form->value, $init_obj, 'value matches init_object' );
$form->process( init_object => $init_obj, params => $params );
ok( $form->validated, 'form validated' );
is_deeply( $form->fif, $params, 'fif matches params' );
is_deeply( $form->value, $params, 'value matches params' );
}
{
# field with only an inflation
# value for validation is inflated; value returned is inflated;
# type || p1 fif || p1 value || p2 validation || p2 fif || p2 value
# infl init_obj init_obj inflated params inflated
{
package Test::Form2;
use HTML::FormHandler::Moose;
extends 'HTML::FormHandler';
has_field 'foo' => ( inflate_method => \&inflate_foo );
sub inflate_foo { 'inflatedfoo' }
sub validate_foo {
my ( $self, $field ) = @_;
$self->add_error unless $field->value eq 'inflatedfoo';
}
}
my $form = Test::Form2->new;
my $init_obj = { foo => 'initialfoo' };
my $params = { foo => 'fromparams' };
$form->process( init_object => $init_obj, params => {} );
is_deeply( $form->fif, $init_obj, 'fif matches init_object' );
is_deeply( $form->value, $init_obj, 'value matches init_object' );
$form->process( init_object => $init_obj, params => $params );
ok( $form->validated, 'form validated' );
is_deeply( $form->fif, $params, 'fif matches params' );
is_deeply( $form->value, { foo => 'inflatedfoo' }, 'value is inflated' );
}
{
# field with only a deflation
# type || p1 fif || p1 value || p2 validation || p2 fif || p2 value
# defl deflated init_obj params params params
{
package Test::Form3;
use HTML::FormHandler::Moose;
extends 'HTML::FormHandler';
has_field 'foo' => ( deflate_method => \&deflate_foo );
sub deflate_foo { 'deflatedfoo' }
sub validate_foo {
my ( $self, $field ) = @_;
$self->add_error unless $field->value eq 'fromparams';
}
}
my $form = Test::Form3->new;
my $init_obj = { foo => 'initialfoo' };
my $params = { foo => 'fromparams' };
$form->process( init_object => $init_obj, params => {} );
is_deeply( $form->fif, { foo => 'deflatedfoo' }, 'fif is deflated foo' );
is_deeply( $form->value, { foo => 'initialfoo' }, 'value is initial foo' );
$form->process( init_object => $init_obj, params => $params );
ok( $form->validated, 'form validated' );
is_deeply( $form->fif, $params, 'fif matches params' );
is_deeply( $form->value, $params, 'value matches params' );
}
{
# field with only a deflation; 'fif_from_value' => 1
# type || p1 fif || p1 value || p2 validation || p2 fif || p2 value
# defl-ffv deflated init_obj params deflated params
{
package Test::Form4;
use HTML::FormHandler::Moose;
extends 'HTML::FormHandler';
has_field 'foo' => ( deflate_method => \&deflate_foo,
'fif_from_value' => 1 );
sub deflate_foo { 'deflatedfoo' }
sub validate_foo {
my ( $self, $field ) = @_;
$self->add_error unless $field->value eq 'fromparams';
}
}
my $form = Test::Form4->new;
my $init_obj = { foo => 'initialfoo' };
my $params = { foo => 'fromparams' };
$form->process( init_object => $init_obj, params => {} );
is_deeply( $form->fif, { foo => 'deflatedfoo' }, 'fif is deflated foo' );
is_deeply( $form->value, { foo => 'initialfoo' }, 'value is initial foo' );
$form->process( init_object => $init_obj, params => $params );
ok( $form->validated, 'form validated' );
is_deeply( $form->fif, { foo => 'deflatedfoo' }, 'fif is deflated' );
is_deeply( $form->value, $params, 'value matches params' );
}
{
# field with an inflation and deflation
# both fif and value are 'deflated'.
# type || p1 fif || p1 value || p2 validation || p2 fif || p2 value
# infl-defl deflated init_obj inflated params inflated
{
package Test::Form5;
use HTML::FormHandler::Moose;
extends 'HTML::FormHandler';
has_field 'foo' => ( inflate_method => \&inflate_foo, deflate_method => \&deflate_foo );
sub inflate_foo { 'inflatedfoo' }
sub deflate_foo { 'deflatedfoo' }
sub validate_foo {
my ( $self, $field ) = @_;
$self->add_error unless $field->value eq 'inflatedfoo';
}
}
my $form = Test::Form5->new;
my $init_obj = { foo => 'initialfoo' };
my $params = { foo => 'fromparams' };
$form->process( init_object => $init_obj, params => {} );
is_deeply( $form->fif, { foo => 'deflatedfoo' }, 'fif is deflated' );
is_deeply( $form->value, $init_obj, 'value is initial' );
$form->process( init_object => $init_obj, params => $params );
ok( $form->validated, 'form validated' );
is_deeply( $form->fif, $params, 'fif matches params' );
is_deeply( $form->value, { foo => 'inflatedfoo' }, 'value is inflated' );
}
{
# field with only 'inflate_default'
# type || p1 fif || p1 value || p2 validation || p2 fif || p2 value
# infl_def inflated inflated params params params
{
package Test::Form6;
use HTML::FormHandler::Moose;
extends 'HTML::FormHandler';
has_field 'foo' => ( inflate_default_method => sub { 'infl_def_foo' } );
sub validate_foo {
my ( $self, $field ) = @_;
$self->add_error unless $field->value eq 'fromparams';
}
}
my $form = Test::Form6->new;
my $init_obj = { foo => 'initialfoo' };
my $params = { foo => 'fromparams' };
$form->process( init_object => $init_obj, params => {} );
is_deeply( $form->fif, { foo => 'infl_def_foo' }, 'fif matches inflate_default' );
is_deeply( $form->value, { foo => 'infl_def_foo' }, 'value matches init_object' );
$form->process( init_object => $init_obj, params => $params );
ok( $form->validated, 'form validated' );
is_deeply( $form->fif, $params, 'fif matches params' );
is_deeply( $form->value, $params, 'value matches params' );
}
{
# field with only a 'deflate_value' method
# type || p1 fif || p1 value || p2 validation || p2 fif || p2 value
# defl_val init_obj init_obj params params deflated
{
package Test::Form7;
use HTML::FormHandler::Moose;
extends 'HTML::FormHandler';
has_field 'foo' => ( deflate_value_method => sub { 'defl_val_foo' } );
sub validate_foo {
my ( $self, $field ) = @_;
$self->add_error unless $field->value eq 'fromparams';
}
}
my $form = Test::Form7->new;
my $init_obj = { foo => 'initialfoo' };
my $params = { foo => 'fromparams' };
$form->process( init_object => $init_obj, params => {} );
is_deeply( $form->fif, $init_obj, 'fif matches init_object' );
is_deeply( $form->value, $init_obj, 'value matches init_object' );
$form->process( init_object => $init_obj, params => $params );
ok( $form->validated, 'form validated' );
is_deeply( $form->fif, $params, 'fif matches params' );
is_deeply( $form->value, { foo => 'defl_val_foo' }, 'value is deflated by deflate_value' );
}
{
# field with 'inflate_default' and a 'deflate_value' method
# type || p1 fif || p1 value || p2 validation || p2 fif || p2 value
# def-val inflated inflated params params deflated
{
package Test::Form8;
use HTML::FormHandler::Moose;
extends 'HTML::FormHandler';
has_field 'foo' => ( inflate_default_method => sub { 'infl_def_foo' },
deflate_value_method => sub { 'defl_val_foo' } );
sub validate_foo {
my ( $self, $field ) = @_;
$self->add_error unless $field->value eq 'fromparams';
}
}
my $form = Test::Form8->new;
my $init_obj = { foo => 'initialfoo' };
my $params = { foo => 'fromparams' };
$form->process( init_object => $init_obj, params => {} );
is_deeply( $form->fif, { foo => 'infl_def_foo' }, 'fif matches init_object' );
is_deeply( $form->value, { foo => 'infl_def_foo' }, 'value matches init_object' );
$form->process( init_object => $init_obj, params => $params );
ok( $form->validated, 'form validated' );
is_deeply( $form->fif, $params, 'fif matches params' );
is_deeply( $form->value, { foo => 'defl_val_foo' }, 'value from deflate_value' );
}
done_testing;