libextutils-autoinstall-perl-0.63/0000750000175000017500000000000010311300316017112 5ustar bastianbastianlibextutils-autoinstall-perl-0.63/Changes0000640000175000017500000000057710311277542020435 0ustar bastianbastian== Changes for 0.63 - September 12, 2005 * Added some text in the POD's synopsis regarding --defaultdeps and the environment variable. == Changes for 0.62 - July 9, 2005 * With CPANPLUS, we no longer probe $Config{sitelib} for writability and suggest `sudo` for the entire installation process, as CPANPLUS can handle this with `sudo` on `make install`. Reported by Sungo. libextutils-autoinstall-perl-0.63/MANIFEST0000640000175000017500000000067510311300065020255 0ustar bastianbastianAUTHORS Changes inc/ExtUtils/AutoInstall.pm inc/Module/Install.pm inc/Module/Install/AutoInstall.pm inc/Module/Install/Base.pm inc/Module/Install/Can.pm inc/Module/Install/Fetch.pm inc/Module/Install/Include.pm inc/Module/Install/Makefile.pm inc/Module/Install/Metadata.pm inc/Module/Install/Win32.pm inc/Module/Install/WriteAll.pm lib/ExtUtils/AutoInstall.pm Makefile.PL MANIFEST This list of files META.yml README SIGNATURE t/1-basic.t TODO libextutils-autoinstall-perl-0.63/META.yml0000640000175000017500000000051610311300073020366 0ustar bastianbastianname: ExtUtils-AutoInstall version: 0.63 abstract: Automatic install of dependencies via CPAN author: Autrijus Tang license: perl distribution_type: module requires: Cwd: 0 Carp: 0 ExtUtils::Manifest: 0 ExtUtils::MakeMaker: 0 no_index: directory: - inc generated_by: Module::Install version 0.370 libextutils-autoinstall-perl-0.63/TODO0000640000175000017500000000023710310275374017623 0ustar bastianbastian- Request for a specific version instead of the latest. - A cleaner self-boostrap block. - Default autoconf-like test utilities. - Module::Build integration. libextutils-autoinstall-perl-0.63/SIGNATURE0000640000175000017500000000401010311300310020364 0ustar bastianbastianThis file contains message digests of all files listed in MANIFEST, signed via the Module::Signature module, version 0.41. To verify the content in this distribution, first make sure you have Module::Signature installed, then type: % cpansign -v It would 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 48ba7b9b0070b50c16b518dc1c21436efb31a421 AUTHORS SHA1 17a14654729486e47bb2c4cf91623f16c27da833 Changes SHA1 556c1a8dc5692d7c982589b45de392018810ae90 MANIFEST SHA1 7962ab6d905fa834373f87d4ae6fd53584617952 META.yml SHA1 154b71228e053034fa0ee626ec72b6d8620cf8e2 Makefile.PL SHA1 9e96a3756898d07e6f9932e6f1acc21ecbec5dfa README SHA1 e7326dddbecb834552e8392824a286515385013e TODO SHA1 c9a5c36ff588a3fbbe37ff8660b6830f9368748f inc/ExtUtils/AutoInstall.pm SHA1 19e565da4e1516f3e722d54142e715eae98b6fd9 inc/Module/Install.pm SHA1 485d8ff10f85ab63ab4d29b77eccd298043a692e inc/Module/Install/AutoInstall.pm SHA1 a7f7e2bfb0ac6f8ad965832ef3a246a7bd433058 inc/Module/Install/Base.pm SHA1 7b0e82ea99187c2121bfc8fe590de8363e8100d7 inc/Module/Install/Can.pm SHA1 d097dedadac0edcafbee3a14c262e24089f5795e inc/Module/Install/Fetch.pm SHA1 08bfc9e53d1e15f5556c9d282a7db70a68b9ff06 inc/Module/Install/Include.pm SHA1 69b187644e08b73ab9ffbcb61ee51291e693685f inc/Module/Install/Makefile.pm SHA1 7298762404963528a5abcb0fa76cfe12afb9b87c inc/Module/Install/Metadata.pm SHA1 8ee248d67d4c61a4f01e6a96c41afbd93be4c9ef inc/Module/Install/Win32.pm SHA1 3c099dd7fb73a49bcc489b152c3ca3c7a1b36427 inc/Module/Install/WriteAll.pm SHA1 223fde4939b1710719e77871348fd82a3d42c021 lib/ExtUtils/AutoInstall.pm SHA1 907a089e21ac3559ca99033e066535491321e601 t/1-basic.t -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.2 (FreeBSD) iD8DBQFDJYDItLPdNzw1AaARAtweAJ4lHLNfzQPBYice2wJK7H+5hru+mQCbBP4f rfG8NxpkJ/O4UCSYU/weHqI= =3WyS -----END PGP SIGNATURE----- libextutils-autoinstall-perl-0.63/README0000640000175000017500000000232010310275374020006 0ustar bastianbastianThis is the README file for ExtUtils::AutoInstall, a module to let Makefile.PL automatically install dependencies via CPAN or CPANPLUS. = Features * Letting the user enable/disable optional dependencies. * Support sane defaults by probing for the machine's capability. * If not inside a cpan shell, use CPAN.pm to install dependencies. * Enable/disable the associated tests automatically. * Supply UNINST=1 when it is safe and possibly needed. * Checks MANIFEST to avoid unnecessary grepping of EXE_FILES. * Utilizes CPANPLUS and/or Sort::Versions where feasible. * Offers check-only and skip-all Makefile.PL targets. * Offers check-only and install-only Makefile targets. * Take advantage of the 'sudo' command where available. = Installation ExtUtils::AutoInstall uses the standard perl module install process: cpansign -v # optional; see SIGNATURE for details perl Makefile.PL make # or 'nmake' on Win32 make test make install = Copyright Copyright 2001, 2002, 2003, 2004, 2005 by Autrijus Tang . All rights reserved. You can redistribute and/or modify this bundle under the same terms as Perl itself. See . libextutils-autoinstall-perl-0.63/t/0000750000175000017500000000000011002710167017364 5ustar bastianbastianlibextutils-autoinstall-perl-0.63/t/1-basic.t0000640000175000017500000001301110310275371020771 0ustar bastianbastian#!/usr/bin/perl # $File: //member/autrijus/ExtUtils-AutoInstall/t/1-basic.t $ $Author: autrijus $ # $Revision: #1 $ $Change: 7911 $ $DateTime: 2003/09/06 14:31:22 $ use strict; use Test; BEGIN { plan tests => 6; $^W = 0; }; # Intercepts calls to WriteMakefile and prompt. my $mm_args; my @prompts = qw/y n n y y/; use ExtUtils::MakeMaker; sub ExtUtils::MakeMaker::WriteMakefile { $mm_args = {@_} } sub ExtUtils::MakeMaker::prompt ($;$) { return 'n' } # tiehandle trick to intercept STDOUT. sub PRINT { my $self = shift; $$self .= join '', @_; } sub PRINTF { my $self = shift; $$self .= sprintf(shift, @_); } sub TIEHANDLE { my $self = ''; return bless \$self, shift; } sub READ {} sub READLINE {} sub GETC {} sub FILENO {} require Symbol; my $fh = Symbol::gensym; my $out = tie *$fh, __PACKAGE__; select(*$fh); # test from a clean state $ENV{PERL_EXTUTILS_AUTOINSTALL} = ''; require ExtUtils::AutoInstall; ExtUtils::AutoInstall::_accept_default(0); *ExtUtils::AutoInstall::_prompt = sub { ok($_[1], shift(@prompts)); return 'n'; }; # calls the module. ok(eval <<'.', $@); use ExtUtils::AutoInstall ( -version => '0.21', # ExtUtils::AutoInstall version -config => { make_args => '--hello' # option(s) for CPAN::Config }, -core => [ # core modules Package0 => '', # any version would do ], 'Feature1' => [ # do we want to install this feature by default? -default => 0, Package1 => '0.01', ], 'Feature2' => [ # associate tests to be disabled along with this -tests => [ $0 ], Package2 => '0.02', ], 'Feature3' => { # hash reference works, too Package3 => '0.03', }, ); ''; . # simulates a makefile. WriteMakefile( AUTHOR => 'Joe Hacker (joe@hacker.org)', ABSTRACT => 'Perl Interface to Joe Hacker', NAME => 'Joe::Hacker', VERSION_FROM => 'Hacker.pm', DISTNAME => 'Joe-Hacker', EXE_FILES => [ qw/foo bar baz/ ], ); # XXX - test currently disabled in anticipation of a # rewrite using Test::MockObject. exit; $$out =~ s/.*\n//; # strip the version-dependent line. ok($$out, qr/\Q*** Checking for dependencies... [Core Features] - Package0 ...failed! (needed) [Feature1] - Package1 ...failed! (needs 0.01) [Feature2] - Package2 ...failed! (needs 0.02) [Feature3] - Package3 ...failed! (needs 0.03)\E .*\Q *** ExtUtils::AutoInstall configuration finished.\E/s); use vars qw/@Data_Stack $DNE/; $mm_args->{test}{TESTS} = ''; # XXX: workaround false-positive globbing ok(_deep_check($mm_args, { ABSTRACT => 'Perl Interface to Joe Hacker', test => { 'TESTS' => '' }, NAME => 'Joe::Hacker', DISTNAME => 'Joe-Hacker', AUTHOR => 'Joe Hacker (joe@hacker.org)', EXE_FILES => [], VERSION_FROM => 'Hacker.pm', })); ####################################################################### # The following section is adapated verbatim from Test::More v0.32. # # According to the Artistic License, the copyright information of # Test::More is acknowledged here: # # Test::More - yet another framework for writing test scripts # # AUTHOR # # Michael G Schwern with much inspiration from # Joshua Pritikin's Test module and lots of discussion with Barrie # Slaymaker and the perl-qa gang. # # The source code of Test::More may be acquired at http://www.cpan.org/, # or from a standard perl distribution of v5.7.2+. # ####################################################################### sub _deep_check { my($e1, $e2) = @_; my $ok = 0; my $eq; { # Quiet unintialized value warnings when comparing undefs. local $^W = 0; if( $e1 eq $e2 ) { $ok = 1; } else { if( UNIVERSAL::isa($e1, 'ARRAY') and UNIVERSAL::isa($e2, 'ARRAY') ) { $ok = eq_array($e1, $e2); } elsif( UNIVERSAL::isa($e1, 'HASH') and UNIVERSAL::isa($e2, 'HASH') ) { $ok = eq_hash($e1, $e2); } elsif( UNIVERSAL::isa($e1, 'REF') and UNIVERSAL::isa($e2, 'REF') ) { push @Data_Stack, { type => 'REF', vals => [$e1, $e2] }; $ok = _deep_check($$e1, $$e2); pop @Data_Stack if $ok; } elsif( UNIVERSAL::isa($e1, 'SCALAR') and UNIVERSAL::isa($e2, 'SCALAR') ) { push @Data_Stack, { type => 'REF', vals => [$e1, $e2] }; $ok = _deep_check($$e1, $$e2); } else { push @Data_Stack, { vals => [$e1, $e2] }; $ok = 0; } } } return $ok; } sub eq_hash { my($a1, $a2) = @_; return 1 if $a1 eq $a2; my $ok = 1; my $bigger = keys %$a1 > keys %$a2 ? $a1 : $a2; foreach my $k (keys %$bigger) { my $e1 = exists $a1->{$k} ? $a1->{$k} : $DNE; my $e2 = exists $a2->{$k} ? $a2->{$k} : $DNE; push @Data_Stack, { type => 'HASH', idx => $k, vals => [$e1, $e2] }; $ok = _deep_check($e1, $e2); pop @Data_Stack if $ok; last unless $ok; } return $ok; } sub eq_array { my($a1, $a2) = @_; return 1 if $a1 eq $a2; my $ok = 1; my $max = $#$a1 > $#$a2 ? $#$a1 : $#$a2; for (0..$max) { my $e1 = $_ > $#$a1 ? $DNE : $a1->[$_]; my $e2 = $_ > $#$a2 ? $DNE : $a2->[$_]; push @Data_Stack, { type => 'ARRAY', idx => $_, vals => [$e1, $e2] }; $ok = _deep_check($e1,$e2); pop @Data_Stack if $ok; last unless $ok; } return $ok; } libextutils-autoinstall-perl-0.63/inc/0000750000175000017500000000000011002710167017672 5ustar bastianbastianlibextutils-autoinstall-perl-0.63/inc/ExtUtils/0000750000175000017500000000000011002710167021453 5ustar bastianbastianlibextutils-autoinstall-perl-0.63/inc/ExtUtils/AutoInstall.pm0000640000175000017500000004335510311300072024253 0ustar bastianbastian#line 1 "inc/ExtUtils/AutoInstall.pm - lib/ExtUtils/AutoInstall.pm" package ExtUtils::AutoInstall; $ExtUtils::AutoInstall::VERSION = '0.63'; use strict; use Cwd (); use ExtUtils::MakeMaker (); #line 312 # special map on pre-defined feature sets my %FeatureMap = ( '' => 'Core Features', # XXX: deprecated '-core' => 'Core Features', ); # various lexical flags my (@Missing, @Existing, %DisabledTests, $UnderCPAN, $HasCPANPLUS); my ($Config, $CheckOnly, $SkipInstall, $AcceptDefault, $TestOnly); my ($PostambleActions, $PostambleUsed); _accept_default(!-t STDIN); # see if it's a non-interactive session _init(); sub _accept_default { $AcceptDefault = shift; } sub missing_modules { return @Missing; } sub do_install { __PACKAGE__->install( [ UNIVERSAL::isa($Config, 'HASH') ? %{$Config} : @{$Config}], @Missing, ); } # initialize various flags, and/or perform install sub _init { foreach my $arg (@ARGV, split(/[\s\t]+/, $ENV{PERL_EXTUTILS_AUTOINSTALL} || '')) { if ($arg =~ /^--config=(.*)$/) { $Config = [ split(',', $1) ]; } elsif ($arg =~ /^--installdeps=(.*)$/) { __PACKAGE__->install($Config, @Missing = split(/,/, $1)); exit 0; } elsif ($arg =~ /^--default(?:deps)?$/) { $AcceptDefault = 1; } elsif ($arg =~ /^--check(?:deps)?$/) { $CheckOnly = 1; } elsif ($arg =~ /^--skip(?:deps)?$/) { $SkipInstall = 1; } elsif ($arg =~ /^--test(?:only)?$/) { $TestOnly = 1; } } } # overrides MakeMaker's prompt() to automatically accept the default choice sub _prompt { goto &ExtUtils::MakeMaker::prompt unless $AcceptDefault; my ($prompt, $default) = @_; my $y = ($default =~ /^[Yy]/); print $prompt, ' [', ($y ? 'Y' : 'y'), '/', ($y ? 'n' : 'N'), '] '; print "$default\n"; return $default; } # the workhorse sub import { my $class = shift; my @args = @_ or return; my $core_all; print "*** $class version ".$class->VERSION."\n"; print "*** Checking for dependencies...\n"; my $cwd = Cwd::cwd(); $Config = []; my $maxlen = length((sort { length($b) <=> length($a) } grep { /^[^\-]/ } map { ref($_) ? keys %{ref($_) eq 'HASH' ? $_ : +{@{$_}}} : '' } map { +{@args}->{$_} } grep { /^[^\-]/ or /^-core$/i } keys %{+{@args}})[0]); while (my ($feature, $modules) = splice(@args, 0, 2)) { my (@required, @tests, @skiptests); my $default = 1; my $conflict = 0; if ($feature =~ m/^-(\w+)$/) { my $option = lc($1); # check for a newer version of myself _update_to($modules, @_) and return if $option eq 'version'; # sets CPAN configuration options $Config = $modules if $option eq 'config'; # promote every features to core status $core_all = ($modules =~ /^all$/i) and next if $option eq 'core'; next unless $option eq 'core'; } print "[".($FeatureMap{lc($feature)} || $feature)."]\n"; $modules = [ %{$modules} ] if UNIVERSAL::isa($modules, 'HASH'); unshift @$modules, -default => &{shift(@$modules)} if (ref($modules->[0]) eq 'CODE'); # XXX: bugward combatability while (my ($mod, $arg) = splice(@$modules, 0, 2)) { if ($mod =~ m/^-(\w+)$/) { my $option = lc($1); $default = $arg if ($option eq 'default'); $conflict = $arg if ($option eq 'conflict'); @tests = @{$arg} if ($option eq 'tests'); @skiptests = @{$arg} if ($option eq 'skiptests'); next; } printf("- %-${maxlen}s ...", $mod); # XXX: check for conflicts and uninstalls(!) them. if (defined(my $cur = _version_check(_load($mod), $arg ||= 0))) { print "loaded. ($cur".($arg ? " >= $arg" : '').")\n"; push @Existing, $mod => $arg; $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; } else { print "missing." . ($arg ? " (would need $arg)" : '') . "\n"; push @required, $mod => $arg; } } next unless @required; my $mandatory = ($feature eq '-core' or $core_all); if (!$SkipInstall and ($CheckOnly or _prompt( qq{==> Auto-install the }. (@required / 2). ($mandatory ? ' mandatory' : ' optional'). qq{ module(s) from CPAN?}, $default ? 'y' : 'n', ) =~ /^[Yy]/)) { push (@Missing, @required); $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; } elsif (!$SkipInstall and $default and $mandatory and _prompt( qq{==> The module(s) are mandatory! Really skip?}, 'n', ) =~ /^[Nn]/) { push (@Missing, @required); $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; } else { $DisabledTests{$_} = 1 for map { glob($_) } @tests; } } _check_lock(); # check for $UnderCPAN if (@Missing and not ($CheckOnly or $UnderCPAN)) { require Config; print "*** Dependencies will be installed the next time you type '$Config::Config{make}'.\n"; # make an educated guess of whether we'll need root permission. print " (You may need to do that as the 'root' user.)\n" if eval '$>'; } print "*** $class configuration finished.\n"; chdir $cwd; # import to main:: no strict 'refs'; *{'main::WriteMakefile'} = \&Write if caller(0) eq 'main'; } # CPAN.pm is non-reentrant, so check if we're under it and have no CPANPLUS sub _check_lock { return unless @Missing; return if _has_cpanplus(); require CPAN; CPAN::Config->load; my $lock = MM->catfile($CPAN::Config->{cpan_home}, ".lock"); if (-f $lock and open(LOCK, $lock) and ($^O eq 'MSWin32' ? _under_cpan() : == getppid()) and ($CPAN::Config->{prerequisites_policy} || '') ne 'ignore' ) { print << '.'; *** Since we're running under CPAN, I'll just let it take care of the dependency's installation later. . $UnderCPAN = 1; } close LOCK; } sub install { my $class = shift; my $i; # used below to strip leading '-' from config keys my @config = (map { s/^-// if ++$i; $_ } @{+shift}); my (@modules, @installed); while (my ($pkg, $ver) = splice(@_, 0, 2)) { # grep out those already installed if (defined(_version_check(_load($pkg), $ver))) { push @installed, $pkg; } else { push @modules, $pkg, $ver; } } return @installed unless @modules; # nothing to do print "*** Installing dependencies...\n"; return unless _connected_to('cpan.org'); my %args = @config; my %failed; local *FAILED; if ($args{do_once} and open(FAILED, '.#autoinstall.failed')) { while () { chomp; $failed{$_}++ } close FAILED; my @newmod; while (my ($k, $v) = splice(@modules, 0, 2)) { push @newmod, ($k => $v) unless $failed{$k}; } @modules = @newmod; } if (_has_cpanplus()) { _install_cpanplus(\@modules, \@config); } else { _install_cpan(\@modules, \@config); } print "*** $class installation finished.\n"; # see if we have successfully installed them while (my ($pkg, $ver) = splice(@modules, 0, 2)) { if (defined(_version_check(_load($pkg), $ver))) { push @installed, $pkg; } elsif ($args{do_once} and open(FAILED, '>> .#autoinstall.failed')) { print FAILED "$pkg\n"; } } close FAILED if $args{do_once}; return @installed; } sub _install_cpanplus { my @modules = @{+shift}; my @config = @{+shift}; my $installed = 0; require CPANPLUS::Backend; my $cp = CPANPLUS::Backend->new; my $conf = $cp->configure_object; return unless _can_write( $conf->can('conf') ? $conf->get_conf('base') # 0.05x+ : $conf->_get_build('base') # 0.04x ); # if we're root, set UNINST=1 to avoid trouble unless user asked for it. my $makeflags = $conf->get_conf('makeflags') || ''; if (UNIVERSAL::isa($makeflags, 'HASH')) { # 0.03+ uses a hashref here $makeflags->{UNINST} = 1 unless exists $makeflags->{UNINST}; } else { # 0.02 and below uses a scalar $makeflags = join(' ', split(' ', $makeflags), 'UNINST=1') if ($makeflags !~ /\bUNINST\b/ and eval qq{ $> eq '0' }); } $conf->set_conf(makeflags => $makeflags); $conf->set_conf(prereqs => 1); while (my ($key, $val) = splice(@config, 0, 2)) { eval { $conf->set_conf($key, $val) }; } my $modtree = $cp->module_tree; while (my ($pkg, $ver) = splice(@modules, 0, 2)) { print "*** Installing $pkg...\n"; MY::preinstall($pkg, $ver) or next if defined &MY::preinstall; my $success; my $obj = $modtree->{$pkg}; if ($obj and defined(_version_check($obj->{version}, $ver))) { my $pathname = $pkg; $pathname =~ s/::/\\W/; foreach my $inc (grep { m/$pathname.pm/i } keys(%INC)) { delete $INC{$inc}; } my $rv = $cp->install( modules => [ $obj->{module} ]); if ($rv and ($rv->{$obj->{module}} or $rv->{ok})) { print "*** $pkg successfully installed.\n"; $success = 1; } else { print "*** $pkg installation cancelled.\n"; $success = 0; } $installed += $success; } else { print << "."; *** Could not find a version $ver or above for $pkg; skipping. . } MY::postinstall($pkg, $ver, $success) if defined &MY::postinstall; } return $installed; } sub _install_cpan { my @modules = @{+shift}; my @config = @{+shift}; my $installed = 0; my %args; require CPAN; CPAN::Config->load; require Config; return unless _can_write(MM->catfile($CPAN::Config->{cpan_home}, 'sources')) and _can_write($Config::Config{sitelib}); # if we're root, set UNINST=1 to avoid trouble unless user asked for it. my $makeflags = $CPAN::Config->{make_install_arg} || ''; $CPAN::Config->{make_install_arg} = join(' ', split(' ', $makeflags), 'UNINST=1') if ($makeflags !~ /\bUNINST\b/ and eval qq{ $> eq '0' }); # don't show start-up info $CPAN::Config->{inhibit_startup_message} = 1; # set additional options while (my ($opt, $arg) = splice(@config, 0, 2)) { ($args{$opt} = $arg, next) if $opt =~ /^force$/; # pseudo-option $CPAN::Config->{$opt} = $arg; } local $CPAN::Config->{prerequisites_policy} = 'follow'; while (my ($pkg, $ver) = splice(@modules, 0, 2)) { MY::preinstall($pkg, $ver) or next if defined &MY::preinstall; print "*** Installing $pkg...\n"; my $obj = CPAN::Shell->expand(Module => $pkg); my $success = 0; if ($obj and defined(_version_check($obj->cpan_version, $ver))) { my $pathname = $pkg; $pathname =~ s/::/\\W/; foreach my $inc (grep { m/$pathname.pm/i } keys(%INC)) { delete $INC{$inc}; } $obj->force('install') if $args{force}; my $rv = $obj->install || eval { $CPAN::META->instance( 'CPAN::Distribution', $obj->cpan_file, )->{install} if $CPAN::META }; if ($rv eq 'YES') { print "*** $pkg successfully installed.\n"; $success = 1; } else { print "*** $pkg installation failed.\n"; $success = 0; } $installed += $success; } else { print << "."; *** Could not find a version $ver or above for $pkg; skipping. . } MY::postinstall($pkg, $ver, $success) if defined &MY::postinstall; } return $installed; } sub _has_cpanplus { return ( $HasCPANPLUS = ( $INC{'CPANPLUS/Config.pm'} or _load('CPANPLUS::Shell::Default') ) ); } # make guesses on whether we're under the CPAN installation directory sub _under_cpan { require Cwd; require File::Spec; my $cwd = File::Spec->canonpath(Cwd::cwd()); my $cpan = File::Spec->canonpath($CPAN::Config->{cpan_home}); return (index($cwd, $cpan) > -1); } sub _update_to { my $class = __PACKAGE__; my $ver = shift; return if defined(_version_check(_load($class), $ver)); # no need to upgrade if (_prompt( "==> A newer version of $class ($ver) is required. Install?", 'y' ) =~ /^[Nn]/) { die "*** Please install $class $ver manually.\n"; } print << "."; *** Trying to fetch it from CPAN... . # install ourselves _load($class) and return $class->import(@_) if $class->install([], $class, $ver); print << '.'; exit 1; *** Cannot bootstrap myself. :-( Installation terminated. . } # check if we're connected to some host, using inet_aton sub _connected_to { my $site = shift; return ( ( _load('Socket') and Socket::inet_aton($site) ) or _prompt(qq( *** Your host cannot resolve the domain name '$site', which probably means the Internet connections are unavailable. ==> Should we try to install the required module(s) anyway?), 'n' ) =~ /^[Yy]/ ); } # check if a directory is writable; may create it on demand sub _can_write { my $path = shift; mkdir ($path, 0755) unless -e $path; return 1 if -w $path; print << "."; *** You are not allowed to write to the directory '$path'; the installation may fail due to insufficient permissions. . if (eval '$>' and lc(`sudo -V`) =~ /version/ and _prompt(qq( ==> Should we try to re-execute the autoinstall process with 'sudo'?), 'y' ) =~ /^[Yy]/) { # try to bootstrap ourselves from sudo print << "."; *** Trying to re-execute the autoinstall process with 'sudo'... . my $missing = join(',', @Missing); my $config = join(',', UNIVERSAL::isa($Config, 'HASH') ? %{$Config} : @{$Config} ) if $Config; return unless system('sudo', $^X, $0, "--config=$config", "--installdeps=$missing"); print << "."; *** The 'sudo' command exited with error! Resuming... . } return _prompt(qq( ==> Should we try to install the required module(s) anyway?), 'n' ) =~ /^[Yy]/ } # load a module and return the version it reports sub _load { my $mod = pop; # class/instance doesn't matter my $file = $mod; $file =~ s|::|/|g; $file .= '.pm'; local $@; return eval { require $file; $mod->VERSION } || ($@ ? undef : 0); } # compare two versions, either use Sort::Versions or plain comparison sub _version_check { my ($cur, $min) = @_; return unless defined $cur; $cur =~ s/\s+$//; # check for version numbers that are not in decimal format if (ref($cur) or ref($min) or $cur =~ /v|\..*\./ or $min =~ /v|\..*\./) { if ($version::VERSION or defined(_load('version'))) { # use version.pm if it is installed. return ((version->new($cur) >= version->new($min)) ? $cur : undef); } elsif ($Sort::Versions::VERSION or defined(_load('Sort::Versions'))) { # use Sort::Versions as the sorting algorithm for a.b.c versions return ((Sort::Versions::versioncmp($cur, $min) != -1) ? $cur : undef); } warn "Cannot reliably compare non-decimal formatted versions.\n". "Please install version.pm or Sort::Versions.\n"; } # plain comparison local $^W = 0; # shuts off 'not numeric' bugs return ($cur >= $min ? $cur : undef); } # nothing; this usage is deprecated. sub main::PREREQ_PM { return {}; } sub _make_args { my %args = @_; $args{PREREQ_PM} = { %{$args{PREREQ_PM} || {} }, @Existing, @Missing } if $UnderCPAN or $TestOnly; if ($args{EXE_FILES}) { require ExtUtils::Manifest; my $manifest = ExtUtils::Manifest::maniread('MANIFEST'); $args{EXE_FILES} = [ grep { exists $manifest->{$_} } @{$args{EXE_FILES}} ]; } $args{test}{TESTS} ||= 't/*.t'; $args{test}{TESTS} = join(' ', grep { !exists($DisabledTests{$_}) } map { glob($_) } split(/\s+/, $args{test}{TESTS})); my $missing = join(',', @Missing); my $config = join(',', UNIVERSAL::isa($Config, 'HASH') ? %{$Config} : @{$Config} ) if $Config; $PostambleActions = ( $missing ? "\$(PERL) $0 --config=$config --installdeps=$missing" : "\@\$(NOOP)" ); return %args; } # a wrapper to ExtUtils::MakeMaker::WriteMakefile sub Write { require Carp; Carp::croak "WriteMakefile: Need even number of args" if @_ % 2; if ($CheckOnly) { print << "."; *** Makefile not written in check-only mode. . return; } my %args = _make_args(@_); no strict 'refs'; $PostambleUsed = 0; local *MY::postamble = \&postamble unless defined &MY::postamble; ExtUtils::MakeMaker::WriteMakefile(%args); print << "." unless $PostambleUsed; *** WARNING: Makefile written with customized MY::postamble() without including contents from ExtUtils::AutoInstall::postamble() -- auto installation features disabled. Please contact the author. . return 1; } sub postamble { $PostambleUsed = 1; return << "."; config :: installdeps \t\@\$(NOOP) checkdeps :: \t\$(PERL) $0 --checkdeps installdeps :: \t$PostambleActions . } 1; __END__ #line 978 libextutils-autoinstall-perl-0.63/inc/Module/0000750000175000017500000000000010311300316021110 5ustar bastianbastianlibextutils-autoinstall-perl-0.63/inc/Module/Install.pm0000640000175000017500000000732710311300072023065 0ustar bastianbastian#line 1 "inc/Module/Install.pm - /usr/local/lib/perl5/site_perl/5.8.7/Module/Install.pm" package Module::Install; $VERSION = '0.37'; die << "." unless $INC{join('/', inc => split(/::/, __PACKAGE__)).'.pm'}; Please invoke ${\__PACKAGE__} with: use inc::${\__PACKAGE__}; not: use ${\__PACKAGE__}; . use strict 'vars'; use Cwd (); use File::Find (); use File::Path (); @inc::Module::Install::ISA = 'Module::Install'; *inc::Module::Install::VERSION = *VERSION; #line 129 sub import { my $class = shift; my $self = $class->new(@_); if (not -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"}; } *{caller(0) . "::AUTOLOAD"} = $self->autoload; # Unregister loader and worker packages so subdirs can use them again delete $INC{"$self->{file}"}; delete $INC{"$self->{path}.pm"}; } #line 156 sub autoload { my $self = shift; my $caller = caller; my $cwd = Cwd::cwd(); my $sym = "$caller\::AUTOLOAD"; $sym->{$cwd} = sub { my $pwd = Cwd::cwd(); if (my $code = $sym->{$pwd}) { goto &$code unless $cwd eq $pwd; # delegate back to parent dirs } $$sym =~ /([^:]+)$/ or die "Cannot autoload $caller"; unshift @_, ($self, $1); goto &{$self->can('call')} unless uc($1) eq $1; }; } #line 181 sub new { my ($class, %args) = @_; return $args{_self} if $args{_self}; $args{dispatch} ||= 'Admin'; $args{prefix} ||= 'inc'; $args{author} ||= '.author'; $args{bundle} ||= 'inc/BUNDLES'; $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{prefix}/$args{path}.pm"; bless(\%args, $class); } #line 210 sub call { my $self = shift; my $method = shift; my $obj = $self->load($method) or return; unshift @_, $obj; goto &{$obj->can($method)}; } #line 225 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"; 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 my $obj = $admin->load($method, 1); push @{$self->{extensions}}, $obj; $obj; } #line 255 sub load_extensions { my ($self, $path, $top_obj) = @_; unshift @INC, $self->{prefix} unless grep { $_ eq $self->{prefix} } @INC; local @INC = ($path, @INC); foreach my $rv ($self->find_extensions($path)) { my ($file, $pkg) = @{$rv}; next if $self->{pathnames}{$pkg}; eval { require $file; 1 } or (warn($@), next); $self->{pathnames}{$pkg} = delete $INC{$file}; push @{$self->{extensions}}, $pkg->new( _top => $top_obj ); } } #line 279 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; return if $1 eq $self->{dispatch}; $file = "$self->{path}/$1.pm"; my $pkg = "$self->{name}::$1"; $pkg =~ s!/!::!g; push @found, [$file, $pkg]; }, $path) if -d $path; @found; } 1; __END__ #line 617 libextutils-autoinstall-perl-0.63/inc/Module/Install/0000750000175000017500000000000010311300316022516 5ustar bastianbastianlibextutils-autoinstall-perl-0.63/inc/Module/Install/Win32.pm0000640000175000017500000000363210311300073023763 0ustar bastianbastian#line 1 "inc/Module/Install/Win32.pm - /usr/local/lib/perl5/site_perl/5.8.7/Module/Install/Win32.pm" package Module::Install::Win32; use Module::Install::Base; @ISA = qw(Module::Install::Base); $VERSION = '0.02'; use strict; # 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 ( $Config::Config{make} and $Config::Config{make} =~ /^nmake\b/i and $^O eq 'MSWin32' 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 << '.'; ------------------------------------------------------------------------------- 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. ------------------------------------------------------------------------------- . } } 1; __END__ libextutils-autoinstall-perl-0.63/inc/Module/Install/Base.pm0000640000175000017500000000152410311300072023730 0ustar bastianbastian#line 1 "inc/Module/Install/Base.pm - /usr/local/lib/perl5/site_perl/5.8.7/Module/Install/Base.pm" package Module::Install::Base; #line 28 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 46 sub AUTOLOAD { my $self = shift; goto &{$self->_top->autoload}; } #line 57 sub _top { $_[0]->{_top} } #line 68 sub admin { my $self = shift; $self->_top->{admin} or Module::Install::Base::FakeAdmin->new; } sub is_admin { my $self = shift; $self->admin->VERSION; } sub DESTROY {} package Module::Install::Base::FakeAdmin; my $Fake; sub new { $Fake ||= bless(\@_, $_[0]) } sub AUTOLOAD {} sub DESTROY {} 1; __END__ #line 112 libextutils-autoinstall-perl-0.63/inc/Module/Install/Fetch.pm0000640000175000017500000000462710311300073024117 0ustar bastianbastian#line 1 "inc/Module/Install/Fetch.pm - /usr/local/lib/perl5/site_perl/5.8.7/Module/Install/Fetch.pm" package Module::Install::Fetch; use Module::Install::Base; @ISA = qw(Module::Install::Base); $VERSION = '0.01'; 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/, << "."); open $host user anonymous anonymous\@example.com cd $path binary get $file $file quit . 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; libextutils-autoinstall-perl-0.63/inc/Module/Install/AutoInstall.pm0000640000175000017500000000233410311300072025315 0ustar bastianbastian#line 1 "inc/Module/Install/AutoInstall.pm - /usr/local/lib/perl5/site_perl/5.8.7/Module/Install/AutoInstall.pm" package Module::Install::AutoInstall; use Module::Install::Base; @ISA = qw(Module::Install::Base); sub AutoInstall { $_[0] } sub run { my $self = shift; $self->auto_install_now(@_); } sub write { my $self = shift; $self->auto_install(@_); } sub auto_install { my $self = shift; return if $self->{done}++; # Flatten array of arrays into a single array my @core = map @$_, map @$_, grep ref, $self->build_requires, $self->requires; while ( @core and @_ > 1 and $_[0] =~ /^-\w+$/ ) { push @core, splice(@_, 0, 2); } # We'll need ExtUtils::AutoInstall $self->include('ExtUtils::AutoInstall'); require ExtUtils::AutoInstall; ExtUtils::AutoInstall->import( (@core ? (-core => \@core) : ()), @_, $self->features ); $self->makemaker_args( ExtUtils::AutoInstall::_make_args() ); my $class = ref($self); $self->postamble( "# --- $class section:\n" . ExtUtils::AutoInstall::postamble() ); } sub auto_install_now { my $self = shift; $self->auto_install; ExtUtils::AutoInstall::do_install(); } 1; libextutils-autoinstall-perl-0.63/inc/Module/Install/Makefile.pm0000640000175000017500000000724010311300072024574 0ustar bastianbastian#line 1 "inc/Module/Install/Makefile.pm - /usr/local/lib/perl5/site_perl/5.8.7/Module/Install/Makefile.pm" package Module::Install::Makefile; use Module::Install::Base; @ISA = qw(Module::Install::Base); $VERSION = '0.01'; use strict 'vars'; use vars '$VERSION'; use ExtUtils::MakeMaker (); sub Makefile { $_[0] } sub prompt { shift; goto &ExtUtils::MakeMaker::prompt; } sub makemaker_args { my $self = shift; my $args = ($self->{makemaker_args} ||= {}); %$args = ( %$args, @_ ) if @_; $args; } sub clean_files { my $self = shift; my $clean = $self->makemaker_args->{clean} ||= {}; %$clean = ( %$clean, FILES => join(" ", grep length, $clean->{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 ); } 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 ($] >= 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 ) { $args->{SIGN} = 1 if $self->sign; } delete $args->{SIGN} unless $self->is_admin; # 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 $dir = ($args->{DIR} ||= []); if ($self->bundles) { push @$dir, map "$_->[1]", @{$self->bundles}; delete $prereq->{$_->[0]} for @{$self->bundles}; } 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"; } my %args = map {($_ => $args->{$_})} grep {defined($args->{$_})} keys %$args; if ($self->admin->preop) { $args{dist} = $self->admin->preop; } ExtUtils::MakeMaker::WriteMakefile(%args); $self->fix_up_makefile(); } sub fix_up_makefile { my $self = 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 || ''); open MAKEFILE, '< Makefile' or die $!; my $makefile = do { local $/; }; close MAKEFILE; $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; open MAKEFILE, '> Makefile' or die $!; print MAKEFILE "$preamble$makefile$postamble"; close MAKEFILE; } 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 273 libextutils-autoinstall-perl-0.63/inc/Module/Install/WriteAll.pm0000640000175000017500000000152610311300072024603 0ustar bastianbastian#line 1 "inc/Module/Install/WriteAll.pm - /usr/local/lib/perl5/site_perl/5.8.7/Module/Install/WriteAll.pm" package Module::Install::WriteAll; use Module::Install::Base; @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}; $self->makemaker_args( PL_FILES => {} ) unless $self->makemaker_args->{'PL_FILES'}; if ($args{inline}) { $self->Inline->write; } else { $self->Makefile->write; } } } 1; libextutils-autoinstall-perl-0.63/inc/Module/Install/Include.pm0000640000175000017500000000064510311300072024444 0ustar bastianbastian#line 1 "inc/Module/Install/Include.pm - /usr/local/lib/perl5/site_perl/5.8.7/Module/Install/Include.pm" package Module::Install::Include; use Module::Install::Base; @ISA = qw(Module::Install::Base); sub include { +shift->admin->include(@_) }; sub include_deps { +shift->admin->include_deps(@_) }; sub auto_include { +shift->admin->auto_include(@_) }; sub auto_include_deps { +shift->admin->auto_include_deps(@_) }; 1; libextutils-autoinstall-perl-0.63/inc/Module/Install/Can.pm0000640000175000017500000000165710311300073023567 0ustar bastianbastian#line 1 "inc/Module/Install/Can.pm - /usr/local/lib/perl5/site_perl/5.8.7/Module/Install/Can.pm" package Module::Install::Can; use Module::Install::Base; @ISA = qw(Module::Install::Base); $VERSION = '0.01'; use strict; use Config (); use File::Spec (); use ExtUtils::MakeMaker (); # 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; } 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; } 1; libextutils-autoinstall-perl-0.63/inc/Module/Install/Metadata.pm0000640000175000017500000001153310311300072024577 0ustar bastianbastian#line 1 "inc/Module/Install/Metadata.pm - /usr/local/lib/perl5/site_perl/5.8.7/Module/Install/Metadata.pm" package Module::Install::Metadata; use Module::Install::Base; @ISA = qw(Module::Install::Base); $VERSION = '0.04'; use strict 'vars'; use vars qw($VERSION); sub Meta { shift } my @scalar_keys = qw( name module_name version abstract author license distribution_type sign perl_version ); my @tuple_keys = qw(build_requires requires recommends bundles); foreach my $key (@scalar_keys) { *$key = sub { my $self = shift; return $self->{'values'}{$key} unless @_; $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 @{$self->{'values'}{$key}}, $rv; push @rv, $rv; } return @rv; }; } sub features { my $self = shift; while (my ($name, $mods) = splice(@_, 0, 2)) { my $count = 0; push @{$self->{'values'}{'features'}}, ($name => [ map { (++$count % 2 and ref($_) and ($count += $#$_)) ? @$_ : $_ } @$mods ] ); } return @{$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 _dump { my $self = shift; my $package = ref($self->_top); my $version = $self->_top->VERSION; my %values = %{$self->{'values'}}; delete $values{sign}; if (my $perl_version = delete $values{perl_version}) { # Always canonical to three-dot version $perl_version =~ s{^(\d+)\.(\d\d\d)(\d*)}{join('.', $1, int($2), int($3))}e if $perl_version >= 5.006; $values{requires} = [ [perl => $perl_version], @{$values{requires}||[]}, ]; } warn "No license specified, setting license = 'unknown'\n" unless $values{license}; $values{license} ||= 'unknown'; $values{distribution_type} ||= 'module'; $values{name} ||= do { my $name = $values{module_name}; $name =~ s/::/-/g; $name; } if $values{module_name}; if ($values{name} =~ /::/) { my $name = $values{name}; $name =~ s/::/-/g; die "Error in name(): '$values{name}' should be '$name'!\n"; } my $dump = ''; foreach my $key (@scalar_keys) { $dump .= "$key: $values{$key}\n" if exists $values{$key}; } foreach my $key (@tuple_keys) { next unless exists $values{$key}; $dump .= "$key:\n"; foreach (@{$values{$key}}) { $dump .= " $_->[0]: $_->[1]\n"; } } if (my $no_index = $values{no_index}) { push @{$no_index->{'directory'}}, 'inc'; require YAML; local $YAML::UseHeader = 0; $dump .= YAML::Dump({ no_index => $no_index}); } else { $dump .= << "META"; no_index: directory: - inc META } $dump .= "generated_by: $package version $version\n"; return $dump; } 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->$key( $module => $version ); } } else { $self->$key( $value ); } } return $self; } sub write { my $self = shift; return $self unless $self->is_admin; META_NOT_OURS: { local *FH; if (open FH, "META.yml") { while () { last META_NOT_OURS if /^generated_by: Module::Install\b/; } return $self if -s FH; } } warn "Writing META.yml\n"; open META, "> META.yml" or warn "Cannot write to META.yml: $!"; print META $self->_dump; close META; return $self; } sub version_from { my ($self, $version_from) = @_; require ExtUtils::MM_Unix; $self->version(ExtUtils::MM_Unix->parse_version($version_from)); } sub abstract_from { my ($self, $abstract_from) = @_; require ExtUtils::MM_Unix; $self->abstract( bless( { DISTNAME => $self->name }, 'ExtUtils::MM_Unix') ->parse_abstract($abstract_from) ); } 1; libextutils-autoinstall-perl-0.63/lib/0000750000175000017500000000000011002710167017667 5ustar bastianbastianlibextutils-autoinstall-perl-0.63/lib/ExtUtils/0000750000175000017500000000000010311300316021441 5ustar bastianbastianlibextutils-autoinstall-perl-0.63/lib/ExtUtils/AutoInstall.pm0000640000175000017500000007517410311277631024272 0ustar bastianbastianpackage ExtUtils::AutoInstall; $ExtUtils::AutoInstall::VERSION = '0.63'; use strict; use Cwd (); use ExtUtils::MakeMaker (); =head1 NAME ExtUtils::AutoInstall - Automatic install of dependencies via CPAN =head1 VERSION This document describes version 0.63 of B, released September 12, 2005. =head1 SYNOPSIS In F, with L available on the author's system: use inc::Module::Install; name ('Joe-Hacker'); abstract ('Perl Interface to Joe Hacker'); author ('Joe Hacker '); include ('ExtUtils::AutoInstall'); requires ('Module0'); # mandatory modules features ( -config => { make_args => '--hello', # option(s) for CPAN::Config force => 1, # pseudo-option to force install do_once => 1, # skip previously failed modules }, 'Feature1' => [ 'Module2' => '0.1', ], 'Feature2' => [ 'Module3' => '1.0', ], ); auto_install(); &WriteAll; Invoking the resulting F: % perl Makefile.PL # interactive behaviour % perl Makefile.PL --defaultdeps # accept default value on prompts % perl Makefile.PL --checkdeps # check only, no Makefile produced % perl Makefile.PL --skipdeps # ignores all dependencies % perl Makefile.PL --testonly # don't write installation targets Note that the trailing 'deps' of arguments may be omitted, too. Using C<--defaultdeps> will make F behave similarly to a regular Makefile.PL file with C dependencies. One can use environment variables (see "ENVIRONMENT") below to set a default behavior instead of specifying it in the command line for every invocation of F. Using F (or F): % make [all|test|install] # install dependencies first % make checkdeps # same as the --checkdeps above % make installdeps # install dependencies only =head1 DESCRIPTION B lets module writers to specify a more sophisticated form of dependency information than the C option offered by B. This module works best with the B framework, a drop-in replacement for MakeMaker. However, this module also supports F files based on MakeMaker; see L for instructions. =head2 Prerequisites and Features Prerequisites are grouped into B, and the user could choose yes/no on each one's dependencies; the module writer may also supply a boolean value via C<-default> to specify the default choice. The B marked by the name C<-core> will double-check with the user, if the user chooses not to install the mandatory modules. This differs from the pre-0.26 'silent install' behaviour. Starting from version 0.27, if C<-core> is set to the string C (case-insensitive), every feature will be considered mandatory. The dependencies are expressed as pairs of C => C inside an array reference. If the order does not matter, and there are no C<-default>, C<-tests> or C<-skiptests> directives for that feature, you may also use a hash reference. =head2 The Installation Process Once B has determined which module(s) are needed, it checks whether it's running under the B shell and should therefore let B handle the dependency. Finally, the C is overridden to perform some additional checks, as well as skips tests associated with disabled features by the C<-tests> option. The actual installation happens at the end of the C target; both C and C will trigger the installation of required modules. If it's not running under B, the installer will probe for an active connection by trying to resolve the domain C, and check for the user's permission to use B. If all went well, a separate B instance is created to install the required modules. If you have the B package installed in your system, it is preferred by default over B; it also accepts some extra options (e.g. C<-target =E 'skiptest', -skiptest =E 1> to skip testing). All modules scheduled to be installed will be deleted from C<%INC> first, so B will check the newly installed modules. Additionally, you could use the C target to install the modules, and the C target to check dependencies without actually installing them; the C command has an equivalent effect. If the F itself needs to use an independent module (e.g. B, v1.21 or greater), then use something like below: BEGIN { require ExtUtils::AutoInstall; # the first argument is an arrayref of the -config flags ExtUtils::AutoInstall->install([], 'Acme::KillerApp' => 1.21); } use Acme::KillerApp 1.21; ExtUtils::AutoInstall->import( # ... arguments as usual ... ); Note the version test in the use clause; if you are so close to the cutting edge that B 1.20 is the latest version on CPAN, this will prevent your module from going awry. =head2 User-Defined Hooks User-defined I and I hooks are available via C and C subroutines, as shown below: # pre-install handler; takes $module_name and $version sub MY::preinstall { return 1; } # return false to skip install # post-install handler; takes $module_name, $version, $success sub MY::postinstall { return; } # the return value doesn't matter Note that since B performs installation at the time of C (i.e. before perl parses the remainder of F), you have to declare those two handlers I the C statement for them to take effect. If the user did not choose to install a module or it already exists on the system, neither of the handlers is invoked. Both handlers are invoked exactly once for each module when installation is attempted. C takes two arguments, C<$module_name> and C<$version>; if it returns a false value, installation for that module will be skipped, and C won't be called at all. C takes three arguments, C<$module_name>, C<$version> and C<$success>. The last one denotes whether the installation succeeded or not: C<1> means installation completed successfully, C<0> means failure during install, and C means that the installation was not attempted at all, possibly due to connection problems, or that module does not exist on CPAN at all. =head2 Customized C Starting from version 0.43, B supports modules that require a C subroutine in their F. The user-defined C, if present, is responsible for calling C and include the output in its return value. For example, the B (database driver) modules for the Perl DBI are required to include the postamble generated by the function C, so their F may contain lines like this: sub MY::postamble { return &ExtUtils::AutoInstall::postamble . &dbd_postamble; } Note that the B module does not export the C function, so the name should always be fully qualified. =head1 CAVEATS B will add C to your B flags if your effective uid is 0 (root), unless you explicitly disable it by setting B's C configuration option (or the C option of B) to include C. This I cause dependency problems if you are using a fine-tuned directory structure for your site. Please consult L for an explanation in detail. If either B or B is available, they will be used to compare the required version with the existing module's version and the CPAN module's. Otherwise it silently falls back to use I. This may cause inconsistent behaviours in pathetic situations. =head1 NOTES Since this module is needed before writing F, it makes little use as a CPAN module; hence each distribution must include it in full. The only alternative I'm aware of, namely prompting in F to force user install it (cf. the B