File Coverage

blib/lib/MooX/Role/Validatable.pm

Criterion	Covered	Total	%
statement	26	69	37.6
branch	0	18	0.0
condition			n/a
subroutine	9	20	45.0
pod	8	10	80.0
total	43	117	36.7

package MooX::Role::Validatable;

use strict;
use 5.008_005;
our $VERSION = '0.03';

use Moo::Role;
use MooX::Role::Validatable::Error;
use Types::Standard qw( Str Int Bool ArrayRef );

use Carp qw(confess);
use Scalar::Util qw/blessed/;

has '_init_errors' => (
    is       => 'ro',
    isa      => ArrayRef,
    init_arg => undef,
    default  => sub { return [] },
);
has '_validation_errors' => (
    is       => 'ro',
    isa      => ArrayRef,
    init_arg => undef,
    default  => sub { return [] },
);

has 'error_class' => (is => 'ro', default => sub { 'MooX::Role::Validatable::Error' }, trigger => sub {
    my $self = shift; my $error_class = $self->error_class;
    eval "require $error_class;";
    confess $@ if $@;
} );

has validation_methods => (
    is   => 'lazy',
    isa  => ArrayRef[Str]
);

sub _build_validation_methods {
    my $self = shift;
    return [grep { $_ =~ /^_validate_/ } ($self->meta->get_all_method_names)];
}

sub all_errors {
    my $self = shift;
    return (@{$self->{_init_errors}}, @{$self->{_validation_errors}});
}

sub all_init_errors {
    return @{(shift)->{_init_errors}};
}

sub all_validation_errors {
    return @{(shift)->{_validation_errors}};
}

sub passes_validation {
    my $self = shift;
    my @all_errors = $self->all_errors;
    return (scalar @all_errors) ? 0 : 1;
}

sub should_alert {
    my $self = shift;
    return (grep { $_->alert } ($self->all_errors)) ? 1 : 0;
}

sub confirm_validity {
    my $self = shift;
    $self->{_validation_errors} = [
        map { $self->_errfilter($_) }
        map { $self->$_ } @{$self->validation_methods}
    ];
    return $self->passes_validation;
}

sub add_errors {
    my ($self, @errors) = @_;
    push @{ $self->{_init_errors} }, map { $self->_errfilter($_) } @errors;
    return scalar @errors;
}

sub initialized_correctly {
    my $self = shift;
    return (@{$self->{_init_errors}}) ? 0 : 1;
}

sub all_errors_by_severity {
    my $self = shift;
    return (sort { $b->severity <=> $a->severity } ($self->all_errors));
}

sub primary_validation_error {
    my $self = shift;

    my @errors = $self->all_errors_by_severity;
    return unless @errors;

    # We may wish to do something with perm v. transient here at some point.
    return $errors[0];
}

sub _errfilter {
    my ($self, $error) = @_;
    return $error if blessed($error);

    $error = { message => $error } unless ref($error); # when it's a string

    confess "Cannot add validation error which is not blessed nor hashref" unless ref($error) eq 'HASH';
    $error->{message_to_client} = $error->{message} unless exists $error->{message_to_client};
    $error->{set_by} = caller(1) unless exists $error->{set_by};
    return $self->error_class->new($error);
}

no Moo::Role;

1;
__END__