File Coverage

blib/lib/Dancer2/Plugin/DataTransposeValidator.pm

Criterion	Covered	Total	%
statement	50	51	98.0
branch	20	24	83.3
condition	4	7	57.1
subroutine	11	11	100.0
pod	1	2	50.0
total	86	95	90.5

package Dancer2::Plugin::DataTransposeValidator;

use strict;
use warnings;

use Carp 'croak';
use Dancer2::Core::Types qw(Enum HashRef Maybe Str);
use Dancer2::Plugin::DataTransposeValidator::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.200

=cut

our $VERSION = '0.200';

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

has errors_hash => (
    is          => 'ro',
    isa         => Maybe [ Enum [qw/arrayref joined/] ],
    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->absolute
                  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";
    }

    return Dancer2::Plugin::DataTransposeValidator::Validator->new(
        params => $params,
        rules  => {
            options => $rules->{options} || {},
            prepare => $rules->{prepare} || {},
        },
        css_error_class => $plugin->css_error_class,
        errors_hash     => $plugin->errors_hash,
    );
}

1;
__END__