Test-Pod-Coverage-1.08/0000755000175000017500000000000010366044620013303 5ustar andyandyTest-Pod-Coverage-1.08/t/0000755000175000017500000000000010366044620013546 5ustar andyandyTest-Pod-Coverage-1.08/t/privates.t0000644000175000017500000000147710366031616015602 0ustar andyandy#!perl -T use strict; use lib "t"; use Test::More tests=>4; use Test::Builder::Tester; BEGIN { use_ok( 'Test::Pod::Coverage' ); } MISSING_FUNCS: { test_out( "not ok 1 - Privates fails" ); test_fail(+4); test_diag( "Coverage for Privates is 60.0%, with 2 naked subroutines:" ); test_diag( "\tINTERNAL_DOODAD" ); test_diag( "\tINTERNAL_THING" ); pod_coverage_ok( "Privates", "Privates fails" ); test_test( "Should fail at 60%" ); } SPECIFIED_PRIVATES: { test_out( "ok 1 - Privates works w/a custom PC object" ); pod_coverage_ok( "Privates", { also_private => [ qr/^[A-Z_]+$/ ], }, "Privates works w/a custom PC object" ); test_test( "Trying to pass PC object" ); } SPECIFIED_PRIVATES_NAKED: { pod_coverage_ok( "Privates", { also_private => [ qr/^[A-Z_]+$/ ], }, ); } Test-Pod-Coverage-1.08/t/parms.t0000644000175000017500000000043510366031616015060 0ustar andyandy#!perl -T use lib "t"; use strict; use Test::More tests=>2; use Test::Builder::Tester; BEGIN { use_ok( 'Test::Pod::Coverage' ); } OPTIONAL_MESSAGE: { test_out( "ok 1 - Pod coverage on Simple" ); pod_coverage_ok( "Simple" ); test_test( "Simple runs under T:B:T" ); } Test-Pod-Coverage-1.08/t/nopod.t0000644000175000017500000000051110366031616015050 0ustar andyandy#!perl -T use strict; use lib "t"; use Test::More tests=>2; use Test::Builder::Tester; BEGIN { use_ok( 'Test::Pod::Coverage' ); } test_out( "not ok 1 - Checking Nopod" ); test_fail(+2); test_diag( "Nopod: couldn't find pod" ); pod_coverage_ok( "Nopod", "Checking Nopod" ); test_test( "Handles files with no pod at all" ); Test-Pod-Coverage-1.08/t/all_modules.t0000644000175000017500000000063610366031616016241 0ustar andyandy#!perl -T use strict; use Test::More tests => 2; BEGIN { use_ok( "Test::Pod::Coverage" ); } my @files = Test::Pod::Coverage::all_modules( "blib" ); # The expected files have slashes, not File::Spec separators, because # that's how File::Find does it. my @expected = qw( Test::Pod::Coverage ); @files = sort @files; @expected = sort @expected; is_deeply( \@files, \@expected, "Got all the distro files" ); Test-Pod-Coverage-1.08/t/Simple.pm0000644000175000017500000000042510366031616015337 0ustar andyandypackage Simple; sub foo {} sub bar {} sub baz {} 1; __END__ # test module - three subs, one without, one with an item, one with a head2 =head2 Methods =over =item foo this is foo =back =head2 bar The bar is just a throwaway. =head2 baz baz is very important =cut Test-Pod-Coverage-1.08/t/simple.t0000644000175000017500000000070710366031616015231 0ustar andyandy#!perl -T use lib "t"; use strict; use Test::More tests=>4; use Test::Builder::Tester; BEGIN { use_ok( 'Test::Pod::Coverage' ); } pod_coverage_ok( "Simple", "Simple is OK" ); # Now try it under T:B:T test_out( "ok 1 - Simple is still OK" ); pod_coverage_ok( "Simple", "Simple is still OK" ); test_test( "Simple runs under T:B:T" ); test_out( "ok 1 - Pod coverage on Simple" ); pod_coverage_ok( "Simple" ); test_test( "Simple runs under T:B:T" ); Test-Pod-Coverage-1.08/t/self.t0000644000175000017500000000020710366031616014664 0ustar andyandy#!perl -T use lib "t"; use strict; use Test::Pod::Coverage tests=>1; pod_coverage_ok( "Test::Pod::Coverage", "T:P:C itself is OK" ); Test-Pod-Coverage-1.08/t/PC_Inherits.pm0000644000175000017500000000030510366031616016252 0ustar andyandypackage PC_Inherits; use base qw(PC_Inherited); =head1 NAME PC_Inherit - inherits and doesn't document parent things! =cut # documented in parent; stupid to document here, too! sub new { } 1; Test-Pod-Coverage-1.08/t/00.load.t0000644000175000017500000000021610366031616015070 0ustar andyandy#!perl -T use Test::More tests => 1; use_ok( 'Test::Pod::Coverage' ); diag( "Testing Test::Pod::Coverage $Test::Pod::Coverage::VERSION" ); Test-Pod-Coverage-1.08/t/nosymbols.t0000644000175000017500000000107110366031616015760 0ustar andyandy#!perl -T use strict; use lib "t"; use Test::More tests => 3; use Test::Builder::Tester; BEGIN { use_ok( 'Test::Pod::Coverage' ); } NO_VERBOSE: { test_out( "ok 1 - Checking Nosymbols" ); pod_coverage_ok( "Nosymbols", "Checking Nosymbols" ); test_test( "Handles files with no symbols" ); } VERBOSE: { local $ENV{HARNESS_VERBOSE} = 1; test_out( "ok 1 - Checking Nosymbols" ); test_diag( "Nosymbols: no public symbols defined" ); pod_coverage_ok( "Nosymbols", "Checking Nosymbols" ); test_test( "Handles files with no symbols" ); } Test-Pod-Coverage-1.08/t/Privates.pm0000644000175000017500000000050410366031616015701 0ustar andyandypackage Privates; sub foo {} sub bar {} sub baz {} sub INTERNAL_THING {} sub INTERNAL_DOODAD {} 1; __END__ # test module - three subs, one without, one with an item, one with a head2 =head2 Methods =over =item foo this is foo =back =head2 bar The bar is just a throwaway. =head2 baz baz is very important =cut Test-Pod-Coverage-1.08/t/PC_Inherited.pm0000644000175000017500000000020510366031616016377 0ustar andyandypackage PC_Inherited; =head1 NAME PC_Inherited - we write docs so you don't have to! =head2 C< new > ... =cut sub new { } 1; Test-Pod-Coverage-1.08/t/Nosymbols.pm0000644000175000017500000000022410366031616016070 0ustar andyandypackage Nosymbols; =head1 NAME This is a dummy module with all POD, no symbols. =head1 DESCRIPTION This is a pod file without errors. =cut 1; Test-Pod-Coverage-1.08/t/pod.t0000644000175000017500000000021410366031616014513 0ustar andyandy#!perl -T use Test::More; eval "use Test::Pod 1.14"; plan skip_all => "Test::Pod 1.14 required for testing POD" if $@; all_pod_files_ok(); Test-Pod-Coverage-1.08/t/all_pod_coverage_ok.t0000644000175000017500000000016510366031616017714 0ustar andyandy#!perl -T # This is the most basic form that most people will use. use Test::Pod::Coverage; all_pod_coverage_ok(); Test-Pod-Coverage-1.08/t/Nopod.pm0000644000175000017500000000012510366031616015162 0ustar andyandypackage Nopod; # Documentation is for wimps! # sub foo {} sub bar {} sub baz {} 1; Test-Pod-Coverage-1.08/t/alt_class.t0000644000175000017500000000120310366031616015675 0ustar andyandy#!perl -T use strict; use lib "t"; use Test::More tests=>2; use Test::Builder::Tester; BEGIN { use_ok( 'Test::Pod::Coverage' ); } # the follow test checks that PC_Inherits.pm is fully covered, which it is not # -- unless you count the documentation of its parent, PC_Inherited; we do this # with the Pod::Coverage::CountParents subclass of Pod::Coverage -- so, if this # test passes, it means the subclass was, in fact, used test_out( "ok 1 - Checking PC_Inherits" ); pod_coverage_ok( "PC_Inherits", { coverage_class => 'Pod::Coverage::CountParents' }, "Checking PC_Inherits", ); test_test( "allows alternate Pod::Coverage class" ); Test-Pod-Coverage-1.08/Changes0000644000175000017500000000403010366044501014571 0ustar andyandyRevision history for Test::Pod::Coverage 1.08 Wed Jan 25 21:59:49 CST 2006 [FIXES] * File and directory names may now contain periods and hyphens. * Now exports all_modules(). 1.07_01 Wed Dec 28 23:10:31 CST 2005 [ENHANCEMENTS] * Can now use an alternate class that implements the Pod::Coverage interface. This is mostly useful for avoiding the necessity to redocument or itemize overriden methods in a subclass by using Pod::Coverage::CountParents. Thanks to Ricardo Signes. 1.06 Tue Jun 22 16:51:42 CDT 2004 [ENHANCEMENTS] * Looks in blib/ if there is one, otherwise looks in lib/ * Doesn't report "no public symbols" unless verbose mode is on. * Thanks to David Wheeler and Shawn Sorichetti for nudging. This behavior will be in Test::Pod soon, too. 1.04 Sat May 1 00:06:14 CDT 2004 [FIXES] * Now it runs taint-safe. I was not untainting the filename. 1.02 Fri Apr 30 23:27:23 CDT 2004 [FIXES] * Fixed a warning in all_modules() under 5.8.3 1.00 Wed Apr 28 23:50:19 CDT 2004 [ENHANCEMENTS] * Now runs taint-safe. * No longer uses File::Find. 0.08 Fri Feb 13 23:13:21 CST 2004 [ENHANCEMENTS] * Added all_pod_coverage_ok(), and all_modules() for support. 0.06 Jan 27 2004 [ENHANCEMENTS] * Files with all pod and no symbols is no longer an error. * Enhanced some of the error messages. 0.04 Sun Jan 18 21:51:59 CST 2004 [ENHANCEMENTS] * Now lists the naked subroutines in the error message. 0.03 Sat Jan 17 11:14:56 CST 2004 [ENHANCEMENTS] * Now says what module has a problem if it can't find any POD. Thanks, Barbie. [INTERNALS] * Added a couple more tests to bring my test coverage up to 100%, according to Devel::Cover. Whoo! 0.02 First version with the new reasonable API on pod_coverage_ok(). If you got in on 0.01, switch now. Test-Pod-Coverage-1.08/MANIFEST0000644000175000017500000000042610366031616014437 0ustar andyandyChanges Coverage.pm MANIFEST META.yml Makefile.PL t/00.load.t t/all_pod_coverage_ok.t t/alt_class.t t/PC_Inherited.pm t/PC_Inherits.pm t/Nopod.pm t/Nosymbols.pm t/Privates.pm t/Simple.pm t/all_modules.t t/nopod.t t/nosymbols.t t/parms.t t/pod.t t/privates.t t/self.t t/simple.t Test-Pod-Coverage-1.08/Coverage.pm0000644000175000017500000002015710366044532015403 0ustar andyandypackage Test::Pod::Coverage; =head1 NAME Test::Pod::Coverage - Check for pod coverage in your distribution. =head1 VERSION Version 1.08 =cut our $VERSION = "1.08"; =head1 SYNOPSIS Checks for POD coverage in files for your distribution. use Test::Pod::Coverage tests=>1; pod_coverage_ok( "Foo::Bar", "Foo::Bar is covered" ); Can also be called with L parms. use Test::Pod::Coverage tests=>1; pod_coverage_ok( "Foo::Bar", { also_private => [ qr/^[A-Z_]+$/ ], }, "Foo::Bar, with all-caps functions as privates", ); The L parms are also useful for subclasses that don't re-document the parent class's methods. Here's an example from L. pod_coverage_ok( "Mail::SRS" ); # No exceptions # Define the three overridden methods. my $trustme = { trustme => [qr/^(new|parse|compile)$/] }; pod_coverage_ok( "Mail::SRS::DB", $trustme ); pod_coverage_ok( "Mail::SRS::Guarded", $trustme ); pod_coverage_ok( "Mail::SRS::Reversable", $trustme ); pod_coverage_ok( "Mail::SRS::Shortcut", $trustme ); Alternately, you could use L, which always allows a subclass to reimplement its parents' methods without redocumenting them. For example: my $trustparents = { coverage_class => 'Pod::Coverage::CountParents' }; pod_coverage_ok( "IO::Handle::Frayed", $trustparents ); (The C parameter is not passed to the coverage class with other parameters.) If you want POD coverage for your module, but don't want to make Test::Pod::Coverage a prerequisite for installing, create the following as your F file: use Test::More; eval "use Test::Pod::Coverage"; plan skip_all => "Test::Pod::Coverage required for testing pod coverage" if $@; plan tests => 1; pod_coverage_ok( "Pod::Master::Html"); Finally, Module authors can include the following in a F file and have C automatically find and check all modules in the module distribution: use Test::More; eval "use Test::Pod::Coverage 1.00"; plan skip_all => "Test::Pod::Coverage 1.00 required for testing POD coverage" if $@; all_pod_coverage_ok(); =cut use strict; use warnings; use Pod::Coverage; use Test::Builder; my $Test = Test::Builder->new; sub import { my $self = shift; my $caller = caller; no strict 'refs'; *{$caller.'::pod_coverage_ok'} = \&pod_coverage_ok; *{$caller.'::all_pod_coverage_ok'} = \&all_pod_coverage_ok; *{$caller.'::all_modules'} = \&all_modules; $Test->exported_to($caller); $Test->plan(@_); } =head1 FUNCTIONS All functions listed below are exported to the calling namespace. =head2 all_pod_coverage_ok( [$parms, ] $msg ) Checks that the POD code in all modules in the distro have proper POD coverage. If the I<$parms> hashref if passed in, they're passed into the C object that the function uses. Check the L manual for what those can be. The exception is the C parameter, which specifies a class to use for coverage testing. It defaults to C. =cut sub all_pod_coverage_ok { my $parms = (@_ && (ref $_[0] eq "HASH")) ? shift : {}; my $msg = shift; my $ok = 1; my @modules = all_modules(); if ( @modules ) { $Test->plan( tests => scalar @modules ); for my $module ( @modules ) { my $thismsg = defined $msg ? $msg : "Pod coverage on $module"; my $thisok = pod_coverage_ok( $module, $parms, $thismsg ); $ok = 0 unless $thisok; } } else { $Test->plan( tests => 1 ); $Test->ok( 1, "No modules found." ); } return $ok; } =head2 pod_coverage_ok( $module, [$parms, ] $msg ) Checks that the POD code in I<$module> has proper POD coverage. If the I<$parms> hashref if passed in, they're passed into the C object that the function uses. Check the L manual for what those can be. The exception is the C parameter, which specifies a class to use for coverage testing. It defaults to C. =cut sub pod_coverage_ok { my $module = shift; my %parms = (@_ && (ref $_[0] eq "HASH")) ? %{(shift)} : (); my $msg = @_ ? shift : "Pod coverage on $module"; my $pc_class = (delete $parms{coverage_class}) || 'Pod::Coverage'; eval "require $pc_class" or die $@; my $pc = $pc_class->new( package => $module, %parms ); my $rating = $pc->coverage; my $ok; if ( defined $rating ) { $ok = ($rating == 1); $Test->ok( $ok, $msg ); if ( !$ok ) { my @nakies = sort $pc->naked; my $s = @nakies == 1 ? "" : "s"; $Test->diag( sprintf( "Coverage for %s is %3.1f%%, with %d naked subroutine$s:", $module, $rating*100, scalar @nakies ) ); $Test->diag( "\t$_" ) for @nakies; } } else { # No symbols my $why = $pc->why_unrated; my $nopublics = ( $why =~ "no public symbols defined" ); my $verbose = $ENV{HARNESS_VERBOSE} || 0; $ok = $nopublics; $Test->ok( $ok, $msg ); $Test->diag( "$module: $why" ) unless ( $nopublics && !$verbose ); } return $ok; } =head2 all_modules( [@dirs] ) Returns a list of all modules in I<$dir> and in directories below. If no directories are passed, it defaults to F if F exists, or F if not. Note that the modules are as "Foo::Bar", not "Foo/Bar.pm". The order of the files returned is machine-dependent. If you want them sorted, you'll have to sort them yourself. =cut sub all_modules { my @starters = @_ ? @_ : _starting_points(); my %starters = map {$_,1} @starters; my @queue = @starters; my @modules; 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 { $_ ne "CVS" && $_ ne ".svn" } @newfiles; push @queue, map "$file/$_", @newfiles; } if ( -f $file ) { next unless $file =~ /\.pm$/; my @parts = File::Spec->splitdir( $file ); shift @parts if @parts && exists $starters{$parts[0]}; shift @parts if @parts && $parts[0] eq "lib"; $parts[-1] =~ s/\.pm$// if @parts; # Untaint the parts for ( @parts ) { if ( /^([a-zA-Z0-9_\.\-]+)$/ && ($_ eq $1) ) { $_ = $1; # Untaint the original } else { die qq{Invalid and untaintable filename "$file"!}; } } my $module = join( "::", @parts ); push( @modules, $module ); } } # while return @modules; } sub _starting_points { return 'blib' if -e 'blib'; return 'lib'; } =head1 BUGS Please report any bugs or feature requests to C, or through the web interface at L. I will be notified, and then you'll automatically be notified of progress on your bug as I make changes. =head1 SUPPORT You can find documentation for this module with the perldoc command. perldoc Test::Pod::Coverage You can also look for information at: =over 4 =item * AnnoCPAN: Annotated CPAN documentation L =item * CPAN Ratings L =item * RT: CPAN's request tracker L =item * Search CPAN L =back =head1 AUTHOR Written by Andy Lester, C<< >>. =head1 ACKNOWLEDGEMENTS Thanks to Ricardo Signes for patches, and Richard Clamp for writing Pod::Coverage. =head1 COPYRIGHT & LICENSE Copyright 2006, Andy Lester, All Rights Reserved. You may use, modify, and distribute this package under the same terms as Perl itself. =cut 1; Test-Pod-Coverage-1.08/META.yml0000644000175000017500000000064010366044620014554 0ustar andyandy# http://module-build.sourceforge.net/META-spec.html #XXXXXXX This is a prototype!!! It will change in the future!!! XXXXX# name: Test-Pod-Coverage version: 1.08 version_from: Coverage.pm installdirs: site requires: Pod::Coverage: 0 Test::Builder::Tester: 0 Test::More: 0 distribution_type: module generated_by: ExtUtils::MakeMaker version 6.30 Test-Pod-Coverage-1.08/Makefile.PL0000644000175000017500000000077710366031616015271 0ustar andyandyuse strict; use warnings; use ExtUtils::MakeMaker; WriteMakefile( NAME => 'Test::Pod::Coverage', VERSION_FROM => 'Coverage.pm', ABSTRACT => "Check for pod coverage in your distribution", PREREQ_PM => { 'Pod::Coverage' => 0, 'Test::More' => 0, 'Test::Builder::Tester' => 0, }, dist => { COMPRESS => 'gzip -9f', SUFFIX => 'gz', }, clean => { FILES => 'Test-Pod-Coverage-*' }, );