Test::Pod - check for POD errors in files

Test-Pod documentation Contained in the Test-Pod distribution.

Index

Code Index:

NAME

Top

Test::Pod - check for POD errors in files

VERSION

Top

Version 1.45

SYNOPSIS

Top

Test::Pod lets you check the validity of a POD file, and report its results in standard Test::Simple fashion.

    use Test::Pod tests => $num_tests;
    pod_file_ok( $file, "Valid POD file" );

Module authors can include the following in a t/pod.t file and have Test::Pod automatically find and check all POD files in a module distribution:

    use Test::More;
    eval "use Test::Pod 1.00";
    plan skip_all => "Test::Pod 1.00 required for testing POD" if $@;
    all_pod_files_ok();

You can also specify a list of files to check, using the all_pod_files() function supplied:

    use strict;
    use Test::More;
    eval "use Test::Pod 1.00";
    plan skip_all => "Test::Pod 1.00 required for testing POD" if $@;
    my @poddirs = qw( blib script );
    all_pod_files_ok( all_pod_files( @poddirs ) );

Or even (if you're running under Apache::Test):

    use strict;
    use Test::More;
    eval "use Test::Pod 1.00";
    plan skip_all => "Test::Pod 1.00 required for testing POD" if $@;

    my @poddirs = qw( blib script );
    use File::Spec::Functions qw( catdir updir );
    all_pod_files_ok(
        all_pod_files( map { catdir updir, $_ } @poddirs )
    );

DESCRIPTION

Top

Check POD files for errors or warnings in a test file, using Pod::Simple to do the heavy lifting.

FUNCTIONS

Top

pod_file_ok( FILENAME[, TESTNAME ] )

pod_file_ok() will okay the test if the POD parses correctly. Certain conditions are not reported yet, such as a file with no pod in it at all.

When it fails, pod_file_ok() will show any pod checking errors as diagnostics.

The optional second argument TESTNAME is the name of the test. If it is omitted, pod_file_ok() chooses a default test name "POD test for FILENAME".

all_pod_files_ok( [@entries] )

Checks all the files under @entries for valid POD. It runs all_pod_files() on directories and assumes everything else to be a file to be tested. It calls the plan() function for you (one test for each file), so you can't have already called plan.

If @entries is empty or not passed, the function finds all POD files in files in the blib directory if it exists, or the lib directory if not. A POD file is one that ends with .pod, .pl and .pm, or any file where the first line looks like a shebang line.

If you're testing a module, just make a t/pod.t:

    use Test::More;
    eval "use Test::Pod 1.00";
    plan skip_all => "Test::Pod 1.00 required for testing POD" if $@;
    all_pod_files_ok();

Returns true if all pod files are ok, or false if any fail.

all_pod_files( [@dirs] )

Returns a list of all the Perl files in @dirs and in directories below. If no directories are passed, it defaults to blib if blib exists, or else lib if not. Skips any files in CVS, .svn, .git and similar directories. See %Test::Pod::ignore_dirs for a list of them.

A Perl file is:

* Any file that ends in .PL, .pl, .PL, .pm, .pod, or .t.
* Any file that has a first line with a shebang and "perl" on it.
* Any file that ends in .bat and has a first line with "--*-Perl-*--" on it.

The order of the files returned is machine-dependent. If you want them sorted, you'll have to sort them yourself.

TODO

Top

STUFF TO DO

Note the changes that are being made.

Note that you no longer can test for "no pod".

AUTHOR

Top

Currently maintained by David E. Wheeler, <david@justatheory.com>.

Originally by brian d foy.

Maintainer emeritus: Andy Lester, <andy at petdance.com>.

ACKNOWLEDGEMENTS

Top

Thanks to Andy Lester, David Wheeler, Paul Miller and Peter Edwards for contributions and to brian d foy for the original code.

COPYRIGHT AND LICENSE

Top

Copyright 2006-2010, Andy Lester. Some Rights Reserved.

This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

Test-Pod documentation Contained in the Test-Pod distribution. 
package Test::Pod;

use strict;


our $VERSION = '1.45';


use 5.008;

use Test::Builder;
use File::Spec;
use Pod::Simple;

our %ignore_dirs = (
    '.bzr' => 'Bazaar',
    '.git' => 'Git',
    '.hg'  => 'Mercurial',
    '.pc'  => 'quilt',
    '.svn' => 'Subversion',
    CVS    => 'CVS',
    RCS    => 'RCS',
    SCCS   => 'SCCS',
    _darcs => 'darcs',
    _sgbak => 'Vault/Fortress',
);

my $Test = Test::Builder->new;

sub import {
    my $self = shift;
    my $caller = caller;

    for my $func ( qw( pod_file_ok all_pod_files all_pod_files_ok ) ) {
        no strict 'refs';
        *{$caller."::".$func} = \&$func;
    }

    $Test->exported_to($caller);
    $Test->plan(@_);
}

sub _additional_test_pod_specific_checks {
    my ($ok, $errata, $file) = @_;

    return $ok;
}


sub pod_file_ok {
    my $file = shift;
    my $name = @_ ? shift : "POD test for $file";

    if ( !-f $file ) {
        $Test->ok( 0, $name );
        $Test->diag( "$file does not exist" );
        return;
    }

    my $checker = Pod::Simple->new;

    $checker->output_string( \my $trash ); # Ignore any output
    $checker->parse_file( $file );

    my $ok = !$checker->any_errata_seen;
       $ok = _additional_test_pod_specific_checks( $ok, ($checker->{errata}||={}), $file );

    $name .= ' (no pod)' if !$checker->content_seen;
    $Test->ok( $ok, $name );
    if ( !$ok ) {
        my $lines = $checker->{errata};
        for my $line ( sort { $a<=>$b } keys %$lines ) {
            my $errors = $lines->{$line};
            $Test->diag( "$file ($line): $_" ) for @$errors;
        }
    }

    return $ok;
} # pod_file_ok


sub all_pod_files_ok {
    my @args = @_ ? @_ : _starting_points();
    my @files = map { -d $_ ? all_pod_files($_) : $_ } @args;

    $Test->plan( tests => scalar @files );

    my $ok = 1;
    foreach my $file ( @files ) {
        pod_file_ok( $file ) or undef $ok;
    }
    return $ok;
}


sub all_pod_files {
    my @queue = @_ ? @_ : _starting_points();
    my @pod = ();

    while ( @queue ) {
        my $file = shift @queue;
        if ( -d $file ) {
            local *DH;
            opendir DH, $file or next;
            my @newfiles = readdir DH;
            closedir DH;

            @newfiles = File::Spec->no_upwards( @newfiles );
            @newfiles = grep { not exists $ignore_dirs{ $_ } } @newfiles;

            foreach my $newfile (@newfiles) {
                my $filename = File::Spec->catfile( $file, $newfile );
                if ( -f $filename ) {
                    push @queue, $filename;
                }
                else {
                    push @queue, File::Spec->catdir( $file, $newfile );
                }
            }
        }
        if ( -f $file ) {
            push @pod, $file if _is_perl( $file );
        }
    } # while
    return @pod;
}

sub _starting_points {
    return 'blib' if -e 'blib';
    return 'lib';
}

sub _is_perl {
    my $file = shift;

    return 1 if $file =~ /\.PL$/;
    return 1 if $file =~ /\.p(?:l|m|od)$/;
    return 1 if $file =~ /\.t$/;

    open my $fh, '<', $file or return;
    my $first = <$fh>;
    close $fh;

    return 1 if defined $first && ($first =~ /(?:^#!.*perl)|--\*-Perl-\*--/);

    return;
}


1;