Gecko [ edgpens.lpkmn.gov.my ]

Name	Size	Permission
Command	[ DIR ]	drwxrwxrwx
Guides	[ DIR ]	drwxrwxrwx
Plugin	[ DIR ]	drwxrwxrwx
Routes	[ DIR ]	drwxrwxrwx
Validator	[ DIR ]	drwxrwxrwx
resources	[ DIR ]	drwxrwxrwx
Command.pm	6.44 KB	-rw-rw-rw-
Commands.pm	8.14 KB	-rw-rw-rw-
Controller.pm	26.91 KB	-rw-rw-rw-
Guides.pod	10.94 KB	-rw-rw-rw-
Lite.pm	9.81 KB	-rw-rw-rw-
Plugin.pm	1.02 KB	-rw-rw-rw-
Plugins.pm	4.6 KB	-rw-rw-rw-
Renderer.pm	13.63 KB	-rw-rw-rw-
Routes.pm	9.44 KB	-rw-rw-rw-
Sessions.pm	5.45 KB	-rw-rw-rw-
Static.pm	8.3 KB	-rw-rw-rw-
Types.pm	4.72 KB	-rw-rw-rw-
Validator.pm	4.71 KB	-rw-rw-rw-

Code Editor : Validator.pm

package Mojolicious::Validator;
use Mojo::Base -base;

use Mojo::DynamicMethods;
use Mojo::Util qw(trim);
use Mojolicious::Validator::Validation;

has checks  => sub { {} };
has filters => sub { {not_empty => \&_not_empty, trim => \&_trim} };

sub add_check {
  my ($self, $name, $cb) = @_;
  $self->checks->{$name} = $cb;
  Mojo::DynamicMethods::register 'Mojolicious::Validator::Validation', $self, $name, $cb;
  return $self;
}

sub add_filter { $_[0]->filters->{$_[1]} = $_[2] and return $_[0] }

sub new {
  my $self = shift->SUPER::new(@_);

$self->add_check(equal_to => \&_equal_to);
  $self->add_check(in       => \&_in);
  $self->add_check(like     => sub { $_[2] !~ $_[3] });
  $self->add_check(num      => \&_num);
  $self->add_check(size     => \&_size);
  $self->add_check(upload   => sub { !ref $_[2] || !$_[2]->isa('Mojo::Upload') });

return $self;
}

sub validation { Mojolicious::Validator::Validation->new(validator => shift) }

sub _equal_to {
  my ($v, $name, $value, $to) = @_;
  return 1 unless defined(my $other = $v->input->{$to});
  return $value ne $other;
}

sub _in {
  my ($v, $name, $value) = (shift, shift, shift);
  $value eq $_ && return undef for @_;
  return 1;
}

sub _not_empty { length $_[2] ? $_[2] : undef }

sub _num {
  my ($v, $name, $value, $min, $max) = @_;
  return 1 if $value !~ /^-?[0-9]+$/;
  return defined $min && $min > $value || defined $max && $max < $value;
}

sub _size {
  my ($v, $name, $value, $min, $max) = @_;
  my $len = ref $value ? $value->size : length $value;
  return (defined $min && $len < $min) || (defined $max && $len > $max);
}

sub _trim { defined $_[2] ? trim $_[2] : undef }

=encoding utf8

=head1 NAME

Mojolicious::Validator - Validate values

=head1 SYNOPSIS

use Mojolicious::Validator;

my $validator = Mojolicious::Validator->new;
  my $v = $validator->validation;
  $v->input({foo => 'bar'});
  $v->required('foo')->like(qr/ar$/);
  say $v->param('foo');

=head1 DESCRIPTION

L<Mojolicious::Validator> validates values for L<Mojolicious>.

=head1 CHECKS

These validation checks are available by default.

=head2 equal_to

$v = $v->equal_to('foo');

String value needs to be equal to the value of another field.

=head2 in

$v = $v->in('foo', 'bar', 'baz');

String value needs to match one of the values in the list.

=head2 like

$v = $v->like(qr/^[A-Z]/);

String value needs to match the regular expression.

=head2 num

$v = $v->num;
  $v = $v->num(2, 5);
  $v = $v->num(-3, 7);
  $v = $v->num(2, undef);
  $v = $v->num(undef, 5);

String value needs to be a non-fractional number (positive or negative) and if provided in the given range.

=head2 size

$v = $v->size(2, 5);
  $v = $v->size(2, undef);
  $v = $v->size(undef, 5);

String value length or size of L<Mojo::Upload> object in bytes needs to be between these two values.

=head2 upload

$v = $v->upload;

Value needs to be a L<Mojo::Upload> object, representing a file upload.

=head1 FILTERS

These filters are available by default.

=head2 not_empty

$v = $v->optional('foo', 'not_empty');

Remove empty string values and treat them as if they had not been submitted.

=head2 trim

$v = $v->optional('foo', 'trim');

Trim whitespace characters from both ends of string value with L<Mojo::Util/"trim">.

=head1 ATTRIBUTES

L<Mojolicious::Validator> implements the following attributes.

=head2 checks

my $checks = $validator->checks;
  $validator = $validator->checks({size => sub {...}});

Registered validation checks, by default only L</"equal_to">, L</"in">, L</"like">, L</"num">, L</"size"> and
L</"upload"> are already defined.

=head2 filters

my $filters = $validator->filters;
  $validator  = $validator->filters({trim => sub {...}});

Registered filters, by default only L</"not_empty"> and L</"trim"> are already defined.

=head1 METHODS

L<Mojolicious::Validator> inherits all methods from L<Mojo::Base> and implements the following new ones.

=head2 add_check

$validator = $validator->add_check(size => sub {...});

$validator->add_check(foo => sub {
    my ($v, $name, $value, @args) = @_;
    ...
    return undef;
  });

=head2 add_filter

$validator = $validator->add_filter(trim => sub {...});

$validator->add_filter(foo => sub {
    my ($v, $name, $value) = @_;
    ...
    return $value;
  });

=head2 new

my $validator = Mojolicious::Validator->new;

Construct a new L<Mojolicious::Validator> object.

=head2 validation

my $v = $validator->validation;

Build L<Mojolicious::Validator::Validation> object to perform validations.

my $v = $validator->validation;
  $v->input({foo => 'bar'});
  $v->required('foo')->size(1, 5);
  say $v->param('foo');

=head1 SEE ALSO

L<Mojolicious>, L<Mojolicious::Guides>, L<https://mojolicious.org>.

=cut

${this.title}

Code Editor : Validator.pm