view release on metacpan or  search on metacpan

lib/Form/Tiny/Form.pm  view on Meta::CPAN

{
	my ($self, $def, $out_ref) = @_;

	my $current = $$out_ref;

	# We got the parameter, now we have to check if it is not empty
	# Even if it is, it may still be handled if isn't hard-required
	if (ref $current || length($current // '') || !$def->hard_required) {

		# coerce, validate, adjust
		$current = $def->get_coerced($self, $current);
		if ($def->validate($self, $current)) {
			$current = $def->get_adjusted($self, $current);
		}

		$$out_ref = $current;

		return 1;
	}

	return;
}

### OPTIMIZATION: detect and use faster route for flat forms

sub _ft_validate_flat
{
	my ($self, $fields, $dirty, $inline_hook) = @_;

	foreach my $validator (@{$self->field_defs}) {
		my $curr_f = $validator->name;

		if (exists $fields->{$curr_f}) {
			$dirty->{$curr_f} = $inline_hook
				? $inline_hook->($self, $validator, $fields->{$curr_f})
				: $fields->{$curr_f}
				;

			next if $self->_ft_mangle_field($validator, \$dirty->{$curr_f});
		}

		# for when it didn't pass the existence test
		if ($validator->has_default) {
			$dirty->{$curr_f} = $validator->get_default($self);
		}
		elsif ($validator->required) {
			$self->add_error($self->form_meta->build_error(Required => field_def => $validator));
		}
	}
}

sub _ft_validate_nested
{
	my ($self, $fields, $dirty, $inline_hook) = @_;

	foreach my $validator (@{$self->field_defs}) {
		my $current_data = Form::Tiny::Utils::_find_field($fields, $validator);
		if (defined $current_data) {
			my $all_ok = 1;

			# This may have multiple iterations only if there's an array
			foreach my $path_value (@$current_data) {
				next if $path_value->[2];

				$path_value->[1] = ($inline_hook->($self, $validator, $path_value->[1]))
					if $inline_hook;
				$all_ok = $self->_ft_mangle_field($validator, \$path_value->[1]) && $all_ok;
			}

			Form::Tiny::Utils::_assign_field($dirty, $validator, $current_data);

			# found and valid, go to the next field
			next if $all_ok;
		}

		# for when it didn't pass the existence test
		if ($validator->has_default) {
			Form::Tiny::Utils::_assign_field(
				$dirty,
				$validator,
				[[$validator->get_name_path->path, $validator->get_default($self)]]
			);
		}
		elsif ($validator->required) {
			$self->add_error($self->form_meta->build_error(Required => field_def => $validator));
		}
	}
}

sub _ft_find_field
{
	my ($self, $name, $raise) = @_;

	my $def = first { $_->name eq $name } @{$self->field_defs};

	if ($raise && !defined $def) {
		croak "form does not contain a field definition for $name";
	}

	return $def;
}

sub valid
{
	my ($self) = @_;
	my $meta = $self->form_meta;
	$self->_ft_clear_errors;

	my %hooks = %{$meta->inline_hooks};
	my $fields = $self->input;
	my $dirty = {};
	if (
		(!$hooks{reformat} || !try sub { $fields = $hooks{reformat}->($self, $fields) })
		&& ref $fields eq 'HASH'
		)
	{
		$hooks{before_validate}->($self, $fields)
			if $hooks{before_validate};

		$meta->is_flat
			? $self->_ft_validate_flat($fields, $dirty, $hooks{before_mangle})