File Coverage

lib/Test/Spelling/Comment.pm

Criterion	Covered	Total	%
statement	134	134	100.0
branch	47	48	97.9
condition	6	6	100.0
subroutine	17	17	100.0
pod	3	3	100.0
total	207	208	99.5

package Test::Spelling::Comment;

use 5.006;
use strict;
use warnings;

our $VERSION = '0.004';

use Moo;

use Carp                  ();
use Comment::Spell::Check ();
use File::Find            ();
use Pod::Wordlist         ();
use Scalar::Util          ();
use Test::Builder         ();

has _skip => (
    is       => 'ro',
    init_arg => 'skip',
);

has _stopwords => (
    is        => 'ro',
    isa       => sub { Carp::croak q{stopwords must have method 'wordlist'} if !Scalar::Util::blessed( $_[0] ) || !$_[0]->can('wordlist'); },
    init_arg  => 'stopwords',
    lazy      => 1,
    default   => sub { Pod::Wordlist->new },
    predicate => 1,
);

my $TEST = Test::Builder->new();

# - Do not use subtests because subtests cannot be tested with
#   Test::Builder:Tester.
# - Do not use a plan because a method that sets a plan cannot be tested
#   with Test::Builder:Tester.
# - Do not call done_testing in a method that should be tested by
#   Test::Builder::Tester because TBT cannot test them.

sub add_stopwords {
    my $self = shift;

    my $wordlist = $self->_stopwords->wordlist;

  STOPWORD:
    for (@_) {

        # explicit copy
        my $stopword = $_;
        $stopword =~ s{ ^ \s* }{}xsm;
        $stopword =~ s{ \s+ $ }{}xsm;
        next STOPWORD if $stopword eq q{};

        $wordlist->{$stopword} = 1;
    }

    return $self;
}

sub all_files_ok {
    my $self = shift;

    my @args = scalar @_ ? @_ : $self->_default_dirs();
    if ( !@args ) {
        $TEST->skip_all("No files found\n");
        return 1;
    }

    my @files;
  ARG:
    for my $arg (@args) {
        if ( !-e $arg ) {
            $TEST->carp("File '$arg' does not exist");
            next ARG;
        }

        if ( -l $arg ) {
            $TEST->carp("Ignoring symlink '$arg'");
            next ARG;
        }

        if ( -f $arg ) {
            push @files, $arg;
            next ARG;
        }

        if ( !-d $arg ) {
            $TEST->carp("File '$arg' is not a file nor a directory. Ignoring it.");
            next ARG;
        }

        File::Find::find(
            {
                no_chdir   => 1,
                preprocess => sub {
                    my @sorted = sort grep { !-l "$File::Find::dir/$_" } @_;
                    return @sorted;
                },
                wanted => sub {
                    return if !-f $File::Find::name;
                    push @files, $File::Find::name;
                },
            },
            $arg,
        );
    }

    if ( !@files ) {
        $TEST->skip_all("No files found in (@args)\n");
        return 1;
    }

    my $rc = 1;
    for my $file ( grep { $_ !~ m{ [~] $ }xsm } @files ) {
        if ( !$self->file_ok($file) ) {
            $rc = 0;
        }
    }

    $TEST->done_testing;

    return 1 if $rc;
    return;
}

sub file_ok {
    my ( $self, $file ) = @_;

    Carp::croak 'usage: file_ok(FILE)' if @_ != 2 || !defined $file;

    if ( !-f $file ) {
        $TEST->ok( 0, $file );
        $TEST->diag("\n");
        $TEST->diag("File $file does not exist or is not a file");

        return;
    }

    my $fh;
    if ( !open $fh, '<', $file ) {
        $TEST->ok( 0, $file );
        $TEST->diag("\n");
        $TEST->diag("Cannot read file '$file': $!");

        return;
    }

    my @lines = <$fh>;
    chomp @lines;

    if ( !close $fh ) {
        $TEST->ok( 0, $file );
        $TEST->diag("\n");
        $TEST->diag("Cannot read file '$file': $!");

        return;
    }

    my $skips_ref = $self->_skip;
    if ( defined $skips_ref ) {
        if (   ( !defined Scalar::Util::reftype($skips_ref) )
            || ( Scalar::Util::reftype($skips_ref) ne Scalar::Util::reftype( [] ) ) )
        {
            $skips_ref = [$skips_ref];
        }

        for my $line (@lines) {
            for my $skip ( @{$skips_ref} ) {
                ## no critic (RegularExpressions::RequireDotMatchAnything)
                ## no critic (RegularExpressions::RequireExtendedFormatting)
                ## no critic (RegularExpressions::RequireLineBoundaryMatching)
                $line =~ s{$skip}{}g;
                ## use critic
            }
        }
    }

    my $speller = Comment::Spell::Check->new( $self->_has_stopwords ? ( stopwords => $self->_stopwords ) : () );
    my $buf;
    $speller->set_output_string($buf);
    my $result;
    if ( !eval { $result = $speller->parse_from_string( join "\n", @lines, q{} ); 1 } ) {
        my $error_msg = $@;
        $TEST->ok( 0, $file );
        $TEST->diag("\n$error_msg\n\n");

        return;
    }

    if ( @{ $result->{fails} } == 0 ) {
        $TEST->ok( 1, $file );

        return 1;
    }

    $TEST->ok( 0, $file );
    $TEST->diag("\n$buf\n\n");

    return;
}

sub _default_dirs {
    my ($self) = @_;

    my @dirs;
    if ( -d 'blib' ) {
        push @dirs, 'blib';
    }
    elsif ( -d 'lib' ) {
        push @dirs, 'lib';
    }

    if ( -d 'bin' ) {
        push @dirs, 'bin';
    }

    if ( -d 'script' ) {
        push @dirs, 'script';
    }

    my @sorted = sort @dirs;
    return @sorted;
}

no Moo;

1;

__END__