File Coverage

blib/lib/Test/TrailingSpace.pm

Criterion	Covered	Total	%
statement	61	61	100.0
branch	15	16	93.7
condition	2	3	66.6
subroutine	14	14	100.0
pod	2	2	100.0
total	94	96	97.9

package Test::TrailingSpace;
$Test::TrailingSpace::VERSION = '0.0601';
use 5.014;
use strict;
use warnings;
use autodie;

use Test::More;

use File::Find::Object::Rule 0.0301;

sub new
{
    my $class = shift;

    my $self = bless {}, $class;

    $self->_init(@_);

    return $self;
}

sub _filename_regex
{
    my $self = shift;

    if (@_)
    {
        $self->{_filename_regex} = shift;
    }

    return $self->{_filename_regex};
}

sub _root_path
{
    my $self = shift;

    if (@_)
    {
        $self->{_root_path} = shift;
    }

    return $self->{_root_path};
}

sub _abs_path_prune_re
{
    my $self = shift;

    if (@_)
    {
        $self->{_abs_path_prune_re} = shift;
    }

    return $self->{_abs_path_prune_re};
}

sub _path_cb
{
    my $self = shift;

    if (@_)
    {
        $self->{_path_cb} = shift;
    }

    return $self->{_path_cb};
}

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

    $self->_root_path( exists( $args->{root} ) ? $args->{root} : '.' );
    $self->_filename_regex( $args->{filename_regex} );
    $self->_abs_path_prune_re( $args->{abs_path_prune_re} );
    my $find_cr = $args->{find_cr};

    my $OPEN_MODE = $find_cr ? '<:raw' : '<';
    my $cb =
"sub { my (\$r) = \@_; my \$nf = 0; while (my \$p = \$r->match()) { open( my \$fh, '$OPEN_MODE', \$p ); L: while ( my \$l = <\$fh> ){chomp(\$l);";
    $cb .=
q#if ( $l =~ /[ \\t]+\\r?\\z/ ){diag("Found trailing space in file '$p'");++$nf; last L;}#;
    if ( $args->{find_tabs} )
    {
        $cb .=
q#if ( $l =~ /\\t/ ) { diag("Found hard tabs in file '$p'"); ++$nf; last L;}#;
    }

    if ($find_cr)
    {
        $cb .=
q# if ( $l =~ /\\r\\z/ ) { diag("Found Carriage Returns line endings in file '$p'");  ++$nf; last L; }#;
    }
    $cb .= "} } return \$nf;}";

    ## no critic
    $self->_path_cb( eval($cb) );
    ## use critic
    return;
}

sub no_trailing_space
{
    local $Test::Builder::Level = $Test::Builder::Level + 1;

    my ( $self, $blurb ) = @_;

    my $subrule = File::Find::Object::Rule->new;

    my $abs_path_prune_re = $self->_abs_path_prune_re();

    my $rule = $subrule->or(
        $subrule->new->exec(
            sub {
                my ( $shortname, undef, $path ) = @_;
                return (
                    (
                        $shortname =~
                            /\A(?:blib|_build|CVS|\.svn|\.bzr|\.hg|\.git)\z/
                    )
                        or ( defined($abs_path_prune_re)
                        && ( $path =~ m/$abs_path_prune_re/ ) )
                );
            }
        )->prune->discard,
        $subrule->new->file()

          # ->exec(sub { print STDERR join(",", "Foo==", @_), "\n"; return 1; })
            ->name( $self->_filename_regex() ),
    )->start( $self->_root_path() );
    my $num_found = $self->_path_cb()->($rule);

    return is( $num_found, 0, $blurb );
}

1;

__END__