File Coverage

lib/Test/Spelling/Comment.pm

Criterion	Covered	Total	%
statement	99	99	100.0
branch	25	26	96.1
condition	6	6	100.0
subroutine	14	14	100.0
pod	3	3	100.0
total	147	148	99.3

package Test::Spelling::Comment;

use 5.006;
use strict;
use warnings;

our $VERSION = '0.005';

use Moo;

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

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) = @_;

    my @files = Test::XTFiles->new->all_files();
    if ( !@files ) {
        $TEST->skip_all("No files found\n");
        return 1;
    }

    my $rc = 1;
    for my $file (@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;
}

no Moo;

1;

__END__