Test-Signature-1.10/0000755000076500007650000000000010704723033015476 5ustar audreytaudreyt00000000000000Test-Signature-1.10/Changes0000644000076500007650000000271210704722652017001 0ustar audreytaudreyt00000000000000# Change log for Test::Signature # The following versions are available on CPAN: --- version: 1.10 date: 16 Oct 2007 changes: - Taking over maintainence from Iain. - Modernized the build infrastructure with Module::Install. - Tidied up source code, test files, documentation, and this changelog. --- version: 1.06 date: 19 Jan 2004 changes: - Taken over maintainence from Iain. --- version: 1.05 date: 1 Aug 2003 changes: - Fixed misused word. - Refactored forced/non-forced behaviour. - Reorganised tests. - Reworded tests to match Module::Signature. --- version: 1.04 date: 21 May 2003 changes: - Code tidied. - Made more independent from the advance technology. - Module::Install stuff mentioned. --- version: 1.03 date: 29 Oct 2002 changes: - Updated recommended version of Module::Signature - Checks for network availability. As taken from MS 0.16 # Versions below here are available on BACKPAN # http://backpan.cpan.org/authors/id/S/SP/SPOON/ --- version: 1.02 date: 17 Oct 2002 changes: - Updated recommended version of Module::Signature - Recommended Module::Signature programmatically. --- version: 1.01 date: 13 Oct 2002 changes: - Fixed incorrect skip() calling. - Fixed incorrect SKIP blocking. - Documentation nits from Autrijus. - EU::Manifest provides sensible defaults for MANIFEST.SKIP --- version: 1.00 date: 12 Oct 2002 changes: - Initial revision. Test-Signature-1.10/inc/0000755000076500007650000000000010704723031016245 5ustar audreytaudreyt00000000000000Test-Signature-1.10/inc/Module/0000755000076500007650000000000010704723031017472 5ustar audreytaudreyt00000000000000Test-Signature-1.10/inc/Module/Install/0000755000076500007650000000000010704723031021100 5ustar audreytaudreyt00000000000000Test-Signature-1.10/inc/Module/Install/Base.pm0000644000076500007650000000203510704723020022306 0ustar audreytaudreyt00000000000000#line 1 package Module::Install::Base; $VERSION = '0.67'; # Suspend handler for "redefined" warnings BEGIN { my $w = $SIG{__WARN__}; $SIG{__WARN__} = sub { $w }; } ### This is the ONLY module that shouldn't have strict on # use strict; #line 41 sub new { my ($class, %args) = @_; foreach my $method ( qw(call load) ) { *{"$class\::$method"} = sub { shift()->_top->$method(@_); } unless defined &{"$class\::$method"}; } bless( \%args, $class ); } #line 61 sub AUTOLOAD { my $self = shift; local $@; my $autoload = eval { $self->_top->autoload } or return; goto &$autoload; } #line 76 sub _top { $_[0]->{_top} } #line 89 sub admin { $_[0]->_top->{admin} or Module::Install::Base::FakeAdmin->new; } sub is_admin { $_[0]->admin->VERSION; } sub DESTROY {} package Module::Install::Base::FakeAdmin; my $Fake; sub new { $Fake ||= bless(\@_, $_[0]) } sub AUTOLOAD {} sub DESTROY {} # Restore warning handler BEGIN { $SIG{__WARN__} = $SIG{__WARN__}->(); } 1; #line 138 Test-Signature-1.10/inc/Module/Install/Can.pm0000644000076500007650000000337410704723020022144 0ustar audreytaudreyt00000000000000#line 1 package Module::Install::Can; use strict; use Module::Install::Base; use Config (); ### This adds a 5.005 Perl version dependency. ### This is a bug and will be fixed. use File::Spec (); use ExtUtils::MakeMaker (); use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.67'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } # check if we can load some module ### Upgrade this to not have to load the module if possible sub can_use { my ($self, $mod, $ver) = @_; $mod =~ s{::|\\}{/}g; $mod .= '.pm' unless $mod =~ /\.pm$/i; my $pkg = $mod; $pkg =~ s{/}{::}g; $pkg =~ s{\.pm$}{}i; local $@; eval { require $mod; $pkg->VERSION($ver || 0); 1 }; } # check if we can run some command sub can_run { my ($self, $cmd) = @_; my $_cmd = $cmd; return $_cmd if (-x $_cmd or $_cmd = MM->maybe_command($_cmd)); for my $dir ((split /$Config::Config{path_sep}/, $ENV{PATH}), '.') { my $abs = File::Spec->catfile($dir, $_[1]); return $abs if (-x $abs or $abs = MM->maybe_command($abs)); } return; } # can we locate a (the) C compiler sub can_cc { my $self = shift; my @chunks = split(/ /, $Config::Config{cc}) or return; # $Config{cc} may contain args; try to find out the program part while (@chunks) { return $self->can_run("@chunks") || (pop(@chunks), next); } return; } # Fix Cygwin bug on maybe_command(); if ( $^O eq 'cygwin' ) { require ExtUtils::MM_Cygwin; require ExtUtils::MM_Win32; if ( ! defined(&ExtUtils::MM_Cygwin::maybe_command) ) { *ExtUtils::MM_Cygwin::maybe_command = sub { my ($self, $file) = @_; if ($file =~ m{^/cygdrive/}i and ExtUtils::MM_Win32->can('maybe_command')) { ExtUtils::MM_Win32->maybe_command($file); } else { ExtUtils::MM_Unix->maybe_command($file); } } } } 1; __END__ #line 157 Test-Signature-1.10/inc/Module/Install/Fetch.pm0000644000076500007650000000463010704723020022470 0ustar audreytaudreyt00000000000000#line 1 package Module::Install::Fetch; use strict; use Module::Install::Base; use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.67'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } sub get_file { my ($self, %args) = @_; my ($scheme, $host, $path, $file) = $args{url} =~ m|^(\w+)://([^/]+)(.+)/(.+)| or return; if ( $scheme eq 'http' and ! eval { require LWP::Simple; 1 } ) { $args{url} = $args{ftp_url} or (warn("LWP support unavailable!\n"), return); ($scheme, $host, $path, $file) = $args{url} =~ m|^(\w+)://([^/]+)(.+)/(.+)| or return; } $|++; print "Fetching '$file' from $host... "; unless (eval { require Socket; Socket::inet_aton($host) }) { warn "'$host' resolve failed!\n"; return; } return unless $scheme eq 'ftp' or $scheme eq 'http'; require Cwd; my $dir = Cwd::getcwd(); chdir $args{local_dir} or return if exists $args{local_dir}; if (eval { require LWP::Simple; 1 }) { LWP::Simple::mirror($args{url}, $file); } elsif (eval { require Net::FTP; 1 }) { eval { # use Net::FTP to get past firewall my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600); $ftp->login("anonymous", 'anonymous@example.com'); $ftp->cwd($path); $ftp->binary; $ftp->get($file) or (warn("$!\n"), return); $ftp->quit; } } elsif (my $ftp = $self->can_run('ftp')) { eval { # no Net::FTP, fallback to ftp.exe require FileHandle; my $fh = FileHandle->new; local $SIG{CHLD} = 'IGNORE'; unless ($fh->open("|$ftp -n")) { warn "Couldn't open ftp: $!\n"; chdir $dir; return; } my @dialog = split(/\n/, <<"END_FTP"); open $host user anonymous anonymous\@example.com cd $path binary get $file $file quit END_FTP foreach (@dialog) { $fh->print("$_\n") } $fh->close; } } else { warn "No working 'ftp' program available!\n"; chdir $dir; return; } unless (-f $file) { warn "Fetching failed: $@\n"; chdir $dir; return; } return if exists $args{size} and -s $file != $args{size}; system($args{run}) if exists $args{run}; unlink($file) if $args{remove}; print(((!exists $args{check_for} or -e $args{check_for}) ? "done!" : "failed! ($!)"), "\n"); chdir $dir; return !$?; } 1; Test-Signature-1.10/inc/Module/Install/Makefile.pm0000644000076500007650000001351110704723020023152 0ustar audreytaudreyt00000000000000#line 1 package Module::Install::Makefile; use strict 'vars'; use Module::Install::Base; use ExtUtils::MakeMaker (); use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.67'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } sub Makefile { $_[0] } my %seen = (); sub prompt { shift; # Infinite loop protection my @c = caller(); if ( ++$seen{"$c[1]|$c[2]|$_[0]"} > 3 ) { die "Caught an potential prompt infinite loop ($c[1]|$c[2]|$_[0])"; } # In automated testing, always use defaults if ( $ENV{AUTOMATED_TESTING} and ! $ENV{PERL_MM_USE_DEFAULT} ) { local $ENV{PERL_MM_USE_DEFAULT} = 1; goto &ExtUtils::MakeMaker::prompt; } else { goto &ExtUtils::MakeMaker::prompt; } } sub makemaker_args { my $self = shift; my $args = ($self->{makemaker_args} ||= {}); %$args = ( %$args, @_ ) if @_; $args; } # For mm args that take multiple space-seperated args, # append an argument to the current list. sub makemaker_append { my $self = sShift; my $name = shift; my $args = $self->makemaker_args; $args->{name} = defined $args->{$name} ? join( ' ', $args->{name}, @_ ) : join( ' ', @_ ); } sub build_subdirs { my $self = shift; my $subdirs = $self->makemaker_args->{DIR} ||= []; for my $subdir (@_) { push @$subdirs, $subdir; } } sub clean_files { my $self = shift; my $clean = $self->makemaker_args->{clean} ||= {}; %$clean = ( %$clean, FILES => join(' ', grep length, $clean->{FILES}, @_), ); } sub realclean_files { my $self = shift; my $realclean = $self->makemaker_args->{realclean} ||= {}; %$realclean = ( %$realclean, FILES => join(' ', grep length, $realclean->{FILES}, @_), ); } sub libs { my $self = shift; my $libs = ref $_[0] ? shift : [ shift ]; $self->makemaker_args( LIBS => $libs ); } sub inc { my $self = shift; $self->makemaker_args( INC => shift ); } my %test_dir = (); sub _wanted_t { /\.t$/ and -f $_ and $test_dir{$File::Find::dir} = 1; } sub tests_recursive { my $self = shift; if ( $self->tests ) { die "tests_recursive will not work if tests are already defined"; } my $dir = shift || 't'; unless ( -d $dir ) { die "tests_recursive dir '$dir' does not exist"; } require File::Find; %test_dir = (); File::Find::find( \&_wanted_t, $dir ); $self->tests( join ' ', map { "$_/*.t" } sort keys %test_dir ); } sub write { my $self = shift; die "&Makefile->write() takes no arguments\n" if @_; my $args = $self->makemaker_args; $args->{DISTNAME} = $self->name; $args->{NAME} = $self->module_name || $self->name || $self->determine_NAME($args); $args->{VERSION} = $self->version || $self->determine_VERSION($args); $args->{NAME} =~ s/-/::/g; if ( $self->tests ) { $args->{test} = { TESTS => $self->tests }; } if ($] >= 5.005) { $args->{ABSTRACT} = $self->abstract; $args->{AUTHOR} = $self->author; } if ( eval($ExtUtils::MakeMaker::VERSION) >= 6.10 ) { $args->{NO_META} = 1; } if ( eval($ExtUtils::MakeMaker::VERSION) > 6.17 and $self->sign ) { $args->{SIGN} = 1; } unless ( $self->is_admin ) { delete $args->{SIGN}; } # merge both kinds of requires into prereq_pm my $prereq = ($args->{PREREQ_PM} ||= {}); %$prereq = ( %$prereq, map { @$_ } map { @$_ } grep $_, ($self->build_requires, $self->requires) ); # merge both kinds of requires into prereq_pm my $subdirs = ($args->{DIR} ||= []); if ($self->bundles) { foreach my $bundle (@{ $self->bundles }) { my ($file, $dir) = @$bundle; push @$subdirs, $dir if -d $dir; delete $prereq->{$file}; } } if ( my $perl_version = $self->perl_version ) { eval "use $perl_version; 1" or die "ERROR: perl: Version $] is installed, " . "but we need version >= $perl_version"; } $args->{INSTALLDIRS} = $self->installdirs; my %args = map { ( $_ => $args->{$_} ) } grep {defined($args->{$_})} keys %$args; my $user_preop = delete $args{dist}->{PREOP}; if (my $preop = $self->admin->preop($user_preop)) { $args{dist} = $preop; } my $mm = ExtUtils::MakeMaker::WriteMakefile(%args); $self->fix_up_makefile($mm->{FIRST_MAKEFILE} || 'Makefile'); } sub fix_up_makefile { my $self = shift; my $makefile_name = shift; my $top_class = ref($self->_top) || ''; my $top_version = $self->_top->VERSION || ''; my $preamble = $self->preamble ? "# Preamble by $top_class $top_version\n" . $self->preamble : ''; my $postamble = "# Postamble by $top_class $top_version\n" . ($self->postamble || ''); local *MAKEFILE; open MAKEFILE, "< $makefile_name" or die "fix_up_makefile: Couldn't open $makefile_name: $!"; my $makefile = do { local $/; }; close MAKEFILE or die $!; $makefile =~ s/\b(test_harness\(\$\(TEST_VERBOSE\), )/$1'inc', /; $makefile =~ s/( -I\$\(INST_ARCHLIB\))/ -Iinc$1/g; $makefile =~ s/( "-I\$\(INST_LIB\)")/ "-Iinc"$1/g; $makefile =~ s/^(FULLPERL = .*)/$1 "-Iinc"/m; $makefile =~ s/^(PERL = .*)/$1 "-Iinc"/m; # Module::Install will never be used to build the Core Perl # Sometimes PERL_LIB and PERL_ARCHLIB get written anyway, which breaks # PREFIX/PERL5LIB, and thus, install_share. Blank them if they exist $makefile =~ s/^PERL_LIB = .+/PERL_LIB =/m; #$makefile =~ s/^PERL_ARCHLIB = .+/PERL_ARCHLIB =/m; # Perl 5.005 mentions PERL_LIB explicitly, so we have to remove that as well. $makefile =~ s/("?)-I\$\(PERL_LIB\)\1//g; # XXX - This is currently unused; not sure if it breaks other MM-users # $makefile =~ s/^pm_to_blib\s+:\s+/pm_to_blib :: /mg; open MAKEFILE, "> $makefile_name" or die "fix_up_makefile: Couldn't open $makefile_name: $!"; print MAKEFILE "$preamble$makefile$postamble" or die $!; close MAKEFILE or die $!; 1; } sub preamble { my ($self, $text) = @_; $self->{preamble} = $text . $self->{preamble} if defined $text; $self->{preamble}; } sub postamble { my ($self, $text) = @_; $self->{postamble} ||= $self->admin->postamble; $self->{postamble} .= $text if defined $text; $self->{postamble} } 1; __END__ #line 363 Test-Signature-1.10/inc/Module/Install/Metadata.pm0000644000076500007650000002152710704723020023163 0ustar audreytaudreyt00000000000000#line 1 package Module::Install::Metadata; use strict 'vars'; use Module::Install::Base; use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.67'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } my @scalar_keys = qw{ name module_name abstract author version license distribution_type perl_version tests installdirs }; my @tuple_keys = qw{ build_requires requires recommends bundles }; sub Meta { shift } sub Meta_ScalarKeys { @scalar_keys } sub Meta_TupleKeys { @tuple_keys } foreach my $key (@scalar_keys) { *$key = sub { my $self = shift; return $self->{values}{$key} if defined wantarray and !@_; $self->{values}{$key} = shift; return $self; }; } foreach my $key (@tuple_keys) { *$key = sub { my $self = shift; return $self->{values}{$key} unless @_; my @rv; while (@_) { my $module = shift or last; my $version = shift || 0; if ( $module eq 'perl' ) { $version =~ s{^(\d+)\.(\d+)\.(\d+)} {$1 + $2/1_000 + $3/1_000_000}e; $self->perl_version($version); next; } my $rv = [ $module, $version ]; push @rv, $rv; } push @{ $self->{values}{$key} }, @rv; @rv; }; } # configure_requires is currently a null-op sub configure_requires { 1 } # Aliases for build_requires that will have alternative # meanings in some future version of META.yml. sub test_requires { shift->build_requires(@_) } sub install_requires { shift->build_requires(@_) } # Aliases for installdirs options sub install_as_core { $_[0]->installdirs('perl') } sub install_as_cpan { $_[0]->installdirs('site') } sub install_as_site { $_[0]->installdirs('site') } sub install_as_vendor { $_[0]->installdirs('vendor') } sub sign { my $self = shift; return $self->{'values'}{'sign'} if defined wantarray and ! @_; $self->{'values'}{'sign'} = ( @_ ? $_[0] : 1 ); return $self; } sub dynamic_config { my $self = shift; unless ( @_ ) { warn "You MUST provide an explicit true/false value to dynamic_config, skipping\n"; return $self; } $self->{'values'}{'dynamic_config'} = $_[0] ? 1 : 0; return $self; } sub all_from { my ( $self, $file ) = @_; unless ( defined($file) ) { my $name = $self->name or die "all_from called with no args without setting name() first"; $file = join('/', 'lib', split(/-/, $name)) . '.pm'; $file =~ s{.*/}{} unless -e $file; die "all_from: cannot find $file from $name" unless -e $file; } $self->version_from($file) unless $self->version; $self->perl_version_from($file) unless $self->perl_version; # The remaining probes read from POD sections; if the file # has an accompanying .pod, use that instead my $pod = $file; if ( $pod =~ s/\.pm$/.pod/i and -e $pod ) { $file = $pod; } $self->author_from($file) unless $self->author; $self->license_from($file) unless $self->license; $self->abstract_from($file) unless $self->abstract; } sub provides { my $self = shift; my $provides = ( $self->{values}{provides} ||= {} ); %$provides = (%$provides, @_) if @_; return $provides; } sub auto_provides { my $self = shift; return $self unless $self->is_admin; unless (-e 'MANIFEST') { warn "Cannot deduce auto_provides without a MANIFEST, skipping\n"; return $self; } # Avoid spurious warnings as we are not checking manifest here. local $SIG{__WARN__} = sub {1}; require ExtUtils::Manifest; local *ExtUtils::Manifest::manicheck = sub { return }; require Module::Build; my $build = Module::Build->new( dist_name => $self->name, dist_version => $self->version, license => $self->license, ); $self->provides(%{ $build->find_dist_packages || {} }); } sub feature { my $self = shift; my $name = shift; my $features = ( $self->{values}{features} ||= [] ); my $mods; if ( @_ == 1 and ref( $_[0] ) ) { # The user used ->feature like ->features by passing in the second # argument as a reference. Accomodate for that. $mods = $_[0]; } else { $mods = \@_; } my $count = 0; push @$features, ( $name => [ map { ref($_) ? ( ref($_) eq 'HASH' ) ? %$_ : @$_ : $_ } @$mods ] ); return @$features; } sub features { my $self = shift; while ( my ( $name, $mods ) = splice( @_, 0, 2 ) ) { $self->feature( $name, @$mods ); } return $self->{values}->{features} ? @{ $self->{values}->{features} } : (); } sub no_index { my $self = shift; my $type = shift; push @{ $self->{values}{no_index}{$type} }, @_ if $type; return $self->{values}{no_index}; } sub read { my $self = shift; $self->include_deps( 'YAML', 0 ); require YAML; my $data = YAML::LoadFile('META.yml'); # Call methods explicitly in case user has already set some values. while ( my ( $key, $value ) = each %$data ) { next unless $self->can($key); if ( ref $value eq 'HASH' ) { while ( my ( $module, $version ) = each %$value ) { $self->can($key)->($self, $module => $version ); } } else { $self->can($key)->($self, $value); } } return $self; } sub write { my $self = shift; return $self unless $self->is_admin; $self->admin->write_meta; return $self; } sub version_from { my ( $self, $file ) = @_; require ExtUtils::MM_Unix; $self->version( ExtUtils::MM_Unix->parse_version($file) ); } sub abstract_from { my ( $self, $file ) = @_; require ExtUtils::MM_Unix; $self->abstract( bless( { DISTNAME => $self->name }, 'ExtUtils::MM_Unix' )->parse_abstract($file) ); } sub _slurp { my ( $self, $file ) = @_; local *FH; open FH, "< $file" or die "Cannot open $file.pod: $!"; do { local $/; }; } sub perl_version_from { my ( $self, $file ) = @_; if ( $self->_slurp($file) =~ m/ ^ use \s* v? ([\d_\.]+) \s* ; /ixms ) { my $v = $1; $v =~ s{_}{}g; $self->perl_version($1); } else { warn "Cannot determine perl version info from $file\n"; return; } } sub author_from { my ( $self, $file ) = @_; my $content = $self->_slurp($file); if ($content =~ m/ =head \d \s+ (?:authors?)\b \s* ([^\n]*) | =head \d \s+ (?:licen[cs]e|licensing|copyright|legal)\b \s* .*? copyright .*? \d\d\d[\d.]+ \s* (?:\bby\b)? \s* ([^\n]*) /ixms) { my $author = $1 || $2; $author =~ s{E}{<}g; $author =~ s{E}{>}g; $self->author($author); } else { warn "Cannot determine author info from $file\n"; } } sub license_from { my ( $self, $file ) = @_; if ( $self->_slurp($file) =~ m/ ( =head \d \s+ (?:licen[cs]e|licensing|copyright|legal)\b .*? ) (=head\\d.*|=cut.*|) \z /ixms ) { my $license_text = $1; my @phrases = ( 'under the same (?:terms|license) as perl itself' => 'perl', 1, 'GNU public license' => 'gpl', 1, 'GNU lesser public license' => 'gpl', 1, 'BSD license' => 'bsd', 1, 'Artistic license' => 'artistic', 1, 'GPL' => 'gpl', 1, 'LGPL' => 'lgpl', 1, 'BSD' => 'bsd', 1, 'Artistic' => 'artistic', 1, 'MIT' => 'mit', 1, 'proprietary' => 'proprietary', 0, ); while ( my ($pattern, $license, $osi) = splice(@phrases, 0, 3) ) { $pattern =~ s{\s+}{\\s+}g; if ( $license_text =~ /\b$pattern\b/i ) { if ( $osi and $license_text =~ /All rights reserved/i ) { warn "LEGAL WARNING: 'All rights reserved' may invalidate Open Source licenses. Consider removing it."; } $self->license($license); return 1; } } } warn "Cannot determine license info from $file\n"; return 'unknown'; } 1; Test-Signature-1.10/inc/Module/Install/Win32.pm0000644000076500007650000000341610704723020022342 0ustar audreytaudreyt00000000000000#line 1 package Module::Install::Win32; use strict; use Module::Install::Base; use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.67'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } # determine if the user needs nmake, and download it if needed sub check_nmake { my $self = shift; $self->load('can_run'); $self->load('get_file'); require Config; return unless ( $^O eq 'MSWin32' and $Config::Config{make} and $Config::Config{make} =~ /^nmake\b/i and ! $self->can_run('nmake') ); print "The required 'nmake' executable not found, fetching it...\n"; require File::Basename; my $rv = $self->get_file( url => 'http://download.microsoft.com/download/vc15/Patch/1.52/W95/EN-US/Nmake15.exe', ftp_url => 'ftp://ftp.microsoft.com/Softlib/MSLFILES/Nmake15.exe', local_dir => File::Basename::dirname($^X), size => 51928, run => 'Nmake15.exe /o > nul', check_for => 'Nmake.exe', remove => 1, ); if (!$rv) { die <<'END_MESSAGE'; ------------------------------------------------------------------------------- Since you are using Microsoft Windows, you will need the 'nmake' utility before installation. It's available at: http://download.microsoft.com/download/vc15/Patch/1.52/W95/EN-US/Nmake15.exe or ftp://ftp.microsoft.com/Softlib/MSLFILES/Nmake15.exe Please download the file manually, save it to a directory in %PATH% (e.g. C:\WINDOWS\COMMAND\), then launch the MS-DOS command line shell, "cd" to that directory, and run "Nmake15.exe" from there; that will create the 'nmake.exe' file needed by this module. You may then resume the installation process described in README. ------------------------------------------------------------------------------- END_MESSAGE } } 1; Test-Signature-1.10/inc/Module/Install/WriteAll.pm0000644000076500007650000000162410704723020023162 0ustar audreytaudreyt00000000000000#line 1 package Module::Install::WriteAll; use strict; use Module::Install::Base; use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.67'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } sub WriteAll { my $self = shift; my %args = ( meta => 1, sign => 0, inline => 0, check_nmake => 1, @_ ); $self->sign(1) if $args{sign}; $self->Meta->write if $args{meta}; $self->admin->WriteAll(%args) if $self->is_admin; if ( $0 =~ /Build.PL$/i ) { $self->Build->write; } else { $self->check_nmake if $args{check_nmake}; unless ( $self->makemaker_args->{'PL_FILES'} ) { $self->makemaker_args( PL_FILES => {} ); } if ($args{inline}) { $self->Inline->write; } else { $self->Makefile->write; } } } 1; Test-Signature-1.10/inc/Module/Install.pm0000644000076500007650000001761110704723020021442 0ustar audreytaudreyt00000000000000#line 1 package Module::Install; # For any maintainers: # The load order for Module::Install is a bit magic. # It goes something like this... # # IF ( host has Module::Install installed, creating author mode ) { # 1. Makefile.PL calls "use inc::Module::Install" # 2. $INC{inc/Module/Install.pm} set to installed version of inc::Module::Install # 3. The installed version of inc::Module::Install loads # 4. inc::Module::Install calls "require Module::Install" # 5. The ./inc/ version of Module::Install loads # } ELSE { # 1. Makefile.PL calls "use inc::Module::Install" # 2. $INC{inc/Module/Install.pm} set to ./inc/ version of Module::Install # 3. The ./inc/ version of Module::Install loads # } use 5.004; use strict 'vars'; use vars qw{$VERSION}; BEGIN { # All Module::Install core packages now require synchronised versions. # This will be used to ensure we don't accidentally load old or # different versions of modules. # This is not enforced yet, but will be some time in the next few # releases once we can make sure it won't clash with custom # Module::Install extensions. $VERSION = '0.67'; } # Whether or not inc::Module::Install is actually loaded, the # $INC{inc/Module/Install.pm} is what will still get set as long as # the caller loaded module this in the documented manner. # If not set, the caller may NOT have loaded the bundled version, and thus # they may not have a MI version that works with the Makefile.PL. This would # result in false errors or unexpected behaviour. And we don't want that. my $file = join( '/', 'inc', split /::/, __PACKAGE__ ) . '.pm'; unless ( $INC{$file} ) { die <<"END_DIE"; Please invoke ${\__PACKAGE__} with: use inc::${\__PACKAGE__}; not: use ${\__PACKAGE__}; END_DIE } # If the script that is loading Module::Install is from the future, # then make will detect this and cause it to re-run over and over # again. This is bad. Rather than taking action to touch it (which # is unreliable on some platforms and requires write permissions) # for now we should catch this and refuse to run. if ( -f $0 and (stat($0))[9] > time ) { die << "END_DIE"; Your installer $0 has a modification time in the future. This is known to create infinite loops in make. Please correct this, then run $0 again. END_DIE } use Cwd (); use File::Find (); use File::Path (); use FindBin; *inc::Module::Install::VERSION = *VERSION; @inc::Module::Install::ISA = __PACKAGE__; sub autoload { my $self = shift; my $who = $self->_caller; my $cwd = Cwd::cwd(); my $sym = "${who}::AUTOLOAD"; $sym->{$cwd} = sub { my $pwd = Cwd::cwd(); if ( my $code = $sym->{$pwd} ) { # delegate back to parent dirs goto &$code unless $cwd eq $pwd; } $$sym =~ /([^:]+)$/ or die "Cannot autoload $who - $sym"; unshift @_, ($self, $1); goto &{$self->can('call')} unless uc($1) eq $1; }; } sub import { my $class = shift; my $self = $class->new(@_); my $who = $self->_caller; unless ( -f $self->{file} ) { require "$self->{path}/$self->{dispatch}.pm"; File::Path::mkpath("$self->{prefix}/$self->{author}"); $self->{admin} = "$self->{name}::$self->{dispatch}"->new( _top => $self ); $self->{admin}->init; @_ = ($class, _self => $self); goto &{"$self->{name}::import"}; } *{"${who}::AUTOLOAD"} = $self->autoload; $self->preload; # Unregister loader and worker packages so subdirs can use them again delete $INC{"$self->{file}"}; delete $INC{"$self->{path}.pm"}; } sub preload { my ($self) = @_; unless ( $self->{extensions} ) { $self->load_extensions( "$self->{prefix}/$self->{path}", $self ); } my @exts = @{$self->{extensions}}; unless ( @exts ) { my $admin = $self->{admin}; @exts = $admin->load_all_extensions; } my %seen; foreach my $obj ( @exts ) { while (my ($method, $glob) = each %{ref($obj) . '::'}) { next unless $obj->can($method); next if $method =~ /^_/; next if $method eq uc($method); $seen{$method}++; } } my $who = $self->_caller; foreach my $name ( sort keys %seen ) { *{"${who}::$name"} = sub { ${"${who}::AUTOLOAD"} = "${who}::$name"; goto &{"${who}::AUTOLOAD"}; }; } } sub new { my ($class, %args) = @_; # ignore the prefix on extension modules built from top level. my $base_path = Cwd::abs_path($FindBin::Bin); unless ( Cwd::abs_path(Cwd::cwd()) eq $base_path ) { delete $args{prefix}; } return $args{_self} if $args{_self}; $args{dispatch} ||= 'Admin'; $args{prefix} ||= 'inc'; $args{author} ||= ($^O eq 'VMS' ? '_author' : '.author'); $args{bundle} ||= 'inc/BUNDLES'; $args{base} ||= $base_path; $class =~ s/^\Q$args{prefix}\E:://; $args{name} ||= $class; $args{version} ||= $class->VERSION; unless ( $args{path} ) { $args{path} = $args{name}; $args{path} =~ s!::!/!g; } $args{file} ||= "$args{base}/$args{prefix}/$args{path}.pm"; bless( \%args, $class ); } sub call { my ($self, $method) = @_; my $obj = $self->load($method) or return; splice(@_, 0, 2, $obj); goto &{$obj->can($method)}; } sub load { my ($self, $method) = @_; $self->load_extensions( "$self->{prefix}/$self->{path}", $self ) unless $self->{extensions}; foreach my $obj (@{$self->{extensions}}) { return $obj if $obj->can($method); } my $admin = $self->{admin} or die <<"END_DIE"; The '$method' method does not exist in the '$self->{prefix}' path! Please remove the '$self->{prefix}' directory and run $0 again to load it. END_DIE my $obj = $admin->load($method, 1); push @{$self->{extensions}}, $obj; $obj; } sub load_extensions { my ($self, $path, $top) = @_; unless ( grep { lc $_ eq lc $self->{prefix} } @INC ) { unshift @INC, $self->{prefix}; } foreach my $rv ( $self->find_extensions($path) ) { my ($file, $pkg) = @{$rv}; next if $self->{pathnames}{$pkg}; local $@; my $new = eval { require $file; $pkg->can('new') }; unless ( $new ) { warn $@ if $@; next; } $self->{pathnames}{$pkg} = delete $INC{$file}; push @{$self->{extensions}}, &{$new}($pkg, _top => $top ); } $self->{extensions} ||= []; } sub find_extensions { my ($self, $path) = @_; my @found; File::Find::find( sub { my $file = $File::Find::name; return unless $file =~ m!^\Q$path\E/(.+)\.pm\Z!is; my $subpath = $1; return if lc($subpath) eq lc($self->{dispatch}); $file = "$self->{path}/$subpath.pm"; my $pkg = "$self->{name}::$subpath"; $pkg =~ s!/!::!g; # If we have a mixed-case package name, assume case has been preserved # correctly. Otherwise, root through the file to locate the case-preserved # version of the package name. if ( $subpath eq lc($subpath) || $subpath eq uc($subpath) ) { open PKGFILE, "<$subpath.pm" or die "find_extensions: Can't open $subpath.pm: $!"; my $in_pod = 0; while ( ) { $in_pod = 1 if /^=\w/; $in_pod = 0 if /^=cut/; next if ($in_pod || /^=cut/); # skip pod text next if /^\s*#/; # and comments if ( m/^\s*package\s+($pkg)\s*;/i ) { $pkg = $1; last; } } close PKGFILE; } push @found, [ $file, $pkg ]; }, $path ) if -d $path; @found; } sub _caller { my $depth = 0; my $call = caller($depth); while ( $call eq __PACKAGE__ ) { $depth++; $call = caller($depth); } return $call; } 1; Test-Signature-1.10/INSTALL0000644000076500007650000000667610704722670016554 0ustar audreytaudreyt00000000000000Installation Instructions The instructions are basically as per any Perl module. INSTALLING AUTOMATICALLY ------------------------ The easiest way to install is via CPAN or CPANPLUS: CPAN: % perl -MCPAN -e shell [as root] > install Test::Signature > quit CPANPLUS: % cpanp > i Test::Signature > q See your local 'perldoc CPAN' or 'perldoc CPANPLUS' for instructions on setting up and configuring CPAN or CPANPLUS. OBTAINING THE MODULE -------------------- The latest release version of Test::Signature can be downloaded from any CPAN site: http://www.cpan.org/modules/by-authors/id/A/AU/AUDREYT/ http://search.cpan.org/dist/Test-Signature/ Test::Signature is distributed as a gzipped tar archive file: Test-Signature-.tar.gz where represents the current version number, e.g. 1.05. To install the module, unpack the distribution archive to create an installation directory. Something like this: tar zxf Test-Signature-1.05.tar.gz or gunzip Test-Signature-1.05.tar.gz tar xf Test-Signature-1.05.tar You can then 'cd' into the directory created, cd Test-Signature-1.05 INSTALLING MANUALLY ------------------- First, verify the package's integrity by ensuring you have Module::Signature installed, then type: % cpansign -v That will check each file's integrity, as well as the signature's validity, thus verifying the integrity of the entire package. If "==> Signature verified OK! <==" is not displayed, the distribution may already have been compromised, and you should not run its Makefile.PL. Ideally, you should confirm with a third party that the finger print and key id by which the signature was signed is indeed the key it is meant to be (ideally you'll have an appropriate web of trust set up, but that's not always possible). The 'make install' (done later) will install the modules and scripts on your system. You may need administrator privileges to perform this task. Alternately you can install the module to a local directory (see ExtUtils::MakeMaker for full details), e.g. % perl Makefile.PL PREFIX=/home/abw/ Don't forget to update your PERL5LIB environment variable if you do this, or add a line to your script to tell Perl where to find the files, e.g. use lib qw( /home/abw/lib/perl5/site_perl/5.6.0 ); If you're not after a custom location, just do: % perl Makefile.PL If you are lacking any of the prerequisite modules, running that program will tell you. All prerequisites are available from CPAN. When you have them all: % make && make test If there are any failures, it's best if you contact me. It may help other people who have the same problem. I don't tend to read the Perl newsgroups or PerlMonks, so it's no use posting there. When you report your trouble, be sure to send me the following information; + result of `perl -V' + output from 'make test' - ideally do 'make test TEST_VERBOSE=1 >& errs' Send those to bug-Test-Signature@rt.cpan.org and I'll get back to you as soon as I'm able. If it worked, then become root and type: # make install Congratulations. You've just installed Test::Signature. If you have a copy of cpantest installed, type: % cpantest -g pass -nc -p `basename \`pwd\`` -auto Or: % cpantest -g pass -nc -p Test-Signature-1.05 -auto That will tell both me and other potential users that the module built correctly on your machine. cheers, Iain (aka Spoon). http://iain.truskett.id.au/ Test-Signature-1.10/lib/0000755000076500007650000000000010704723031016242 5ustar audreytaudreyt00000000000000Test-Signature-1.10/lib/Test/0000755000076500007650000000000010704723031017161 5ustar audreytaudreyt00000000000000Test-Signature-1.10/lib/Test/Signature.pm0000644000076500007650000002021410704723017021463 0ustar audreytaudreyt00000000000000package Test::Signature; use 5.004; use strict; use vars qw( $VERSION @ISA @EXPORT @EXPORT_OK ); use Exporter; use Test::Builder; BEGIN { $VERSION = '1.10'; @ISA = qw( Exporter ); @EXPORT = qw( signature_ok ); @EXPORT_OK = qw( signature_force_ok ); } my $test = Test::Builder->new(); =head1 NAME Test::Signature - Automated SIGNATURE testing =head1 SYNOPSIS # This is actually the t/0-signature.t file from this distribution. use Test::More tests => 1; use Test::Signature; signature_ok(); =head1 ABSTRACT C verifies that the C generated signature of a module is correct. =head1 DESCRIPTION C allows you to verify that a distribution has not been tampered with. C lets that be tested as part of the distribution's test suite. By default, if C is not installed then it will just say so and not fail the test. That can be overridden though. B: This is not a substitute for the users verifying the distribution themselves. By the time this module is run, the users will have already run your F or F scripts which could have been compromised. This module is more for ensuring you've updated your signature appropriately before distributing, and for preventing accidental errors during transmission or packaging. =cut =head1 FUNCTIONS C is exported by default. C must be explicitly exported. =head2 signature_ok() This will test that the C generated signature is valid for the distribution. It can be given two optional parameters. The first is a name for the test. The default is C. The second is whether a lack of C should be regarded as a failure. The default is C<0> meaning 'no'. # Test with defaults signature_ok() # Test with custom name signature_ok( "Is the signature valid?" ); # Test with custom name and force C to exist signature_ok( "Is the signature valid?", 1 ); # Test without custom name, but forcing signature_ok( undef, 1 ); =cut sub action_skip { $test->skip( $_[0] ) } sub action_ok { $test->ok( 0, $_[0] ) } sub signature_ok { my $name = shift || 'Valid signature'; my $force = shift || 0; my $action = $force ? \&action_ok : \&action_skip; SKIP: { if ( !-s 'SIGNATURE' ) { $action->("No SIGNATURE file found."); } elsif ( !eval { require Module::Signature; 1 } ) { $action->( "Next time around, consider installing Module::Signature, " . "so you can verify the integrity of this distribution." ); } elsif ( !eval { require Socket; Socket::inet_aton('pgp.mit.edu') } ) { $action->("Cannot connect to the keyserver."); } else { $test->ok( Module::Signature::verify() == Module::Signature::SIGNATURE_OK() => $name ); } } } =head2 signature_force_ok() This is equivalent to calling C<< signature_ok( $name, 1 ) >> but is more readable. # These are equivalent: signature_force_ok( "Is our signature valid?" ); signature_ok( "Is our signature valid?", 1); # These are equivalent: signature_force_ok(); signature_ok( undef, 1 ); =cut sub signature_force_ok { signature_ok( $_[0] || undef, 1 ); } 1; __END__ =head1 NOTES ON USE =head2 F and F It is B that your F and F files be accurate and complete. If you are using C and you do not have a F file, then don't worry about the rest of this. If you do have a F file, or you use C, you must read this. Since the test is run at C time, the distribution has been made. Thus your F file should have the entries listed below. If you're using C, you should have, at least: #defaults ^Makefile$ ^blib/ ^blibdirs$ ^pm_to_blib$ These entries are part of the default set provided by C, which is ignored if you provide your own F file. If you are using C, there is no default F so you B provide your own. It must, minimally, contain: ^Build$ ^Makefile$ ^_build/ ^blib/ If you don't have the correct entries, C will complain that you have: ==> MISMATCHED content between MANIFEST and distribution files! <== You should note this during normal development testing anyway. =head2 Use with Test::Prereq C tends to get a bit particular about modules. If you're using the I option with C then you will have to specify that you expect C as a prerequisite. C will not have it as a prerequisite since that would defeat the point of having the I variant. If you are using C you should have a line like the following in your F: 'PREREQ_PM' => { 'Test::Signature' => '1.04', 'Module::Signature' => '0.22', 'Test::More' => '0.47', }, If using C, your F should have: build_requires => { 'Test::Signature' => '1.04', 'Module::Signature' => '0.22', 'Test::More' => '0.47', }, If you just want the default behaviour of testing the signature if and only if the user already has C installed, then you will need something like the following code. The example uses C format but it should be trivial for you to translate to C. #!/usr/bin/perl -w use strict; use Module::Build 0.18; my @extra_build; eval { require Module::Signature }; if (!$@ or $Test::Prereq::VERSION) { push @extra_build, "Module::Signature" => '0.22' } my $m = Module::Build->new( dist_name => 'WWW-Yahoo-Groups', dist_version => '1.7.7', license => 'perl', requires => { # various modules 'perl' => '5.6.0', }, build_requires => { 'Test::More' => 0.47, 'Test::Prereq' => 0.19, 'Test::Prereq::Build' => 0.04, 'Test::Signature' => 1.04, @extra_build, }, ); $m->create_build_script; If you have any questions on using this module with C, just email me (address below). =head2 Use with Module::Install C is a module to assist in the bundling of build prerequisite modules in packages. Well, among other things. C is a perfect candidate for such a module. As it's a module aimed purely at those writing modules rather than those using them. Here's a good way to use it: Make a test file (say, F) that contains the following: use lib 'inc'; use Test::More tests => 1; use Test::Signature; signature_ok(); In your F (or F if appropriate) add: include 'Test::Signature'; And that's it! You don't have to specify it as a prerequisite or anything like that because C will include it in your distribution. And you don't have to worry about size because C strips out all this waffling POD. =head1 THANKS Arthur Bergman for suggesting the module. Audrey Tang for writing L, and making some suggestions. Tels suggested testing network connectivity to Audrey; Audrey added that to C 0.16 and I (Iain Truskett) added it to this module (as of 1.03). =head1 BUGS Please report bugs at Ebug-test-signature@rt.cpan.orgE or via the web interface at L =head1 AUTHORS Audrey Tang Ecpan@audreyt.orgE Original author: Iain Truskett Espoon@cpan.orgE, now passed away. =head1 LICENSE AND COPYRIGHT Copyright 2002, 2003 by Iain Truskett. Copyright 2003, 2007 by Audrey Tang Ecpan@audreyt.orgE. This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =head1 SEE ALSO L, L, L. L, L, L. L, L. =cut Test-Signature-1.10/Makefile.PL0000644000076500007650000000036110704721636017457 0ustar audreytaudreyt00000000000000#!/usr/local/bin/perl use strict; use inc::Module::Install; name 'Test-Signature'; all_from 'lib/Test/Signature.pm'; requires 'Test::Builder' => '0.17'; requires 'Test::More' => '0.47'; auto_provides; sign; WriteAll; Test-Signature-1.10/MANIFEST0000644000076500007650000000054410704722756016645 0ustar audreytaudreyt00000000000000Changes inc/Module/Install.pm inc/Module/Install/Base.pm inc/Module/Install/Can.pm inc/Module/Install/Fetch.pm inc/Module/Install/Makefile.pm inc/Module/Install/Metadata.pm inc/Module/Install/Win32.pm inc/Module/Install/WriteAll.pm INSTALL lib/Test/Signature.pm Makefile.PL MANIFEST This list of files META.yml README SIGNATURE t/0-signature.t t/9-pod.t Test-Signature-1.10/META.yml0000644000076500007650000000074010704723027016753 0ustar audreytaudreyt00000000000000--- abstract: Automated SIGNATURE testing author: Audrey Tang distribution_type: module generated_by: Module::Install version 0.67 license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.3.html version: 1.3 name: Test-Signature no_index: directory: - inc - t provides: Test::Signature: file: lib/Test/Signature.pm version: 1.10 requires: Test::Builder: 0.17 Test::More: 0.47 perl: 5.004 version: 1.10 Test-Signature-1.10/README0000644000076500007650000001656310704722422016372 0ustar audreytaudreyt00000000000000NAME Test::Signature - Automated SIGNATURE testing SYNOPSIS # This is actually the t/0-signature.t file from this distribution. use Test::More tests => 1; use Test::Signature; signature_ok(); ABSTRACT "Test::Signature" verifies that the "Module::Signature" generated signature of a module is correct. DESCRIPTION "Module::Signature" allows you to verify that a distribution has not been tampered with. "Test::Signature" lets that be tested as part of the distribution's test suite. By default, if "Module::Signature" is not installed then it will just say so and not fail the test. That can be overridden though. IMPORTANT: This is not a substitute for the users verifying the distribution themselves. By the time this module is run, the users will have already run your Makefile.PL or Build.PL scripts which could have been compromised. This module is more for ensuring you've updated your signature appropriately before distributing, and for preventing accidental errors during transmission or packaging. FUNCTIONS "signature_ok" is exported by default. "signature_force_ok" must be explicitly exported. signature_ok() This will test that the "Module::Signature" generated signature is valid for the distribution. It can be given two optional parameters. The first is a name for the test. The default is "Valid signature". The second is whether a lack of "Module::Signature" should be regarded as a failure. The default is 0 meaning 'no'. # Test with defaults signature_ok() # Test with custom name signature_ok( "Is the signature valid?" ); # Test with custom name and force C to exist signature_ok( "Is the signature valid?", 1 ); # Test without custom name, but forcing signature_ok( undef, 1 ); signature_force_ok() This is equivalent to calling "signature_ok( $name, 1 )" but is more readable. # These are equivalent: signature_force_ok( "Is our signature valid?" ); signature_ok( "Is our signature valid?", 1); # These are equivalent: signature_force_ok(); signature_ok( undef, 1 ); NOTES ON USE MANIFEST and MANIFEST.SKIP It is imperative that your MANIFEST and MANIFEST.SKIP files be accurate and complete. If you are using "ExtUtils::MakeMaker" and you do not have a MANIFEST.SKIP file, then don't worry about the rest of this. If you do have a MANIFEST.SKIP file, or you use "Module::Build", you must read this. Since the test is run at "make test" time, the distribution has been made. Thus your MANIFEST.SKIP file should have the entries listed below. If you're using "ExtUtils::MakeMaker", you should have, at least: #defaults ^Makefile$ ^blib/ ^blibdirs$ ^pm_to_blib$ These entries are part of the default set provided by "ExtUtils::Manifest", which is ignored if you provide your own MANIFEST.SKIP file. If you are using "Module::Build", there is no default MANIFEST.SKIP so you must provide your own. It must, minimally, contain: ^Build$ ^Makefile$ ^_build/ ^blib/ If you don't have the correct entries, "Module::Signature" will complain that you have: ==> MISMATCHED content between MANIFEST and distribution files! <== You should note this during normal development testing anyway. Use with Test::Prereq "Test::Prereq" tends to get a bit particular about modules. If you're using the *force* option with "Test::Signature" then you will have to specify that you expect "Module::Signature" as a prerequisite. "Test::Signature" will not have it as a prerequisite since that would defeat the point of having the *force* variant. If you are using "ExtUtils::MakeMaker" you should have a line like the following in your Makefile.PL: 'PREREQ_PM' => { 'Test::Signature' => '1.04', 'Module::Signature' => '0.22', 'Test::More' => '0.47', }, If using "Module::Build", your Build.PL should have: build_requires => { 'Test::Signature' => '1.04', 'Module::Signature' => '0.22', 'Test::More' => '0.47', }, If you just want the default behaviour of testing the signature if and only if the user already has "Module::Signature" installed, then you will need something like the following code. The example uses "Module::Build" format but it should be trivial for you to translate to "ExtUtils::MakeMaker". #!/usr/bin/perl -w use strict; use Module::Build 0.18; my @extra_build; eval { require Module::Signature }; if (!$@ or $Test::Prereq::VERSION) { push @extra_build, "Module::Signature" => '0.22' } my $m = Module::Build->new( dist_name => 'WWW-Yahoo-Groups', dist_version => '1.7.7', license => 'perl', requires => { # various modules 'perl' => '5.6.0', }, build_requires => { 'Test::More' => 0.47, 'Test::Prereq' => 0.19, 'Test::Prereq::Build' => 0.04, 'Test::Signature' => 1.04, @extra_build, }, ); $m->create_build_script; If you have any questions on using this module with "Test::Prereq", just email me (address below). Use with Module::Install "Module::Install" is a module to assist in the bundling of build prerequisite modules in packages. Well, among other things. "Test::Signature" is a perfect candidate for such a module. As it's a module aimed purely at those writing modules rather than those using them. Here's a good way to use it: Make a test file (say, t/00sig.t) that contains the following: use lib 'inc'; use Test::More tests => 1; use Test::Signature; signature_ok(); In your Makefile.PL (or Build.PL if appropriate) add: include 'Test::Signature'; And that's it! You don't have to specify it as a prerequisite or anything like that because "Module::Install" will include it in your distribution. And you don't have to worry about size because "Module::Install" strips out all this waffling POD. THANKS Arthur Bergman for suggesting the module. Audrey Tang for writing Module::Signature, and making some suggestions. Tels suggested testing network connectivity to Audrey; Audrey added that to "Module::Signature" 0.16 and I (Iain Truskett) added it to this module (as of 1.03). BUGS Please report bugs at or via the web interface at AUTHORS Iain Truskett , now passed away. Currently maintained by Audrey Tang LICENSE AND COPYRIGHT Copyright 2002, 2003 by Iain Truskett. All rights reserved. Copyright 2003, 2007 by Audrey Tang . This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself. SEE ALSO perl, Module::Signature, Test::More. Module::Build, ExtUtils::Manifest, ExtUtils::MakeMaker. Test::Prereq, Module::Install. Test-Signature-1.10/SIGNATURE0000644000076500007650000000344310704723033016766 0ustar audreytaudreyt00000000000000This file contains message digests of all files listed in MANIFEST, signed via the Module::Signature module, version 0.55. To verify the content in this distribution, first make sure you have Module::Signature installed, then type: % cpansign -v It will check each file's integrity, as well as the signature's validity. If "==> Signature verified OK! <==" is not displayed, the distribution may already have been compromised, and you should not run its Makefile.PL or Build.PL. -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 SHA1 8f8fb652658f89610492c1ae59c66edbd986aa90 Changes SHA1 4e742aac79b5fb92216a2f20db73c77ca2d8968e INSTALL SHA1 3522a8584f44dd25ffaf5a59e9dbc36932b20dec MANIFEST SHA1 a628ee35fc253094ed14f42a383556aa0129c390 META.yml SHA1 c14df95057379f66936c5bb23decafb6501234e5 Makefile.PL SHA1 2b00e136a96d504a092f86cd54190374a469a656 README SHA1 78edb89a439463e44c33a72bbee84c54d0dc8aaf inc/Module/Install.pm SHA1 8ea4e37df83fd0c1c050be5c8da75545c3828d9b inc/Module/Install/Base.pm SHA1 1da6031583c32f0d1ec073b8376102fc51427dcc inc/Module/Install/Can.pm SHA1 b779375b90c16af2f31f38a1dd2b5df223c7f2fb inc/Module/Install/Fetch.pm SHA1 2054450e1e9c1dd8056362bf4a64ae70d5d71476 inc/Module/Install/Makefile.pm SHA1 5d6189b2cad15cf9932a28faafd55130c8247e83 inc/Module/Install/Metadata.pm SHA1 02af973fae2ac3531fa6b704574b2b8cb2a08148 inc/Module/Install/Win32.pm SHA1 3a2eab96e91cca8d99938cda7791759ae9d97b3a inc/Module/Install/WriteAll.pm SHA1 8ac451b80e4c420aac1f795e9e254b1cdff52431 lib/Test/Signature.pm SHA1 22ff815f7bd1e63c3c6a925c8cce23e76c277004 t/0-signature.t SHA1 a216b0928445955e2c8b48c850faef40d3328321 t/9-pod.t -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.3 (Darwin) iD8DBQFHE6YbtLPdNzw1AaARAqjrAKCejK/WlxEwWFCLBB9yWj0CrHhgzQCgjVL+ iOpdP/mIz1AiiCkD9vfMy90= =5dvI -----END PGP SIGNATURE----- Test-Signature-1.10/t/0000755000076500007650000000000010704723031015737 5ustar audreytaudreyt00000000000000Test-Signature-1.10/t/0-signature.t0000644000076500007650000000014110704722074020264 0ustar audreytaudreyt00000000000000#!/usr/bin/perl -w use strict; use Test::More tests => 1; use Test::Signature; signature_ok(); Test-Signature-1.10/t/9-pod.t0000644000076500007650000000071107712366031017063 0ustar audreytaudreyt00000000000000#!/usr/bin/perl -w use strict; use vars qw( @files ); BEGIN { eval "require File::Find::Rule"; if ($@) { print "1..1\nok 1 # skip File::Find::Rule not installed\n"; exit; } @files = File::Find::Rule->file()->name( '*.pm' )->in( 'blib/lib' ); } use Test::More tests => scalar @files; eval "use Test::Pod 0.95"; SKIP: { skip "Test::Pod 0.95 not installed.", scalar @files if $@; pod_file_ok( $_ ) for @files; }