Test-Pod-Coverage-1.10/000755 000765 000024 00000000000 12362001470 015052 5ustar00neilbstaff000000 000000 Test-Pod-Coverage-1.10/Changes000644 000765 000024 00000006055 12362001265 016355 0ustar00neilbstaff000000 000000 Revision history for Perl module Test::Pod::Coverage 1.10 2014-07-17 NEILB - Changed license to Artistic 2.0, at PETDANCE's request. - Added README - Moved Coverage.pm to lib/Test/Pod/Coverage.pm - Min perl version now set to 5.006 in both code and dist metadata. Addresses RT#21564 from ANDK++ - Added DESCRIPTION section to pod (RT#28715 JEREMIAH++), and changed to a minimal SYNOPSIS, with everything else moved to the DESCRIPTION. - The "no verbose" tests in t/nosymbols.t weren't ensuring that the tests were running with HARNESS_VERBOSE set to false. You could set that true in your environment and break the test. RT#53947 - thanks to Pete Armstrong. - Makefile.PL: Ensured all prereqs listed in PREREQ_PM, and TEST_REQUIRES set if a recent enough ExtUtils::MakeMaker. - Added github repo to pod and dist metadata - Deleted the old META.yml, so new MYMETA.{yml,json} will be generated. - Reformatted as per CPAN::Changes::Spec 1.09_01 2014-07-08 NEILB - Specified license as 'Perl' in metadata, to match doc. - All of the changes in 1.10 were first done in this developer release, apart from the change to Artistic License 2.0. 1.08 2006-01-26 PETDANCE [FIXES] - File and directory names may now contain periods and hyphens. - Now exports all_modules(). 1.07_01 2005-12-29 PETDANCE [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 2004-06-22 PETDANCE [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 2004-05-01 PETDANCE [FIXES] - Now it runs taint-safe. I was not untainting the filename. 1.02 2004-05-01 PETDANCE [FIXES] - Fixed a warning in all_modules() under 5.8.3 1.00 2004-04-29 PETDANCE [ENHANCEMENTS] - Now runs taint-safe. - No longer uses File::Find. 0.08 2004-02-14 PETDANCE [ENHANCEMENTS] - Added all_pod_coverage_ok(), and all_modules() for support. 0.06 2004-01-27 PETDANCE [ENHANCEMENTS] - Files with all pod and no symbols is no longer an error. - Enhanced some of the error messages. 0.04 2004-01-19 PETDANCE [ENHANCEMENTS] - Now lists the naked subroutines in the error message. 0.03 2004-01-17 PETDANCE (not released) [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 2004-01-05 PETDANCE - First version with the new reasonable API on pod_coverage_ok(). If you got in on 0.01, switch now. 0.01 2004-01-04 PETDANCE - First release to CPAN Test-Pod-Coverage-1.10/lib/000755 000765 000024 00000000000 12362001470 015620 5ustar00neilbstaff000000 000000 Test-Pod-Coverage-1.10/Makefile.PL000644 000765 000024 00000002627 12362000110 017021 0ustar00neilbstaff000000 000000 use strict; use warnings; use ExtUtils::MakeMaker; my $mm_ver = $ExtUtils::MakeMaker::VERSION; if ($mm_ver =~ /_/) { $mm_ver = eval $mm_ver; die $@ if $@; } my @REQUIRES = ( 'strict' => 0, 'warnings' => 0, 'Pod::Coverage' => 0, 'Test::Builder' => 0, ); my @TEST_REQUIRES = ( 'Test::Builder::Tester' => 0, 'Test::More' => 0, 'lib' => 0, ); push(@REQUIRES, @TEST_REQUIRES) if $mm_ver < 6.64; WriteMakefile( NAME => 'Test::Pod::Coverage', VERSION_FROM => 'lib/Test/Pod/Coverage.pm', ABSTRACT => "Check for pod coverage in your distribution", PREREQ_PM => { @REQUIRES }, ($mm_ver >= 6.64 ? (TEST_REQUIRES => { @TEST_REQUIRES }) : () ), ($mm_ver >= 6.48 ? (MIN_PERL_VERSION => 5.006) : () ), ($mm_ver >= 6.31 ? (LICENSE => 'artistic_2') : ()), ($mm_ver <= 6.45 ? () : (META_MERGE => { 'meta-spec' => { version => 2 }, resources => { repository => { type => 'git', web => 'https://github.com/neilbowers/Test-Pod-Coverage', url => 'git://github.com/neilbowers/Test-Pod-Coverage.git', }, }, })), dist => { COMPRESS => 'gzip -9f', SUFFIX => 'gz', }, clean => { FILES => 'Test-Pod-Coverage-*' }, ); Test-Pod-Coverage-1.10/MANIFEST000644 000765 000024 00000000711 12362001471 016203 0ustar00neilbstaff000000 000000 Changes lib/Test/Pod/Coverage.pm MANIFEST README 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 META.yml Module YAML meta-data (added by MakeMaker) META.json Module JSON meta-data (added by MakeMaker) Test-Pod-Coverage-1.10/META.json000644 000765 000024 00000002543 12362001470 016477 0ustar00neilbstaff000000 000000 { "abstract" : "Check for pod coverage in your distribution", "author" : [ "unknown" ], "dynamic_config" : 1, "generated_by" : "ExtUtils::MakeMaker version 6.98, CPAN::Meta::Converter version 2.141170", "license" : [ "artistic_2" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : "2" }, "name" : "Test-Pod-Coverage", "no_index" : { "directory" : [ "t", "inc" ] }, "prereqs" : { "build" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "configure" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "runtime" : { "requires" : { "Pod::Coverage" : "0", "Test::Builder" : "0", "perl" : "5.006", "strict" : "0", "warnings" : "0" } }, "test" : { "requires" : { "Test::Builder::Tester" : "0", "Test::More" : "0", "lib" : "0" } } }, "release_status" : "stable", "resources" : { "repository" : { "type" : "git", "url" : "git://github.com/neilbowers/Test-Pod-Coverage.git", "web" : "https://github.com/neilbowers/Test-Pod-Coverage" } }, "version" : "1.10" } Test-Pod-Coverage-1.10/META.yml000644 000765 000024 00000001274 12362001470 016327 0ustar00neilbstaff000000 000000 --- abstract: 'Check for pod coverage in your distribution' author: - unknown build_requires: ExtUtils::MakeMaker: '0' Test::Builder::Tester: '0' Test::More: '0' lib: '0' configure_requires: ExtUtils::MakeMaker: '0' dynamic_config: 1 generated_by: 'ExtUtils::MakeMaker version 6.98, CPAN::Meta::Converter version 2.141170' license: artistic_2 meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: '1.4' name: Test-Pod-Coverage no_index: directory: - t - inc requires: Pod::Coverage: '0' Test::Builder: '0' perl: '5.006' strict: '0' warnings: '0' resources: repository: git://github.com/neilbowers/Test-Pod-Coverage.git version: '1.10' Test-Pod-Coverage-1.10/README000644 000765 000024 00000001042 12362001205 015723 0ustar00neilbstaff000000 000000 README for Perl module Test::Pod::Coverage This module is used to add a test to your Perl distribution, which checks for pod coverage of all appropriate files. You can read a nicely formatted version of the documentation for this module online: https://metacpan.org/pod/Test::Pod::Coverage You should be able to install this using your usual method for installing modules from CPAN. If you don't have one let, have a look at: http://www.cpan.org/modules/INSTALL.html This module was written by Andy Lester, Test-Pod-Coverage-1.10/t/000755 000765 000024 00000000000 12362001470 015315 5ustar00neilbstaff000000 000000 Test-Pod-Coverage-1.10/t/00.load.t000644 000765 000024 00000000216 12356525564 016660 0ustar00neilbstaff000000 000000 #!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.10/t/all_modules.t000644 000765 000024 00000000636 12356525564 020031 0ustar00neilbstaff000000 000000 #!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.10/t/all_pod_coverage_ok.t000644 000765 000024 00000000165 12356525564 021504 0ustar00neilbstaff000000 000000 #!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.10/t/alt_class.t000644 000765 000024 00000001203 12356525564 017465 0ustar00neilbstaff000000 000000 #!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.10/t/Nopod.pm000644 000765 000024 00000000125 12356525564 016752 0ustar00neilbstaff000000 000000 package Nopod; # Documentation is for wimps! # sub foo {} sub bar {} sub baz {} 1; Test-Pod-Coverage-1.10/t/nopod.t000644 000765 000024 00000000511 12356525564 016640 0ustar00neilbstaff000000 000000 #!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.10/t/Nosymbols.pm000644 000765 000024 00000000224 12356525564 017660 0ustar00neilbstaff000000 000000 package 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.10/t/nosymbols.t000644 000765 000024 00000001136 12356742154 017546 0ustar00neilbstaff000000 000000 #!perl -T use strict; use lib "t"; use Test::More tests => 3; use Test::Builder::Tester; BEGIN { use_ok( 'Test::Pod::Coverage' ); } NO_VERBOSE: { local $ENV{HARNESS_VERBOSE} = 0; 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.10/t/parms.t000644 000765 000024 00000000435 12356525564 016650 0ustar00neilbstaff000000 000000 #!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.10/t/PC_Inherited.pm000644 000765 000024 00000000205 12356525564 020167 0ustar00neilbstaff000000 000000 package 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.10/t/PC_Inherits.pm000644 000765 000024 00000000305 12356525564 020042 0ustar00neilbstaff000000 000000 package 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.10/t/pod.t000644 000765 000024 00000000214 12356525564 016303 0ustar00neilbstaff000000 000000 #!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.10/t/Privates.pm000644 000765 000024 00000000504 12356525564 017471 0ustar00neilbstaff000000 000000 package 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.10/t/privates.t000644 000765 000024 00000001477 12356525564 017372 0ustar00neilbstaff000000 000000 #!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.10/t/self.t000644 000765 000024 00000000207 12356525564 016454 0ustar00neilbstaff000000 000000 #!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.10/t/Simple.pm000644 000765 000024 00000000425 12356525564 017127 0ustar00neilbstaff000000 000000 package 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.10/t/simple.t000644 000765 000024 00000000707 12356525564 017021 0ustar00neilbstaff000000 000000 #!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.10/lib/Test/000755 000765 000024 00000000000 12362001470 016537 5ustar00neilbstaff000000 000000 Test-Pod-Coverage-1.10/lib/Test/Pod/000755 000765 000024 00000000000 12362001470 017261 5ustar00neilbstaff000000 000000 Test-Pod-Coverage-1.10/lib/Test/Pod/Coverage.pm000644 000765 000024 00000020730 12362000050 021345 0ustar00neilbstaff000000 000000 package Test::Pod::Coverage; =head1 NAME Test::Pod::Coverage - Check for pod coverage in your distribution. =head1 VERSION Version 1.10 =cut our $VERSION = "1.10"; =head1 SYNOPSIS In one of your dist's test files (eg C): use Test::Pod::Coverage tests=>1; pod_coverage_ok( "Foo::Bar", "Foo::Bar is covered" ); =head1 DESCRIPTION Test::Pod::Coverage is used to create a test for your distribution, to ensure that all relevant files in your distribution are appropriately documented in pod. 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 5.006; 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 REPOSITORY L =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. This program is free software; you can redistribute it and/or modify it under the terms of the Artistic License version 2.0. See http://dev.perl.org/licenses/ for more information =cut 1;