File Coverage

blib/lib/Trickster/Validator.pm

Criterion	Covered	Total	%
statement	64	82	78.0
branch	35	54	64.8
condition	3	5	60.0
subroutine	14	19	73.6
pod	0	5	0.0
total	116	165	70.3

package Trickster::Validator;

use strict;
use warnings;
use v5.14;

use Trickster::Exception;

sub new {
    my ($class, $rules) = @_;

    return bless {
        rules => $rules || {},
        errors => {},
    }, $class;
}

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

    $self->{errors} = {};

    for my $field (keys %{$self->{rules}}) {
        my $rules = $self->{rules}{$field};
        my $value = $data->{$field};

        for my $rule (@$rules) {
            my ($rule_name, @args) = ref($rule) eq 'ARRAY' ? @$rule : ($rule);

            my $method = "_validate_$rule_name";
            if ($self->can($method)) {
                my $error = $self->$method($field, $value, @args);
                if ($error) {
                    push @{$self->{errors}{$field}}, $error;
                }
            }
        }
    }

    return keys %{$self->{errors}} == 0;
}

sub errors {
    my ($self) = @_;
    return $self->{errors};
}

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

    unless ($self->is_valid) {
        Trickster::Exception::BadRequest->throw(
            message => 'Validation failed',
            details => $self->errors,
        );
    }
}

sub is_valid {
    my ($self) = @_;
    return keys %{$self->{errors}} == 0;
}

# Validation rules

sub _validate_required {
    my ($self, $field, $value) = @_;

    return "$field is required" unless defined $value && $value ne '';
    return undef;
}

sub _validate_min {
    my ($self, $field, $value, $min) = @_;

    return undef unless defined $value;

    if ($value =~ /^\d+$/) {
        return "$field must be at least $min" if $value < $min;
    } else {
        return "$field must be at least $min characters" if length($value) < $min;
    }

    return undef;
}

sub _validate_max {
    my ($self, $field, $value, $max) = @_;

    return undef unless defined $value;

    if ($value =~ /^\d+$/) {
        return "$field must be at most $max" if $value > $max;
    } else {
        return "$field must be at most $max characters" if length($value) > $max;
    }

    return undef;
}

sub _validate_email {
    my ($self, $field, $value) = @_;

    return undef unless defined $value;

    return "$field must be a valid email" unless $value =~ /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return undef;
}

sub _validate_regex {
    my ($self, $field, $value, $pattern) = @_;

    return undef unless defined $value;

    return "$field has invalid format" unless $value =~ $pattern;
    return undef;
}

sub _validate_in {
    my ($self, $field, $value, @allowed) = @_;

    return undef unless defined $value;

    return "$field must be one of: " . join(', ', @allowed)
        unless grep { $_ eq $value } @allowed;

    return undef;
}

sub _validate_numeric {
    my ($self, $field, $value) = @_;

    return undef unless defined $value;

    return "$field must be numeric" unless $value =~ /^-?\d+\.?\d*$/;
    return undef;
}

sub _validate_integer {
    my ($self, $field, $value) = @_;

    return undef unless defined $value;

    return "$field must be an integer" unless $value =~ /^-?\d+$/;
    return undef;
}

sub _validate_url {
    my ($self, $field, $value) = @_;

    return undef unless defined $value;

    return "$field must be a valid URL"
        unless $value =~ m{^https?://[^\s/$.?#].[^\s]*$}i;

    return undef;
}

sub _validate_custom {
    my ($self, $field, $value, $callback) = @_;

    return undef unless defined $value;

    my $result = $callback->($value);
    return $result if $result; # Return error message if validation fails
    return undef;
}

1;

__END__