File Coverage

blib/lib/Dancer2/Plugin/DataTransposeValidator.pm

Criterion	Covered	Total	%
statement	71	72	98.6
branch	26	30	86.6
condition	9	13	69.2
subroutine	11	11	100.0
pod	1	2	50.0
total	118	128	92.1

package Dancer2::Plugin::DataTransposeValidator;

use strict;
use warnings;

use Carp 'croak';
use Dancer2::Core::Types qw(HashRef Maybe Str);
use Data::Transpose::Validator;
use Path::Tiny;
use Module::Runtime qw/use_module/;

use Dancer2::Plugin 0.200000;

=head1 NAME

Dancer2::Plugin::DataTransposeValidator - Data::Transpose::Validator plugin for Dancer2

=head1 VERSION

Version 0.101

=cut

our $VERSION = '0.101';

has css_error_class => (
    is          => 'ro',
    isa         => Str,
    from_config => sub { 'has-error' },
);

has errors_hash => (
    is          => 'ro',
    isa         => Maybe [Str],
    from_config => sub { undef },
);

has rules => (
    is      => 'ro',
    isa     => HashRef,
    default => sub { +{} },
);

has rules_class => (
    is          => 'ro',
    isa         => Maybe[Str],
    from_config => sub { undef },
);

has rules_dir => (
    is  => 'ro',
    isa => sub {
        eval { path( $_[0] )->is_dir; 1 }
          or do { croak "rules directory does not exist" };
    },
    default => sub {
        my $plugin = shift;
        my $dir =
            $plugin->config->{rules_dir}
          ? $plugin->config->{rules_dir}
          : 'validation';
        path($plugin->app->setting('appdir'))->child($dir)->stringify;
    },
);

plugin_keywords 'validator';

sub BUILD {
    my $plugin = shift;
    croak __PACKAGE__ . " cannot use both of rules_class and rules_dir"
      if exists $plugin->config->{rules_class}
      && exists $plugin->config->{rules_dir};

    if ( exists $plugin->config->{rules_class} ) {
        use_module($plugin->config->{rules_class});
    }
}

sub validator {
    my ( $plugin, $params, $name, @additional_args ) = @_;
    my $rules;

    croak "params must be a hash reference" unless ref($params) eq 'HASH';

    if ( ref($name) eq '' ) {
        if ( !$plugin->rules->{$name} ) {
            if ( my $class = $plugin->rules_class ) {
                if ( $class->can($name) ) {
                    $plugin->rules->{$name} = \&{"${class}::$name"};
                }
                else {
                    croak "Rules class \"$class\" has no rule sub named: $name";
                }
            }
            else {
                # nasty old rules_dir
                my $path = path( $plugin->rules_dir )->child($name);
                croak "rules_file does not exist" unless $path->is_file;

                my $eval = do $path or croak "bad rules file: $path - $! $@";
                if ( ref($eval) eq 'CODE' ) {
                    $plugin->rules->{$name} = $eval;
                }
                else {
                    $plugin->rules->{$name} = sub { $eval };
                }
            }
        }
        $rules = $plugin->rules->{$name}->(@additional_args);
    }
    elsif (ref($name) eq 'HASH') {
        $rules = $name;
    }
    elsif (ref($name) eq 'CODE') {
        $rules = $name->(@additional_args);
    }
    else {
        my $ref = ref($name);
        croak "rules option reference type $ref not allowed";
    }

    my $options = $rules->{options} || {};
    my $prepare = $rules->{prepare} || {};

    my $dtv = Data::Transpose::Validator->new(%$options);
    $dtv->prepare(%$prepare);

    my $clean = $dtv->transpose($params);
    my $ret;

    if ($clean) {
        $ret->{valid}  = 1;
        $ret->{values} = $clean;
    }
    else {
        $ret->{valid}  = 0;
        $ret->{values} = $dtv->transposed_data;

        my $v_hash = $dtv->errors_hash;
        while ( my ( $key, $value ) = each %$v_hash ) {

            $ret->{css}->{$key} = $plugin->css_error_class;

            my @errors = map { $_->{value} } @{$value};

            if ( $plugin->errors_hash && $plugin->errors_hash eq 'joined' ) {
                $ret->{errors}->{$key} = join( ". ", @errors );
            }
            elsif ( $plugin->errors_hash && $plugin->errors_hash eq 'arrayref' )
            {
                $ret->{errors}->{$key} = \@errors;
            }
            else {
                $ret->{errors}->{$key} = $errors[0];
            }
        }
    }
    return $ret;

}

1;
__END__