File Coverage

blib/lib/Code/TidyAll/Plugin/Test/Vars.pm

Criterion	Covered	Total	%
statement	48	77	62.3
branch	6	20	30.0
condition	1	5	20.0
subroutine	11	12	91.6
pod	1	2	50.0
total	67	116	57.7

package Code::TidyAll::Plugin::Test::Vars;

use strict;
use warnings;
use autodie;

our $VERSION = '0.02';

use Test::Vars 0.008;
use Path::Class qw( dir );
use PPI::Document;

use Moo;

extends 'Code::TidyAll::Plugin';

has ignore_file => (
    is        => 'ro',
    predicate => '_has_ignore_file',
);

has _ignore_for_package => (
    is       => 'ro',
    init_arg => undef,
    lazy     => 1,
    builder  => '_build_ignore_for_package',
);

sub BUILD {
    my $self = shift;

    # We need to read the file before we start checking anything so we can die
    # if it contains bad lines and not have it look like a failure in a
    # particular file we're tidying.
    $self->_ignore_for_package;

    return;
}

sub validate_source {
    my $self   = shift;
    my $source = shift;

    my $doc = PPI::Document->new( \$source );

    # Test::Vars only works with Perl code in a package anyway.
    my $package_stmt = $doc->find_first('PPI::Statement::Package')
        or return;
    my $package = $package_stmt->namespace
        or return;

    my @path = split /::/, $package;
    $path[-1] .= '.pm';

    ## no critic (Subroutines::ProtectPrivateSubs)
    my $file = dir( $self->tidyall->_tempdir )->file( 'lib', @path );
    ## use critic
    ## no critic (ValuesAndExpressions::ProhibitLeadingZeros)
    $file->parent->mkpath( 0, 0755 );
    ## use critic
    $file->spew($source);

    return test_vars(
        $file,
        \&_result_handler,
        %{ $self->_ignore_for_package->{$package} // {} },
    );
}

sub _build_ignore_for_package {
    my $self = shift;

    return {} unless $self->_has_ignore_file;

    my %vars;
    my %regexes;

    open my $fh, '<', $self->ignore_file;
    while (<$fh>) {
        next unless /\S/;

        chomp;
        my ( $package, $ignore ) = split /\s*=\s*/;
        unless ( defined $package && defined $ignore ) {
            die 'Invalid line in ' . $self->ignore_file . ": $_\n";
        }

        if ( $ignore =~ m{^qr} ) {
            local $@ = undef;
            ## no critic (BuiltinFunctions::ProhibitStringyEval)
            $ignore = eval $ignore;
            ## use critic
            die $@ if $@;

            push @{ $regexes{$package} }, $ignore;
        }
        else {
            push @{ $vars{$package} }, $ignore;
        }
    }

    my %ignore;
    for my $package ( keys %regexes ) {
        my @re = @{ $regexes{$package} };
        $ignore{$package}{ignore_if} = sub {
            for my $re (@re) {
                return 1 if $_ =~ /$re/;
            }
            return 0;
        };
    }

    for my $package ( keys %vars ) {
        $ignore{$package}{ignore_vars}{$_} = 1 for @{ $vars{$package} };
    }

    return \%ignore;
}

sub _result_handler {
    shift;
    my $exit_code = shift;
    my $results   = shift;

    return unless $exit_code;

    my @errors = map { $_->[1] } grep { $_->[0] eq 'diag' } @{$results};
    die join q{}, map { "    $_\n" } @errors if @errors;

    return;
}

1;

# ABSTRACT: Provides Test::Vars plugin for Code::TidyAll

__END__