File Coverage

blib/lib/Test/HTML/Tidy/Recursive.pm

Criterion	Covered	Total	%
statement	33	62	53.2
branch	1	4	25.0
condition			n/a
subroutine	9	15	60.0
pod	6	6	100.0
total	49	87	56.3

package Test::HTML::Tidy::Recursive;
$Test::HTML::Tidy::Recursive::VERSION = '0.6.0';
use strict;
use warnings;
use 5.008;

use Test::More;

use HTML::T5;
use File::Find::Object::Rule ();
use IO::All qw/ io /;

use MooX qw/ late /;

has filename_re => (
    is      => 'ro',
    default => sub {
        return qr/\.x?html\z/;
    }
);

has targets => ( is => 'ro', isa => 'ArrayRef', required => 1 );

has filename_filter => (
    is      => 'ro',
    default => sub {
        return sub { return 1; }
    }
);

has _tidy        => ( is => 'rw' );
has _error_count => ( is => 'rw', isa => 'Int', default => 0 );

sub report_error
{
    my ( $self, $args ) = @_;

    $self->_error_count( 1 + $self->_error_count );
    diag( $args->{message} );

    return;
}

sub calc_tidy
{
    my $self = shift;

    my $tidy = HTML::T5->new( { output_xhtml => 1, } );
    $tidy->ignore( type => TIDY_WARNING, type => TIDY_INFO );

    return $tidy;
}

sub run
{
    my $self = shift;
    plan tests => 1;
    local $SIG{__WARN__} = sub {
        my $w = shift;
        if ( $w !~ /\AUse of uninitialized/ )
        {
            die $w;
        }
        return;
    };

    $self->_tidy( $self->calc_tidy );
    $self->traverse;
    $self->_tidy('NULL');

    # TEST
    return is( $self->_error_count, 0, "No errors" );
}

sub check_using_tidy
{
    my ( $self, $args ) = @_;

    my $fn = $args->{filename};

    $self->_tidy->parse( $fn, ( scalar io->file($fn)->slurp() ) );

    for my $message ( $self->_tidy->messages )
    {
        $self->report_error(
            {
                message => scalar $message->as_string
            }
        );
    }

    $self->_tidy->clear_messages();

    return;
}

sub check_file
{
    my ( $self, $args ) = @_;

    $self->check_using_tidy($args);

    return;
}

sub traverse
{
    my ($self) = @_;
    $self->_error_count(0);
    my $filename_re = $self->filename_re;
    my $filter      = $self->filename_filter;

    foreach my $target ( @{ $self->targets } )
    {
        for my $fn (
            File::Find::Object::Rule->file()->name($filename_re)->in($target) )
        {
            if ( $filter->($fn) )
            {
                $self->check_file( { filename => $fn } );
            }
        }
    }

    return;
}

1;

__END__