File Coverage

blib/lib/Form/Tiny/FieldDefinition.pm

Criterion	Covered	Total	%
statement	93	93	100.0
branch	40	44	90.9
condition	18	24	75.0
subroutine	19	19	100.0
pod	2	6	33.3
total	172	186	92.4

package Form::Tiny::FieldDefinition;
$Form::Tiny::FieldDefinition::VERSION = '2.21';
use v5.10;
use strict;
use warnings;
use Moo;
use Types::Standard qw(Enum Bool HasMethods CodeRef InstanceOf HashRef);
use Types::Common::String qw(NonEmptySimpleStr);
use Types::TypeTiny qw(StringLike);
use Carp qw(croak);
use Scalar::Util qw(blessed);

use Form::Tiny::Utils qw(try has_form_meta);
use Form::Tiny::Error;
use Form::Tiny::Path;

has 'name' => (
	is => 'ro',
	isa => NonEmptySimpleStr,
	required => 1,
);

has 'name_path' => (
	is => 'ro',
	isa => InstanceOf ['Form::Tiny::Path'],
	reader => 'get_name_path',
	init_arg => undef,
	lazy => 1,
	default => sub { Form::Tiny::Path->from_name(shift->name) },
);

has 'required' => (
	is => 'ro',
	isa => Enum [0, 1, 'soft', 'hard'],
	writer => 'set_required',
	default => sub { 0 },
);

has 'type' => (
	is => 'ro',
	isa => HasMethods ['validate', 'check'],
	writer => 'set_type',
	predicate => 'has_type',
);

has 'addons' => (
	is => 'ro',
	writer => 'set_addons',
	isa => HashRef,
	default => sub { {} },
	init_arg => undef,
);

has 'coerce' => (
	is => 'ro',
	isa => Bool | CodeRef,
	writer => 'set_coercion',
	default => sub { 0 },
);

has 'adjust' => (
	is => 'ro',
	isa => CodeRef,
	predicate => 'is_adjusted',
	writer => 'set_adjustment',
);

has 'default' => (
	is => 'ro',
	isa => CodeRef,
	writer => 'set_default',
	predicate => 'has_default',
);

has 'message' => (
	is => 'ro',
	isa => StringLike,
	writer => 'set_message',
	predicate => 'has_message',
);

has 'data' => (
	is => 'ro',
	writer => 'set_data',
	predicate => 'has_data',
);

has '_subform' => (
	is => 'ro',
	isa => Bool,
	reader => 'is_subform',
	lazy => 1,
	default => sub { $_[0]->has_type && has_form_meta($_[0]->type) },
	init_arg => undef,
);

sub BUILD
{
	my ($self, $args) = @_;

	if ($self->coerce && ref $self->coerce ne 'CODE') {

		# checks for coercion == 1
		my $t = $self->type;
		croak 'type doesn\'t provide coercion'
			if !$self->has_type
			|| !($t->can('coerce') && $t->can('has_coercion') && $t->has_coercion);
	}

	if ($self->has_default) {

		croak 'default value for an array field is unsupported'
			if scalar grep { $_ } @{$self->get_name_path->meta_arrays};
	}
}

sub hard_required
{
	my ($self) = @_;

	return $self->required eq '1' || $self->required eq 'hard';
}

sub get_coerced
{
	my ($self, $form, $value) = @_;
	my $coerce = $self->coerce;

	if ($coerce) {
		my $error = try sub {
			if (ref $coerce eq 'CODE') {
				$value = $coerce->($form, $value);
			}
			else {
				$value = $self->type->coerce($value);
			}
		};

		if ($error) {
			$form->add_error(
				Form::Tiny::Error::DoesNotValidate->new(
					{
						field => $self->name,
						error => $self->has_message ? $self->message : $error,
					}
				)
			);
		}
	}

	return $value;
}

sub get_adjusted
{
	my ($self, $form, $value) = @_;

	# NOTE: subform must be already validated at this stage
	$value = $self->type->fields
		if $self->is_subform;

	return $value unless $self->is_adjusted;
	return $self->adjust->($form, $value);
}

sub get_default
{
	my ($self, $form) = @_;

	croak 'no default value set but was requested'
		unless $self->has_default;

	my $default = $self->default->($form);
	if ($self->is_subform) {
		my $subform = $self->type;
		croak 'subform default input is not valid'
			unless $subform->check($default);

		$default = $subform->fields;
	}

	return $default;
}

sub validate
{
	my ($self, $form, $value) = @_;

	my @errors;

	if ($self->has_type) {
		if ($self->has_message) {
			push @errors, $self->message
				if !$self->type->check($value);
		}
		else {
			my $error = $self->type->validate($value);
			push @errors, $error
				if defined $error;
		}
	}

	if (@errors == 0 && (my $validators = $self->addons->{validators})) {
		for my $validator (@{$validators}) {
			my ($message, $code) = @{$validator};

			if (!$code->($form, $value)) {
				push @errors, $message;
			}
		}
	}

	for my $error (@errors) {
		if (ref $error eq 'ARRAY' && $self->is_subform) {
			foreach my $exception (@$error) {
				my $class = 'Form::Tiny::Error::DoesNotValidate';
				if (defined blessed $exception && $exception->isa('Form::Tiny::Error')) {
					$class = 'Form::Tiny::Error::NestedFormError';

					my $path = $self->get_name_path;
					$path = $path->clone->append_path(
						$self->type->_ft_find_field($exception->field)->get_name_path
					) if defined $exception->field;

					$exception->set_field($path->join);
				}

				$form->add_error(
					$class->new(
						field => $self->name,
						error => $exception,
					)
				);
			}
		}
		else {
			$form->add_error(
				Form::Tiny::Error::DoesNotValidate->new(
					{
						field => $self->name,
						error => $error,
					}
				)
			);
		}
	}

	return @errors == 0;
}

1;

__END__