# -*- Mode: cperl; coding: utf-8; cperl-indent-level: 4 -*-
-package CPAN;
-$VERSION = '1.80_57';
-$VERSION = eval $VERSION;
+# vim: ts=4 sts=4 sw=4:
use strict;
+package CPAN;
+$CPAN::VERSION = '1.9402';
+$CPAN::VERSION =~ s/_//;
+# we need to run chdir all over and we would get at wrong libraries
+# there
+use File::Spec ();
+BEGIN {
+ if (File::Spec->can("rel2abs")) {
+ for my $inc (@INC) {
+ $inc = File::Spec->rel2abs($inc) unless ref $inc;
+ }
+ }
+}
+use CPAN::Author;
use CPAN::HandleConfig;
use CPAN::Version;
+use CPAN::Bundle;
+use CPAN::CacheMgr;
+use CPAN::Complete;
use CPAN::Debug;
+use CPAN::Distribution;
+use CPAN::Distrostatus;
+use CPAN::FTP;
+use CPAN::Index 1.93; # https://rt.cpan.org/Ticket/Display.html?id=43349
+use CPAN::InfoObj;
+use CPAN::Module;
+use CPAN::Prompt;
+use CPAN::URL;
+use CPAN::Queue;
use CPAN::Tarzip;
+use CPAN::DeferredCode;
+use CPAN::Shell;
+use CPAN::LWP::UserAgent;
+use CPAN::Exception::RecursiveDependency;
+use CPAN::Exception::yaml_not_installed;
+
use Carp ();
use Config ();
-use Cwd ();
+use Cwd qw(chdir);
use DirHandle ();
use Exporter ();
-use ExtUtils::MakeMaker (); # $SelfLoader::DEBUG=1;
+use ExtUtils::MakeMaker qw(prompt); # for some unknown reason,
+ # 5.005_04 does not work without
+ # this
use File::Basename ();
use File::Copy ();
use File::Find;
use File::Path ();
-use File::Spec ();
-use File::Temp ();
use FileHandle ();
+use Fcntl qw(:flock);
use Safe ();
use Sys::Hostname qw(hostname);
use Text::ParseWords ();
use Text::Wrap ();
-no lib "."; # we need to run chdir all over and we would get at wrong
- # libraries there
+
+# protect against "called too early"
+sub find_perl ();
+sub anycwd ();
+sub _uniq;
+
+no lib ".";
require Mac::BuildTools if $^O eq 'MacOS';
+if ($ENV{PERL5_CPAN_IS_RUNNING} && $$ != $ENV{PERL5_CPAN_IS_RUNNING}) {
+ $ENV{PERL5_CPAN_IS_RUNNING_IN_RECURSION} ||= $ENV{PERL5_CPAN_IS_RUNNING};
+ my @rec = _uniq split(/,/, $ENV{PERL5_CPAN_IS_RUNNING_IN_RECURSION}), $$;
+ $ENV{PERL5_CPAN_IS_RUNNING_IN_RECURSION} = join ",", @rec;
+ # warn "# Note: Recursive call of CPAN.pm detected\n";
+ my $w = sprintf "# Note: CPAN.pm is running in process %d now", pop @rec;
+ my %sleep = (
+ 5 => 30,
+ 6 => 60,
+ 7 => 120,
+ );
+ my $sleep = @rec > 7 ? 300 : ($sleep{scalar @rec}||0);
+ my $verbose = @rec >= 4;
+ while (@rec) {
+ $w .= sprintf " which has been called by process %d", pop @rec;
+ }
+ if ($sleep) {
+ $w .= ".\n\n# Sleeping $sleep seconds to protect other processes\n";
+ }
+ if ($verbose) {
+ warn $w;
+ }
+ local $| = 1;
+ while ($sleep > 0) {
+ printf "\r#%5d", --$sleep;
+ sleep 1;
+ }
+ print "\n";
+}
+$ENV{PERL5_CPAN_IS_RUNNING}=$$;
+$ENV{PERL5_CPANPLUS_IS_RUNNING}=$$; # https://rt.cpan.org/Ticket/Display.html?id=23735
END { $CPAN::End++; &cleanup; }
$CPAN::Signal ||= 0;
$CPAN::Frontend ||= "CPAN::Shell";
-$CPAN::Defaultsite ||= "ftp://ftp.perl.org/pub/CPAN";
-# $CPAN::iCwd (i for initial) is going to be initialized during find_perl
+unless (@CPAN::Defaultsites) {
+ @CPAN::Defaultsites = map {
+ CPAN::URL->new(TEXT => $_, FROM => "DEF")
+ }
+ "http://www.perl.org/CPAN/",
+ "ftp://ftp.perl.org/pub/CPAN/";
+}
+# $CPAN::iCwd (i for initial)
+$CPAN::iCwd ||= CPAN::anycwd();
$CPAN::Perl ||= CPAN::find_perl();
$CPAN::Defaultdocs ||= "http://search.cpan.org/perldoc?";
-$CPAN::Defaultrecent ||= "http://search.cpan.org/recent";
-
-
-package CPAN;
-use strict;
-
-use vars qw($VERSION @EXPORT $AUTOLOAD $DEBUG $META $HAS_USABLE $term
- $Signal $Suppress_readline $Frontend
- $Defaultsite $Have_warned $Defaultdocs $Defaultrecent
- $Be_Silent );
+$CPAN::Defaultrecent ||= "http://search.cpan.org/uploads.rdf";
+$CPAN::Defaultrecent ||= "http://cpan.uwinnipeg.ca/htdocs/cpan.xml";
+
+# our globals are getting a mess
+use vars qw(
+ $AUTOLOAD
+ $Be_Silent
+ $CONFIG_DIRTY
+ $Defaultdocs
+ $Echo_readline
+ $Frontend
+ $GOTOSHELL
+ $HAS_USABLE
+ $Have_warned
+ $MAX_RECURSION
+ $META
+ $RUN_DEGRADED
+ $Signal
+ $SQLite
+ $Suppress_readline
+ $VERSION
+ $autoload_recursion
+ $term
+ @Defaultsites
+ @EXPORT
+ );
+
+$MAX_RECURSION = 32;
@CPAN::ISA = qw(CPAN::Debug Exporter);
+# note that these functions live in CPAN::Shell and get executed via
+# AUTOLOAD when called directly
@EXPORT = qw(
- autobundle bundle expand force notest get cvs_import
- install make readme recompile shell test clean
- perldoc recent
- );
+ autobundle
+ bundle
+ clean
+ cvs_import
+ expand
+ force
+ fforce
+ get
+ install
+ install_tested
+ is_tested
+ make
+ mkmyconfig
+ notest
+ perldoc
+ readme
+ recent
+ recompile
+ report
+ shell
+ smoke
+ test
+ upgrade
+ );
sub soft_chdir_with_alternatives ($);
-#-> sub CPAN::AUTOLOAD ;
-sub AUTOLOAD {
- my($l) = $AUTOLOAD;
- $l =~ s/.*:://;
- my(%EXPORT);
- @EXPORT{@EXPORT} = '';
- CPAN::HandleConfig->load unless $CPAN::Config_loaded++;
- if (exists $EXPORT{$l}){
- CPAN::Shell->$l(@_);
- } else {
- $CPAN::Frontend->mywarn(qq{Unknown CPAN command "$AUTOLOAD". }.
- qq{Type ? for help.
-});
+{
+ $autoload_recursion ||= 0;
+
+ #-> sub CPAN::AUTOLOAD ;
+ sub AUTOLOAD { ## no critic
+ $autoload_recursion++;
+ my($l) = $AUTOLOAD;
+ $l =~ s/.*:://;
+ if ($CPAN::Signal) {
+ warn "Refusing to autoload '$l' while signal pending";
+ $autoload_recursion--;
+ return;
+ }
+ if ($autoload_recursion > 1) {
+ my $fullcommand = join " ", map { "'$_'" } $l, @_;
+ warn "Refusing to autoload $fullcommand in recursion\n";
+ $autoload_recursion--;
+ return;
+ }
+ my(%export);
+ @export{@EXPORT} = '';
+ CPAN::HandleConfig->load unless $CPAN::Config_loaded++;
+ if (exists $export{$l}) {
+ CPAN::Shell->$l(@_);
+ } else {
+ die(qq{Unknown CPAN command "$AUTOLOAD". }.
+ qq{Type ? for help.\n});
+ }
+ $autoload_recursion--;
+ }
+}
+
+{
+ my $x = *SAVEOUT; # avoid warning
+ open($x,">&STDOUT") or die "dup failed";
+ my $redir = 0;
+ sub _redirect(@) {
+ #die if $redir;
+ local $_;
+ push(@_,undef);
+ while(defined($_=shift)) {
+ if (s/^\s*>//){
+ my ($m) = s/^>// ? ">" : "";
+ s/\s+//;
+ $_=shift unless length;
+ die "no dest" unless defined;
+ open(STDOUT,">$m$_") or die "open:$_:$!\n";
+ $redir=1;
+ } elsif ( s/^\s*\|\s*// ) {
+ my $pipe="| $_";
+ while(defined($_[0])){
+ $pipe .= ' ' . shift;
+ }
+ open(STDOUT,$pipe) or die "open:$pipe:$!\n";
+ $redir=1;
+ } else {
+ push(@_,$_);
+ }
+ }
+ return @_;
}
+ sub _unredirect {
+ return unless $redir;
+ $redir = 0;
+ ## redirect: unredirect and propagate errors. explicit close to wait for pipe.
+ close(STDOUT);
+ open(STDOUT,">&SAVEOUT");
+ die "$@" if "$@";
+ ## redirect: done
+ }
+}
+
+sub _uniq {
+ my(@list) = @_;
+ my %seen;
+ return grep { !$seen{$_}++ } @list;
}
#-> sub CPAN::shell ;
$Suppress_readline = ! -t STDIN unless defined $Suppress_readline;
CPAN::HandleConfig->load unless $CPAN::Config_loaded++;
- my $oprompt = shift || "cpan> ";
+ my $oprompt = shift || CPAN::Prompt->new;
my $prompt = $oprompt;
my $commandline = shift || "";
+ $CPAN::CurrentCommandId ||= 1;
local($^W) = 1;
unless ($Suppress_readline) {
- require Term::ReadLine;
+ require Term::ReadLine;
if (! $term
or
$term->ReadLine eq "Term::ReadLine::Stub"
) {
$term = Term::ReadLine->new('CPAN Monitor');
}
- if ($term->ReadLine eq "Term::ReadLine::Gnu") {
- my $attribs = $term->Attribs;
- $attribs->{attempted_completion_function} = sub {
- &CPAN::Complete::gnu_cpl;
- }
- } else {
- $readline::rl_completion_function =
- $readline::rl_completion_function = 'CPAN::Complete::cpl';
- }
+ if ($term->ReadLine eq "Term::ReadLine::Gnu") {
+ my $attribs = $term->Attribs;
+ $attribs->{attempted_completion_function} = sub {
+ &CPAN::Complete::gnu_cpl;
+ }
+ } else {
+ $readline::rl_completion_function =
+ $readline::rl_completion_function = 'CPAN::Complete::cpl';
+ }
if (my $histfile = $CPAN::Config->{'histfile'}) {{
unless ($term->can("AddHistory")) {
$CPAN::Frontend->mywarn("Terminal does not support AddHistory.\n");
last;
}
- my($fh) = FileHandle->new;
- open $fh, "<$histfile" or last;
- local $/ = "\n";
- while (<$fh>) {
- chomp;
- $term->AddHistory($_);
- }
- close $fh;
+ $META->readhist($term,$histfile);
}}
- # $term->OUT is autoflushed anyway
- my $odef = select STDERR;
- $| = 1;
- select STDOUT;
- $| = 1;
- select $odef;
+ for ($CPAN::Config->{term_ornaments}) { # alias
+ local $Term::ReadLine::termcap_nowarn = 1;
+ $term->ornaments($_) if defined;
+ }
+ # $term->OUT is autoflushed anyway
+ my $odef = select STDERR;
+ $| = 1;
+ select STDOUT;
+ $| = 1;
+ select $odef;
}
- # no strict; # I do not recall why no strict was here (2000-09-03)
$META->checklock();
- my @cwd = (CPAN::anycwd(),File::Spec->tmpdir(),File::Spec->rootdir());
+ my @cwd = grep { defined $_ and length $_ }
+ CPAN::anycwd(),
+ File::Spec->can("tmpdir") ? File::Spec->tmpdir() : (),
+ File::Spec->rootdir();
my $try_detect_readline;
$try_detect_readline = $term->ReadLine eq "Term::ReadLine::Stub" if $term;
- my $rl_avail = $Suppress_readline ? "suppressed" :
- ($term->ReadLine ne "Term::ReadLine::Stub") ? "enabled" :
- "available (try 'install Bundle::CPAN')";
-
- $CPAN::Frontend->myprint(
- sprintf qq{
+ unless ($CPAN::Config->{inhibit_startup_message}) {
+ my $rl_avail = $Suppress_readline ? "suppressed" :
+ ($term->ReadLine ne "Term::ReadLine::Stub") ? "enabled" :
+ "available (maybe install Bundle::CPAN or Bundle::CPANxxl?)";
+ $CPAN::Frontend->myprint(
+ sprintf qq{
cpan shell -- CPAN exploration and modules installation (v%s)
-ReadLine support %s
+Enter 'h' for help.
},
- $CPAN::VERSION,
- $rl_avail
- )
- unless $CPAN::Config->{'inhibit_startup_message'} ;
+ $CPAN::VERSION,
+ $rl_avail
+ )
+ }
my($continuation) = "";
+ my $last_term_ornaments;
SHELLCOMMAND: while () {
- if ($Suppress_readline) {
- print $prompt;
- last SHELLCOMMAND unless defined ($_ = <> );
- chomp;
- } else {
- last SHELLCOMMAND unless
+ if ($Suppress_readline) {
+ if ($Echo_readline) {
+ $|=1;
+ }
+ print $prompt;
+ last SHELLCOMMAND unless defined ($_ = <> );
+ if ($Echo_readline) {
+ # backdoor: I could not find a way to record sessions
+ print $_;
+ }
+ chomp;
+ } else {
+ last SHELLCOMMAND unless
defined ($_ = $term->readline($prompt, $commandline));
- }
- $_ = "$continuation$_" if $continuation;
- s/^\s+//;
- next SHELLCOMMAND if /^$/;
- $_ = 'h' if /^\s*\?/;
- if (/^(?:q(?:uit)?|bye|exit)$/i) {
- last SHELLCOMMAND;
- } elsif (s/\\$//s) {
- chomp;
- $continuation = $_;
- $prompt = " > ";
- } elsif (/^\!/) {
- s/^\!//;
- my($eval) = $_;
- package CPAN::Eval;
+ }
+ $_ = "$continuation$_" if $continuation;
+ s/^\s+//;
+ next SHELLCOMMAND if /^$/;
+ s/^\s*\?\s*/help /;
+ if (/^(?:q(?:uit)?|bye|exit)$/i) {
+ last SHELLCOMMAND;
+ } elsif (s/\\$//s) {
+ chomp;
+ $continuation = $_;
+ $prompt = " > ";
+ } elsif (/^\!/) {
+ s/^\!//;
+ my($eval) = $_;
+ package
+ CPAN::Eval; # hide from the indexer
use strict;
- use vars qw($import_done);
- CPAN->import(':DEFAULT') unless $import_done++;
- CPAN->debug("eval[$eval]") if $CPAN::DEBUG;
- eval($eval);
- warn $@ if $@;
- $continuation = "";
- $prompt = $oprompt;
- } elsif (/./) {
- my(@line);
- if ($] < 5.00322) { # parsewords had a bug until recently
- @line = split;
- } else {
- eval { @line = Text::ParseWords::shellwords($_) };
- warn($@), next SHELLCOMMAND if $@;
- warn("Text::Parsewords could not parse the line [$_]"),
- next SHELLCOMMAND unless @line;
- }
- $CPAN::META->debug("line[".join("|",@line)."]") if $CPAN::DEBUG;
- my $command = shift @line;
- eval { CPAN::Shell->$command(@line) };
- warn $@ if $@;
+ use vars qw($import_done);
+ CPAN->import(':DEFAULT') unless $import_done++;
+ CPAN->debug("eval[$eval]") if $CPAN::DEBUG;
+ eval($eval);
+ warn $@ if $@;
+ $continuation = "";
+ $prompt = $oprompt;
+ } elsif (/./) {
+ my(@line);
+ eval { @line = Text::ParseWords::shellwords($_) };
+ warn($@), next SHELLCOMMAND if $@;
+ warn("Text::Parsewords could not parse the line [$_]"),
+ next SHELLCOMMAND unless @line;
+ $CPAN::META->debug("line[".join("|",@line)."]") if $CPAN::DEBUG;
+ my $command = shift @line;
+ eval {
+ local (*STDOUT)=*STDOUT;
+ @line = _redirect(@line);
+ CPAN::Shell->$command(@line)
+ };
+ my $command_error = $@;
+ _unredirect;
+ my $reported_error;
+ if ($command_error) {
+ my $err = $command_error;
+ if (ref $err and $err->isa('CPAN::Exception::blocked_urllist')) {
+ $CPAN::Frontend->mywarn("Client not fully configured, please proceed with configuring.$err");
+ $reported_error = ref $err;
+ } else {
+ # I'd prefer never to arrive here and make all errors exception objects
+ if ($err =~ /\S/) {
+ require Carp;
+ require Dumpvalue;
+ my $dv = Dumpvalue->new(tick => '"');
+ Carp::cluck(sprintf "Catching error: %s", $dv->stringify($err));
+ }
+ }
+ }
+ if ($command =~ /^(
+ # classic commands
+ make
+ |test
+ |install
+ |clean
+
+ # pragmas for classic commands
+ |ff?orce
+ |notest
+
+ # compounds
+ |report
+ |smoke
+ |upgrade
+ )$/x) {
+ # only commands that tell us something about failed distros
+ # eval necessary for people without an urllist
+ eval {CPAN::Shell->failed($CPAN::CurrentCommandId,1);};
+ if (my $err = $@) {
+ unless (ref $err and $reported_error eq ref $err) {
+ die $@;
+ }
+ }
+ }
soft_chdir_with_alternatives(\@cwd);
- $CPAN::Frontend->myprint("\n");
- $continuation = "";
- $prompt = $oprompt;
- }
+ $CPAN::Frontend->myprint("\n");
+ $continuation = "";
+ $CPAN::CurrentCommandId++;
+ $prompt = $oprompt;
+ }
} continue {
- $commandline = ""; # I do want to be able to pass a default to
- # shell, but on the second command I see no
- # use in that
- $Signal=0;
- CPAN::Queue->nullify_queue;
- if ($try_detect_readline) {
- if ($CPAN::META->has_inst("Term::ReadLine::Gnu")
- ||
- $CPAN::META->has_inst("Term::ReadLine::Perl")
- ) {
- delete $INC{"Term/ReadLine.pm"};
- my $redef = 0;
- local($SIG{__WARN__}) = CPAN::Shell::paintdots_onreload(\$redef);
- require Term::ReadLine;
- $CPAN::Frontend->myprint("\n$redef subroutines in ".
- "Term::ReadLine redefined\n");
+ $commandline = ""; # I do want to be able to pass a default to
+ # shell, but on the second command I see no
+ # use in that
+ $Signal=0;
+ CPAN::Queue->nullify_queue;
+ if ($try_detect_readline) {
+ if ($CPAN::META->has_inst("Term::ReadLine::Gnu")
+ ||
+ $CPAN::META->has_inst("Term::ReadLine::Perl")
+ ) {
+ delete $INC{"Term/ReadLine.pm"};
+ my $redef = 0;
+ local($SIG{__WARN__}) = CPAN::Shell::paintdots_onreload(\$redef);
+ require Term::ReadLine;
+ $CPAN::Frontend->myprint("\n$redef subroutines in ".
+ "Term::ReadLine redefined\n");
+ $GOTOSHELL = 1;
+ }
+ }
+ if ($term and $term->can("ornaments")) {
+ for ($CPAN::Config->{term_ornaments}) { # alias
+ if (defined $_) {
+ if (not defined $last_term_ornaments
+ or $_ != $last_term_ornaments
+ ) {
+ local $Term::ReadLine::termcap_nowarn = 1;
+ $term->ornaments($_);
+ $last_term_ornaments = $_;
+ }
+ } else {
+ undef $last_term_ornaments;
+ }
+ }
+ }
+ for my $class (qw(Module Distribution)) {
+ # again unsafe meta access?
+ for my $dm (keys %{$CPAN::META->{readwrite}{"CPAN::$class"}}) {
+ next unless $CPAN::META->{readwrite}{"CPAN::$class"}{$dm}{incommandcolor};
+ CPAN->debug("BUG: $class '$dm' was in command state, resetting");
+ delete $CPAN::META->{readwrite}{"CPAN::$class"}{$dm}{incommandcolor};
+ }
+ }
+ if ($GOTOSHELL) {
+ $GOTOSHELL = 0; # not too often
+ $META->savehist if $CPAN::term && $CPAN::term->can("GetHistory");
@_ = ($oprompt,"");
- goto &shell;
- }
- }
+ goto &shell;
+ }
}
soft_chdir_with_alternatives(\@cwd);
}
+#-> CPAN::soft_chdir_with_alternatives ;
sub soft_chdir_with_alternatives ($) {
my($cwd) = @_;
- while (not chdir $cwd->[0]) {
- if (@$cwd>1) {
- $CPAN::Frontend->mywarn(qq{Could not chdir to "$cwd->[0]": $!
-Trying to chdir to "$cwd->[1]" instead.
+ unless (@$cwd) {
+ my $root = File::Spec->rootdir();
+ $CPAN::Frontend->mywarn(qq{Warning: no good directory to chdir to!
+Trying '$root' as temporary haven.
});
- shift @$cwd;
+ push @$cwd, $root;
+ }
+ while () {
+ if (chdir $cwd->[0]) {
+ return;
} else {
- $CPAN::Frontend->mydie(qq{Could not chdir to "$cwd->[0]": $!});
+ if (@$cwd>1) {
+ $CPAN::Frontend->mywarn(qq{Could not chdir to "$cwd->[0]": $!
+Trying to chdir to "$cwd->[1]" instead.
+});
+ shift @$cwd;
+ } else {
+ $CPAN::Frontend->mydie(qq{Could not chdir to "$cwd->[0]": $!});
+ }
}
}
}
-package CPAN::CacheMgr;
-use strict;
-@CPAN::CacheMgr::ISA = qw(CPAN::InfoObj CPAN);
-use File::Find;
-
-package CPAN::FTP;
-use strict;
-use vars qw($Ua $Thesite $Themethod);
-@CPAN::FTP::ISA = qw(CPAN::Debug);
-
-package CPAN::LWP::UserAgent;
-use strict;
-use vars qw(@ISA $USER $PASSWD $SETUPDONE);
-# we delay requiring LWP::UserAgent and setting up inheritance until we need it
-
-package CPAN::Complete;
-use strict;
-@CPAN::Complete::ISA = qw(CPAN::Debug);
-@CPAN::Complete::COMMANDS = sort qw(
- ! a b d h i m o q r u
- autobundle
- clean
- cvs_import
- dump
- force
- install
- look
- ls
- make test
- notest
- perldoc
- readme
- recent
- reload
-);
-
-package CPAN::Index;
-use strict;
-use vars qw($LAST_TIME $DATE_OF_02 $DATE_OF_03);
-@CPAN::Index::ISA = qw(CPAN::Debug);
-$LAST_TIME ||= 0;
-$DATE_OF_03 ||= 0;
-# use constant PROTOCOL => "2.0"; # outcommented to avoid warning on upgrade from 1.57
-sub PROTOCOL { 2.0 }
-
-package CPAN::InfoObj;
-use strict;
-@CPAN::InfoObj::ISA = qw(CPAN::Debug);
-
-package CPAN::Author;
-use strict;
-@CPAN::Author::ISA = qw(CPAN::InfoObj);
-
-package CPAN::Distribution;
-use strict;
-@CPAN::Distribution::ISA = qw(CPAN::InfoObj);
-
-package CPAN::Bundle;
-use strict;
-@CPAN::Bundle::ISA = qw(CPAN::Module);
-
-package CPAN::Module;
-use strict;
-@CPAN::Module::ISA = qw(CPAN::InfoObj);
-
-package CPAN::Exception::RecursiveDependency;
-use strict;
-use overload '""' => "as_string";
-
-sub new {
- my($class) = shift;
- my($deps) = shift;
- my @deps;
- my %seen;
- for my $dep (@$deps) {
- push @deps, $dep;
- last if $seen{$dep}++;
- }
- bless { deps => \@deps }, $class;
-}
-
-sub as_string {
- my($self) = shift;
- "\nRecursive dependency detected:\n " .
- join("\n => ", @{$self->{deps}}) .
- ".\nCannot continue.\n";
-}
-package CPAN::Shell;
-use strict;
-use vars qw($AUTOLOAD @ISA $COLOR_REGISTERED $ADVANCED_QUERY $PRINT_ORNAMENTING);
-@CPAN::Shell::ISA = qw(CPAN::Debug);
-$COLOR_REGISTERED ||= 0;
-$PRINT_ORNAMENTING ||= 0;
-
-#-> sub CPAN::Shell::AUTOLOAD ;
-sub AUTOLOAD {
- my($autoload) = $AUTOLOAD;
- my $class = shift(@_);
- # warn "autoload[$autoload] class[$class]";
- $autoload =~ s/.*:://;
- if ($autoload =~ /^w/) {
- if ($CPAN::META->has_inst('CPAN::WAIT')) {
- CPAN::WAIT->$autoload(@_);
- } else {
- $CPAN::Frontend->mywarn(qq{
-Commands starting with "w" require CPAN::WAIT to be installed.
-Please consider installing CPAN::WAIT to use the fulltext index.
-For this you just need to type
- install CPAN::WAIT
-});
- }
+sub _flock {
+ my($fh,$mode) = @_;
+ if ( $Config::Config{d_flock} || $Config::Config{d_fcntl_can_lock} ) {
+ return flock $fh, $mode;
+ } elsif (!$Have_warned->{"d_flock"}++) {
+ $CPAN::Frontend->mywarn("Your OS does not seem to support locking; continuing and ignoring all locking issues\n");
+ $CPAN::Frontend->mysleep(5);
+ return 1;
} else {
- $CPAN::Frontend->mywarn(qq{Unknown shell command '$autoload'. }.
- qq{Type ? for help.
-});
+ return 1;
}
}
-package CPAN::Queue;
-use strict;
-
-# One use of the queue is to determine if we should or shouldn't
-# announce the availability of a new CPAN module
-
-# Now we try to use it for dependency tracking. For that to happen
-# we need to draw a dependency tree and do the leaves first. This can
-# easily be reached by running CPAN.pm recursively, but we don't want
-# to waste memory and run into deep recursion. So what we can do is
-# this:
-
-# CPAN::Queue is the package where the queue is maintained. Dependencies
-# often have high priority and must be brought to the head of the queue,
-# possibly by jumping the queue if they are already there. My first code
-# attempt tried to be extremely correct. Whenever a module needed
-# immediate treatment, I either unshifted it to the front of the queue,
-# or, if it was already in the queue, I spliced and let it bypass the
-# others. This became a too correct model that made it impossible to put
-# an item more than once into the queue. Why would you need that? Well,
-# you need temporary duplicates as the manager of the queue is a loop
-# that
-#
-# (1) looks at the first item in the queue without shifting it off
-#
-# (2) cares for the item
-#
-# (3) removes the item from the queue, *even if its agenda failed and
-# even if the item isn't the first in the queue anymore* (that way
-# protecting against never ending queues)
-#
-# So if an item has prerequisites, the installation fails now, but we
-# want to retry later. That's easy if we have it twice in the queue.
-#
-# I also expect insane dependency situations where an item gets more
-# than two lives in the queue. Simplest example is triggered by 'install
-# Foo Foo Foo'. People make this kind of mistakes and I don't want to
-# get in the way. I wanted the queue manager to be a dumb servant, not
-# one that knows everything.
-#
-# Who would I tell in this model that the user wants to be asked before
-# processing? I can't attach that information to the module object,
-# because not modules are installed but distributions. So I'd have to
-# tell the distribution object that it should ask the user before
-# processing. Where would the question be triggered then? Most probably
-# in CPAN::Distribution::rematein.
-# Hope that makes sense, my head is a bit off:-) -- AK
-
-use vars qw{ @All };
-
-# CPAN::Queue::new ;
-sub new {
- my($class,$s) = @_;
- my $self = bless { qmod => $s }, $class;
- push @All, $self;
- return $self;
-}
-
-# CPAN::Queue::first ;
-sub first {
- my $obj = $All[0];
- $obj->{qmod};
-}
-
-# CPAN::Queue::delete_first ;
-sub delete_first {
- my($class,$what) = @_;
- my $i;
- for my $i (0..$#All) {
- if ( $All[$i]->{qmod} eq $what ) {
- splice @All, $i, 1;
- return;
+sub _yaml_module () {
+ my $yaml_module = $CPAN::Config->{yaml_module} || "YAML";
+ if (
+ $yaml_module ne "YAML"
+ &&
+ !$CPAN::META->has_inst($yaml_module)
+ ) {
+ # $CPAN::Frontend->mywarn("'$yaml_module' not installed, falling back to 'YAML'\n");
+ $yaml_module = "YAML";
}
- }
+ if ($yaml_module eq "YAML"
+ &&
+ $CPAN::META->has_inst($yaml_module)
+ &&
+ $YAML::VERSION < 0.60
+ &&
+ !$Have_warned->{"YAML"}++
+ ) {
+ $CPAN::Frontend->mywarn("Warning: YAML version '$YAML::VERSION' is too low, please upgrade!\n".
+ "I'll continue but problems are *very* likely to happen.\n"
+ );
+ $CPAN::Frontend->mysleep(5);
+ }
+ return $yaml_module;
}
-# CPAN::Queue::jumpqueue ;
-sub jumpqueue {
- my $class = shift;
- my @what = @_;
- CPAN->debug(sprintf("before jumpqueue All[%s] what[%s]",
- join(",",map {$_->{qmod}} @All),
- join(",",@what)
- )) if $CPAN::DEBUG;
- WHAT: for my $what (reverse @what) {
- my $jumped = 0;
- for (my $i=0; $i<$#All;$i++) { #prevent deep recursion
- CPAN->debug("i[$All[$i]]what[$what]") if $CPAN::DEBUG;
- if ($All[$i]->{qmod} eq $what){
- $jumped++;
- if ($jumped > 100) { # one's OK if e.g. just
- # processing now; more are OK if
- # user typed it several times
- $CPAN::Frontend->mywarn(
-qq{Object [$what] queued more than 100 times, ignoring}
- );
- next WHAT;
- }
+# CPAN::_yaml_loadfile
+sub _yaml_loadfile {
+ my($self,$local_file) = @_;
+ return +[] unless -s $local_file;
+ my $yaml_module = _yaml_module;
+ if ($CPAN::META->has_inst($yaml_module)) {
+ # temporarly enable yaml code deserialisation
+ no strict 'refs';
+ # 5.6.2 could not do the local() with the reference
+ # so we do it manually instead
+ my $old_loadcode = ${"$yaml_module\::LoadCode"};
+ ${ "$yaml_module\::LoadCode" } = $CPAN::Config->{yaml_load_code} || 0;
+
+ my ($code, @yaml);
+ if ($code = UNIVERSAL::can($yaml_module, "LoadFile")) {
+ eval { @yaml = $code->($local_file); };
+ if ($@) {
+ # this shall not be done by the frontend
+ die CPAN::Exception::yaml_process_error->new($yaml_module,$local_file,"parse",$@);
+ }
+ } elsif ($code = UNIVERSAL::can($yaml_module, "Load")) {
+ local *FH;
+ open FH, $local_file or die "Could not open '$local_file': $!";
+ local $/;
+ my $ystream = <FH>;
+ eval { @yaml = $code->($ystream); };
+ if ($@) {
+ # this shall not be done by the frontend
+ die CPAN::Exception::yaml_process_error->new($yaml_module,$local_file,"parse",$@);
}
}
- my $obj = bless { qmod => $what }, $class;
- unshift @All, $obj;
+ ${"$yaml_module\::LoadCode"} = $old_loadcode;
+ return \@yaml;
+ } else {
+ # this shall not be done by the frontend
+ die CPAN::Exception::yaml_not_installed->new($yaml_module, $local_file, "parse");
+ }
+ return +[];
+}
+
+# CPAN::_yaml_dumpfile
+sub _yaml_dumpfile {
+ my($self,$local_file,@what) = @_;
+ my $yaml_module = _yaml_module;
+ if ($CPAN::META->has_inst($yaml_module)) {
+ my $code;
+ if (UNIVERSAL::isa($local_file, "FileHandle")) {
+ $code = UNIVERSAL::can($yaml_module, "Dump");
+ eval { print $local_file $code->(@what) };
+ } elsif ($code = UNIVERSAL::can($yaml_module, "DumpFile")) {
+ eval { $code->($local_file,@what); };
+ } elsif ($code = UNIVERSAL::can($yaml_module, "Dump")) {
+ local *FH;
+ open FH, ">$local_file" or die "Could not open '$local_file': $!";
+ print FH $code->(@what);
+ }
+ if ($@) {
+ die CPAN::Exception::yaml_process_error->new($yaml_module,$local_file,"dump",$@);
+ }
+ } else {
+ if (UNIVERSAL::isa($local_file, "FileHandle")) {
+ # I think this case does not justify a warning at all
+ } else {
+ die CPAN::Exception::yaml_not_installed->new($yaml_module, $local_file, "dump");
+ }
}
- CPAN->debug(sprintf("after jumpqueue All[%s] what[%s]",
- join(",",map {$_->{qmod}} @All),
- join(",",@what)
- )) if $CPAN::DEBUG;
}
-# CPAN::Queue::exists ;
-sub exists {
- my($self,$what) = @_;
- my @all = map { $_->{qmod} } @All;
- my $exists = grep { $_->{qmod} eq $what } @All;
- # warn "in exists what[$what] all[@all] exists[$exists]";
- $exists;
-}
-
-# CPAN::Queue::delete ;
-sub delete {
- my($self,$mod) = @_;
- @All = grep { $_->{qmod} ne $mod } @All;
+sub _init_sqlite () {
+ unless ($CPAN::META->has_inst("CPAN::SQLite")) {
+ $CPAN::Frontend->mywarn(qq{CPAN::SQLite not installed, trying to work without\n})
+ unless $Have_warned->{"CPAN::SQLite"}++;
+ return;
+ }
+ require CPAN::SQLite::META; # not needed since CVS version of 2006-12-17
+ $CPAN::SQLite ||= CPAN::SQLite::META->new($CPAN::META);
}
-# CPAN::Queue::nullify_queue ;
-sub nullify_queue {
- @All = ();
+{
+ my $negative_cache = {};
+ sub _sqlite_running {
+ if ($negative_cache->{time} && time < $negative_cache->{time} + 60) {
+ # need to cache the result, otherwise too slow
+ return $negative_cache->{fact};
+ } else {
+ $negative_cache = {}; # reset
+ }
+ my $ret = $CPAN::Config->{use_sqlite} && ($CPAN::SQLite || _init_sqlite());
+ return $ret if $ret; # fast anyway
+ $negative_cache->{time} = time;
+ return $negative_cache->{fact} = $ret;
+ }
}
-
-
-package CPAN;
-use strict;
-
$META ||= CPAN->new; # In case we re-eval ourselves we need the ||
# from here on only subs.
################################################################################
+sub _perl_fingerprint {
+ my($self,$other_fingerprint) = @_;
+ my $dll = eval {OS2::DLLname()};
+ my $mtime_dll = 0;
+ if (defined $dll) {
+ $mtime_dll = (-f $dll ? (stat(_))[9] : '-1');
+ }
+ my $mtime_perl = (-f CPAN::find_perl ? (stat(_))[9] : '-1');
+ my $this_fingerprint = {
+ '$^X' => CPAN::find_perl,
+ sitearchexp => $Config::Config{sitearchexp},
+ 'mtime_$^X' => $mtime_perl,
+ 'mtime_dll' => $mtime_dll,
+ };
+ if ($other_fingerprint) {
+ if (exists $other_fingerprint->{'stat($^X)'}) { # repair fp from rev. 1.88_57
+ $other_fingerprint->{'mtime_$^X'} = $other_fingerprint->{'stat($^X)'}[9];
+ }
+ # mandatory keys since 1.88_57
+ for my $key (qw($^X sitearchexp mtime_dll mtime_$^X)) {
+ return unless $other_fingerprint->{$key} eq $this_fingerprint->{$key};
+ }
+ return 1;
+ } else {
+ return $this_fingerprint;
+ }
+}
+
+sub suggest_myconfig () {
+ SUGGEST_MYCONFIG: if(!$INC{'CPAN/MyConfig.pm'}) {
+ $CPAN::Frontend->myprint("You don't seem to have a user ".
+ "configuration (MyConfig.pm) yet.\n");
+ my $new = CPAN::Shell::colorable_makemaker_prompt("Do you want to create a ".
+ "user configuration now? (Y/n)",
+ "yes");
+ if($new =~ m{^y}i) {
+ CPAN::Shell->mkmyconfig();
+ return &checklock;
+ } else {
+ $CPAN::Frontend->mydie("OK, giving up.");
+ }
+ }
+}
+
#-> sub CPAN::all_objects ;
sub all_objects {
my($mgr,$class) = @_;
CPAN::Index->reload;
values %{ $META->{readwrite}{$class} }; # unsafe meta access, ok
}
-*all = \&all_objects;
# Called by shell, not in batch mode. In batch mode I see no risk in
# having many processes updating something as installations are
my($self) = @_;
my $lockfile = File::Spec->catfile($CPAN::Config->{cpan_home},".lock");
if (-f $lockfile && -M _ > 0) {
- my $fh = FileHandle->new($lockfile) or
- $CPAN::Frontend->mydie("Could not open $lockfile: $!");
- my $otherpid = <$fh>;
- my $otherhost = <$fh>;
- $fh->close;
- if (defined $otherpid && $otherpid) {
- chomp $otherpid;
+ my $fh = FileHandle->new($lockfile) or
+ $CPAN::Frontend->mydie("Could not open lockfile '$lockfile': $!");
+ my $otherpid = <$fh>;
+ my $otherhost = <$fh>;
+ $fh->close;
+ if (defined $otherpid && $otherpid) {
+ chomp $otherpid;
+ }
+ if (defined $otherhost && $otherhost) {
+ chomp $otherhost;
}
- if (defined $otherhost && $otherhost) {
- chomp $otherhost;
- }
- my $thishost = hostname();
- if (defined $otherhost && defined $thishost &&
- $otherhost ne '' && $thishost ne '' &&
- $otherhost ne $thishost) {
- $CPAN::Frontend->mydie(sprintf("CPAN.pm panic: Lockfile $lockfile\n".
- "reports other host $otherhost and other process $otherpid.\n".
+ my $thishost = hostname();
+ if (defined $otherhost && defined $thishost &&
+ $otherhost ne '' && $thishost ne '' &&
+ $otherhost ne $thishost) {
+ $CPAN::Frontend->mydie(sprintf("CPAN.pm panic: Lockfile '$lockfile'\n".
+ "reports other host $otherhost and other ".
+ "process $otherpid.\n".
"Cannot proceed.\n"));
- }
- elsif (defined $otherpid && $otherpid) {
- return if $$ == $otherpid; # should never happen
- $CPAN::Frontend->mywarn(
- qq{
+ } elsif ($RUN_DEGRADED) {
+ $CPAN::Frontend->mywarn("Running in downgraded mode (experimental)\n");
+ } elsif (defined $otherpid && $otherpid) {
+ return if $$ == $otherpid; # should never happen
+ $CPAN::Frontend->mywarn(
+ qq{
There seems to be running another CPAN process (pid $otherpid). Contacting...
});
- if (kill 0, $otherpid) {
- $CPAN::Frontend->mydie(qq{Other job is running.
-You may want to kill it and delete the lockfile, maybe. On UNIX try:
+ if (kill 0, $otherpid or $!{EPERM}) {
+ $CPAN::Frontend->mywarn(qq{Other job is running.\n});
+ my($ans) =
+ CPAN::Shell::colorable_makemaker_prompt
+ (qq{Shall I try to run in downgraded }.
+ qq{mode? (Y/n)},"y");
+ if ($ans =~ /^y/i) {
+ $CPAN::Frontend->mywarn("Running in downgraded mode (experimental).
+Please report if something unexpected happens\n");
+ $RUN_DEGRADED = 1;
+ for ($CPAN::Config) {
+ # XXX
+ # $_->{build_dir_reuse} = 0; # 2006-11-17 akoenig Why was that?
+ $_->{commandnumber_in_prompt} = 0; # visibility
+ $_->{histfile} = ""; # who should win otherwise?
+ $_->{cache_metadata} = 0; # better would be a lock?
+ $_->{use_sqlite} = 0; # better would be a write lock!
+ $_->{auto_commit} = 0; # we are violent, do not persist
+ $_->{test_report} = 0; # Oliver Paukstadt had sent wrong reports in degraded mode
+ }
+ } else {
+ $CPAN::Frontend->mydie("
+You may want to kill the other job and delete the lockfile. On UNIX try:
kill $otherpid
rm $lockfile
-});
- } elsif (-w $lockfile) {
- my($ans) =
- ExtUtils::MakeMaker::prompt
- (qq{Other job not responding. Shall I overwrite }.
- qq{the lockfile? (Y/N)},"y");
- $CPAN::Frontend->myexit("Ok, bye\n")
- unless $ans =~ /^y/i;
- } else {
- Carp::croak(
- qq{Lockfile $lockfile not writeable by you. }.
- qq{Cannot proceed.\n}.
- qq{ On UNIX try:\n}.
- qq{ rm $lockfile\n}.
- qq{ and then rerun us.\n}
- );
- }
- } else {
- $CPAN::Frontend->mydie(sprintf("CPAN.pm panic: Lockfile $lockfile\n".
- "reports other process with ID ".
- "$otherpid. Cannot proceed.\n"));
+");
+ }
+ } elsif (-w $lockfile) {
+ my($ans) =
+ CPAN::Shell::colorable_makemaker_prompt
+ (qq{Other job not responding. Shall I overwrite }.
+ qq{the lockfile '$lockfile'? (Y/n)},"y");
+ $CPAN::Frontend->myexit("Ok, bye\n")
+ unless $ans =~ /^y/i;
+ } else {
+ Carp::croak(
+ qq{Lockfile '$lockfile' not writable by you. }.
+ qq{Cannot proceed.\n}.
+ qq{ On UNIX try:\n}.
+ qq{ rm '$lockfile'\n}.
+ qq{ and then rerun us.\n}
+ );
+ }
+ } else {
+ $CPAN::Frontend->mydie(sprintf("CPAN.pm panic: Found invalid lockfile ".
+ "'$lockfile', please remove. Cannot proceed.\n"));
}
}
my $dotcpan = $CPAN::Config->{cpan_home};
eval { File::Path::mkpath($dotcpan);};
if ($@) {
- # A special case at least for Jarkko.
- my $firsterror = $@;
- my $seconderror;
- my $symlinkcpan;
- if (-l $dotcpan) {
- $symlinkcpan = readlink $dotcpan;
- die "readlink $dotcpan failed: $!" unless defined $symlinkcpan;
- eval { File::Path::mkpath($symlinkcpan); };
- if ($@) {
- $seconderror = $@;
- } else {
- $CPAN::Frontend->mywarn(qq{
+ # A special case at least for Jarkko.
+ my $firsterror = $@;
+ my $seconderror;
+ my $symlinkcpan;
+ if (-l $dotcpan) {
+ $symlinkcpan = readlink $dotcpan;
+ die "readlink $dotcpan failed: $!" unless defined $symlinkcpan;
+ eval { File::Path::mkpath($symlinkcpan); };
+ if ($@) {
+ $seconderror = $@;
+ } else {
+ $CPAN::Frontend->mywarn(qq{
Working directory $symlinkcpan created.
});
- }
- }
- unless (-d $dotcpan) {
- my $diemess = qq{
+ }
+ }
+ unless (-d $dotcpan) {
+ my $mess = qq{
Your configuration suggests "$dotcpan" as your
CPAN.pm working directory. I could not create this directory due
to this error: $firsterror\n};
- $diemess .= qq{
+ $mess .= qq{
As "$dotcpan" is a symlink to "$symlinkcpan",
I tried to create that, but I failed with this error: $seconderror
} if $seconderror;
- $diemess .= qq{
+ $mess .= qq{
Please make sure the directory exists and is writable.
};
- $CPAN::Frontend->mydie($diemess);
- }
+ $CPAN::Frontend->mywarn($mess);
+ return suggest_myconfig;
+ }
+ } # $@ after eval mkpath $dotcpan
+ if (0) { # to test what happens when a race condition occurs
+ for (reverse 1..10) {
+ print $_, "\n";
+ sleep 1;
+ }
}
- my $fh;
- unless ($fh = FileHandle->new(">$lockfile")) {
- if ($! =~ /Permission/) {
- my $incc = $INC{'CPAN/Config.pm'};
- my $myincc = File::Spec->catfile($ENV{HOME},'.cpan','CPAN','MyConfig.pm');
- $CPAN::Frontend->myprint(qq{
+ # locking
+ if (!$RUN_DEGRADED && !$self->{LOCKFH}) {
+ my $fh;
+ unless ($fh = FileHandle->new("+>>$lockfile")) {
+ if ($! =~ /Permission/) {
+ $CPAN::Frontend->mywarn(qq{
Your configuration suggests that CPAN.pm should use a working
directory of
Please make sure that the configuration variable
\$CPAN::Config->{cpan_home}
points to a directory where you can write a .lock file. You can set
-this variable in either
- $incc
-or
- $myincc
-
+this variable in either a CPAN/MyConfig.pm or a CPAN/Config.pm in your
+\@INC path;
});
- }
- $CPAN::Frontend->mydie("Could not open >$lockfile: $!");
+ return suggest_myconfig;
+ }
+ }
+ my $sleep = 1;
+ while (!CPAN::_flock($fh, LOCK_EX|LOCK_NB)) {
+ if ($sleep>10) {
+ $CPAN::Frontend->mydie("Giving up\n");
+ }
+ $CPAN::Frontend->mysleep($sleep++);
+ $CPAN::Frontend->mywarn("Could not lock lockfile with flock: $!; retrying\n");
+ }
+
+ seek $fh, 0, 0;
+ truncate $fh, 0;
+ $fh->autoflush(1);
+ $fh->print($$, "\n");
+ $fh->print(hostname(), "\n");
+ $self->{LOCK} = $lockfile;
+ $self->{LOCKFH} = $fh;
}
- $fh->print($$, "\n");
- $fh->print(hostname(), "\n");
- $self->{LOCK} = $lockfile;
- $fh->close;
$SIG{TERM} = sub {
- &cleanup;
- $CPAN::Frontend->mydie("Got SIGTERM, leaving");
+ my $sig = shift;
+ &cleanup;
+ $CPAN::Frontend->mydie("Got SIG$sig, leaving");
};
$SIG{INT} = sub {
# no blocks!!!
- &cleanup if $Signal;
- $CPAN::Frontend->mydie("Got another SIGINT") if $Signal;
- print "Caught SIGINT\n";
- $Signal++;
+ my $sig = shift;
+ &cleanup if $Signal;
+ die "Got yet another signal" if $Signal > 1;
+ $CPAN::Frontend->mydie("Got another SIG$sig") if $Signal;
+ $CPAN::Frontend->mywarn("Caught SIG$sig, trying to continue\n");
+ $Signal++;
};
# From: Larry Wall <larry@wall.org>
#-> sub CPAN::getcwd ;
sub getcwd {Cwd::getcwd();}
+#-> sub CPAN::fastcwd ;
+sub fastcwd {Cwd::fastcwd();}
+
+#-> sub CPAN::backtickcwd ;
+sub backtickcwd {my $cwd = `cwd`; chomp $cwd; $cwd}
+
#-> sub CPAN::find_perl ;
-sub find_perl {
+sub find_perl () {
my($perl) = File::Spec->file_name_is_absolute($^X) ? $^X : "";
- my $pwd = $CPAN::iCwd = CPAN::anycwd();
- my $candidate = File::Spec->catfile($pwd,$^X);
- $perl ||= $candidate if MM->maybe_command($candidate);
-
unless ($perl) {
- my ($component,$perl_name);
+ my $candidate = File::Spec->catfile($CPAN::iCwd,$^X);
+ $^X = $perl = $candidate if MM->maybe_command($candidate);
+ }
+ unless ($perl) {
+ my ($component,$perl_name);
DIST_PERLNAME: foreach $perl_name ($^X, 'perl', 'perl5', "perl$]") {
- PATH_COMPONENT: foreach $component (File::Spec->path(),
- $Config::Config{'binexp'}) {
- next unless defined($component) && $component;
- my($abs) = File::Spec->catfile($component,$perl_name);
- if (MM->maybe_command($abs)) {
- $perl = $abs;
- last DIST_PERLNAME;
- }
- }
- }
+ PATH_COMPONENT: foreach $component (File::Spec->path(),
+ $Config::Config{'binexp'}) {
+ next unless defined($component) && $component;
+ my($abs) = File::Spec->catfile($component,$perl_name);
+ if (MM->maybe_command($abs)) {
+ $^X = $perl = $abs;
+ last DIST_PERLNAME;
+ }
+ }
+ }
}
-
return $perl;
}
### Carp::croak "exists called without class argument" unless $class;
$id ||= "";
$id =~ s/:+/::/g if $class eq "CPAN::Module";
- exists $META->{readonly}{$class}{$id} or
- exists $META->{readwrite}{$class}{$id}; # unsafe meta access, ok
+ my $exists;
+ if (CPAN::_sqlite_running) {
+ $exists = (exists $META->{readonly}{$class}{$id} or
+ $CPAN::SQLite->set($class, $id));
+ } else {
+ $exists = exists $META->{readonly}{$class}{$id};
+ }
+ $exists ||= exists $META->{readwrite}{$class}{$id}; # unsafe meta access, ok
}
#-> sub CPAN::delete ;
'Net::FTP' => [
sub {require Net::FTP},
sub {require Net::Config},
- ]
+ ],
+ 'File::HomeDir' => [
+ sub {require File::HomeDir;
+ unless (CPAN::Version->vge(File::HomeDir::->VERSION, 0.52)) {
+ for ("Will not use File::HomeDir, need 0.52\n") {
+ $CPAN::Frontend->mywarn($_);
+ die $_;
+ }
+ }
+ },
+ ],
+ 'Archive::Tar' => [
+ sub {require Archive::Tar;
+ unless (CPAN::Version->vge(Archive::Tar::->VERSION, 1.50)) {
+ for ("Will not use Archive::Tar, need 1.00\n") {
+ $CPAN::Frontend->mywarn($_);
+ die $_;
+ }
+ }
+ unless (CPAN::Version->vge(Archive::Tar::->VERSION, 1.50)) {
+ my $atv = Archive::Tar->VERSION;
+ $CPAN::Frontend->mywarn("You have Archive::Tar $atv, but 1.50 or later is recommended. Please upgrade.\n");
+ }
+ },
+ ],
+ 'File::Temp' => [
+ # XXX we should probably delete from
+ # %INC too so we can load after we
+ # installed a new enough version --
+ # I'm not sure.
+ sub {require File::Temp;
+ unless (CPAN::Version->vge(File::Temp::->VERSION,0.16)) {
+ for ("Will not use File::Temp, need 0.16\n") {
+ $CPAN::Frontend->mywarn($_);
+ die $_;
+ }
+ }
+ },
+ ]
};
if ($usable->{$mod}) {
- for my $c (0..$#{$usable->{$mod}}) {
- my $code = $usable->{$mod}[$c];
- my $ret = eval { &$code() };
- if ($@) {
- warn "DEBUG: c[$c]\$\@[$@]ret[$ret]";
- return;
+ for my $c (0..$#{$usable->{$mod}}) {
+ my $code = $usable->{$mod}[$c];
+ my $ret = eval { &$code() };
+ $ret = "" unless defined $ret;
+ if ($@) {
+ # warn "DEBUG: c[$c]\$\@[$@]ret[$ret]";
+ return;
+ }
}
- }
}
return $HAS_USABLE->{$mod} = 1;
}
sub has_inst {
my($self,$mod,$message) = @_;
Carp::croak("CPAN->has_inst() called without an argument")
- unless defined $mod;
- if (defined $message && $message eq "no"
- ||
- exists $CPAN::META->{dontload_hash}{$mod} # unsafe meta access, ok
+ unless defined $mod;
+ my %dont = map { $_ => 1 } keys %{$CPAN::META->{dontload_hash}||{}},
+ keys %{$CPAN::Config->{dontload_hash}||{}},
+ @{$CPAN::Config->{dontload_list}||[]};
+ if (defined $message && $message eq "no" # afair only used by Nox
||
- exists $CPAN::Config->{dontload_hash}{$mod}
+ $dont{$mod}
) {
$CPAN::META->{dontload_hash}{$mod}||=1; # unsafe meta access, ok
return 0;
$file =~ s|::|/|g;
$file .= ".pm";
if ($INC{$file}) {
- # checking %INC is wrong, because $INC{LWP} may be true
- # although $INC{"URI/URL.pm"} may have failed. But as
- # I really want to say "bla loaded OK", I have to somehow
- # cache results.
- ### warn "$file in %INC"; #debug
- return 1;
+ # checking %INC is wrong, because $INC{LWP} may be true
+ # although $INC{"URI/URL.pm"} may have failed. But as
+ # I really want to say "bla loaded OK", I have to somehow
+ # cache results.
+ ### warn "$file in %INC"; #debug
+ return 1;
} elsif (eval { require $file }) {
- # eval is good: if we haven't yet read the database it's
- # perfect and if we have installed the module in the meantime,
- # it tries again. The second require is only a NOOP returning
- # 1 if we had success, otherwise it's retrying
-
- $CPAN::Frontend->myprint("CPAN: $mod loaded ok\n");
- if ($mod eq "CPAN::WAIT") {
- push @CPAN::Shell::ISA, 'CPAN::WAIT';
- }
- return 1;
+ # eval is good: if we haven't yet read the database it's
+ # perfect and if we have installed the module in the meantime,
+ # it tries again. The second require is only a NOOP returning
+ # 1 if we had success, otherwise it's retrying
+
+ my $mtime = (stat $INC{$file})[9];
+ # privileged files loaded by has_inst; Note: we use $mtime
+ # as a proxy for a checksum.
+ $CPAN::Shell::reload->{$file} = $mtime;
+ my $v = eval "\$$mod\::VERSION";
+ $v = $v ? " (v$v)" : "";
+ CPAN::Shell->optprint("load_module","CPAN: $mod loaded ok$v\n");
+ if ($mod eq "CPAN::WAIT") {
+ push @CPAN::Shell::ISA, 'CPAN::WAIT';
+ }
+ return 1;
} elsif ($mod eq "Net::FTP") {
- $CPAN::Frontend->mywarn(qq{
+ $CPAN::Frontend->mywarn(qq{
Please, install Net::FTP as soon as possible. CPAN.pm installs it for you
if you just type
install Bundle::libnet
}) unless $Have_warned->{"Net::FTP"}++;
- sleep 3;
- } elsif ($mod eq "Digest::SHA"){
- $CPAN::Frontend->myprint(qq{
+ $CPAN::Frontend->mysleep(3);
+ } elsif ($mod eq "Digest::SHA") {
+ if ($Have_warned->{"Digest::SHA"}++) {
+ $CPAN::Frontend->mywarn(qq{CPAN: checksum security checks disabled }.
+ qq{because Digest::SHA not installed.\n});
+ } else {
+ $CPAN::Frontend->mywarn(qq{
CPAN: checksum security checks disabled because Digest::SHA not installed.
Please consider installing the Digest::SHA module.
});
- sleep 2;
- } elsif ($mod eq "Module::Signature"){
- unless ($Have_warned->{"Module::Signature"}++) {
- # No point in complaining unless the user can
- # reasonably install and use it.
- if (eval { require Crypt::OpenPGP; 1 } ||
- defined $CPAN::Config->{'gpg'}) {
- $CPAN::Frontend->myprint(qq{
+ $CPAN::Frontend->mysleep(2);
+ }
+ } elsif ($mod eq "Module::Signature") {
+ # NOT prefs_lookup, we are not a distro
+ my $check_sigs = $CPAN::Config->{check_sigs};
+ if (not $check_sigs) {
+ # they do not want us:-(
+ } elsif (not $Have_warned->{"Module::Signature"}++) {
+ # No point in complaining unless the user can
+ # reasonably install and use it.
+ if (eval { require Crypt::OpenPGP; 1 } ||
+ (
+ defined $CPAN::Config->{'gpg'}
+ &&
+ $CPAN::Config->{'gpg'} =~ /\S/
+ )
+ ) {
+ $CPAN::Frontend->mywarn(qq{
CPAN: Module::Signature security checks disabled because Module::Signature
not installed. Please consider installing the Module::Signature module.
You may also need to be able to connect over the Internet to the public
keyservers like pgp.mit.edu (port 11371).
});
- sleep 2;
- }
- }
+ $CPAN::Frontend->mysleep(2);
+ }
+ }
} else {
- delete $INC{$file}; # if it inc'd LWP but failed during, say, URI
+ delete $INC{$file}; # if it inc'd LWP but failed during, say, URI
}
return 0;
}
my($subroutine);
while ((undef,undef,undef,$subroutine) = caller(++$i)) {
$ineval = 1, last if
- $subroutine eq '(eval)';
+ $subroutine eq '(eval)';
}
return if $ineval && !$CPAN::End;
return unless defined $META->{LOCK};
return unless -f $META->{LOCK};
$META->savehist;
+ close $META->{LOCKFH};
unlink $META->{LOCK};
# require Carp;
# Carp::cluck("DEBUGGING");
- $CPAN::Frontend->mywarn("Lockfile removed.\n");
+ if ( $CPAN::CONFIG_DIRTY ) {
+ $CPAN::Frontend->mywarn("Warning: Configuration not saved.\n");
+ }
+ $CPAN::Frontend->myprint("Lockfile removed.\n");
+}
+
+#-> sub CPAN::readhist
+sub readhist {
+ my($self,$term,$histfile) = @_;
+ my $histsize = $CPAN::Config->{'histsize'} || 100;
+ $term->Attribs->{'MaxHistorySize'} = $histsize if (defined($term->Attribs->{'MaxHistorySize'}));
+ my($fh) = FileHandle->new;
+ open $fh, "<$histfile" or return;
+ local $/ = "\n";
+ while (<$fh>) {
+ chomp;
+ $term->AddHistory($_);
+ }
+ close $fh;
}
#-> sub CPAN::savehist
sub savehist {
my($self) = @_;
my($histfile,$histsize);
- unless ($histfile = $CPAN::Config->{'histfile'}){
+ unless ($histfile = $CPAN::Config->{'histfile'}) {
$CPAN::Frontend->mywarn("No history written (no histfile specified).\n");
return;
}
$histsize = $CPAN::Config->{'histsize'} || 100;
- if ($CPAN::term){
+ if ($CPAN::term) {
unless ($CPAN::term->can("GetHistory")) {
$CPAN::Frontend->mywarn("Terminal does not support GetHistory.\n");
return;
close $fh;
}
+#-> sub CPAN::is_tested
sub is_tested {
- my($self,$what) = @_;
- $self->{is_tested}{$what} = 1;
+ my($self,$what,$when) = @_;
+ unless ($what) {
+ Carp::cluck("DEBUG: empty what");
+ return;
+ }
+ $self->{is_tested}{$what} = $when;
}
+#-> sub CPAN::reset_tested
+# forget all distributions tested -- resets what gets included in PERL5LIB
+sub reset_tested {
+ my ($self) = @_;
+ $self->{is_tested} = {};
+}
+
+#-> sub CPAN::is_installed
+# unsets the is_tested flag: as soon as the thing is installed, it is
+# not needed in set_perl5lib anymore
sub is_installed {
my($self,$what) = @_;
delete $self->{is_tested}{$what};
}
-sub set_perl5lib {
+sub _list_sorted_descending_is_tested {
my($self) = @_;
+ sort
+ { ($self->{is_tested}{$b}||0) <=> ($self->{is_tested}{$a}||0) }
+ keys %{$self->{is_tested}}
+}
+
+#-> sub CPAN::set_perl5lib
+# Notes on max environment variable length:
+# - Win32 : XP or later, 8191; Win2000 or NT4, 2047
+{
+my $fh;
+sub set_perl5lib {
+ my($self,$for) = @_;
+ unless ($for) {
+ (undef,undef,undef,$for) = caller(1);
+ $for =~ s/.*://;
+ }
$self->{is_tested} ||= {};
return unless %{$self->{is_tested}};
my $env = $ENV{PERL5LIB};
$env = $ENV{PERLLIB} unless defined $env;
my @env;
- push @env, $env if defined $env and length $env;
- my @dirs = map {("$_/blib/arch", "$_/blib/lib")} keys %{$self->{is_tested}};
- $CPAN::Frontend->myprint("Prepending @dirs to PERL5LIB.\n");
- $ENV{PERL5LIB} = join $Config::Config{path_sep}, @dirs, @env;
-}
-
-package CPAN::CacheMgr;
-use strict;
-
-#-> sub CPAN::CacheMgr::as_string ;
-sub as_string {
- eval { require Data::Dumper };
- if ($@) {
- return shift->SUPER::as_string;
+ push @env, split /\Q$Config::Config{path_sep}\E/, $env if defined $env and length $env;
+ #my @dirs = map {("$_/blib/arch", "$_/blib/lib")} keys %{$self->{is_tested}};
+ #$CPAN::Frontend->myprint("Prepending @dirs to PERL5LIB.\n");
+
+ my @dirs = map {("$_/blib/arch", "$_/blib/lib")} $self->_list_sorted_descending_is_tested;
+ return if !@dirs;
+
+ if (@dirs < 12) {
+ $CPAN::Frontend->optprint('perl5lib', "Prepending @dirs to PERL5LIB for '$for'\n");
+ $ENV{PERL5LIB} = join $Config::Config{path_sep}, @dirs, @env;
+ } elsif (@dirs < 24 ) {
+ my @d = map {my $cp = $_;
+ $cp =~ s/^\Q$CPAN::Config->{build_dir}\E/%BUILDDIR%/;
+ $cp
+ } @dirs;
+ $CPAN::Frontend->optprint('perl5lib', "Prepending @d to PERL5LIB; ".
+ "%BUILDDIR%=$CPAN::Config->{build_dir} ".
+ "for '$for'\n"
+ );
+ $ENV{PERL5LIB} = join $Config::Config{path_sep}, @dirs, @env;
} else {
- return Data::Dumper::Dumper(shift);
+ my $cnt = keys %{$self->{is_tested}};
+ $CPAN::Frontend->optprint('perl5lib', "Prepending blib/arch and blib/lib of ".
+ "$cnt build dirs to PERL5LIB; ".
+ "for '$for'\n"
+ );
+ $ENV{PERL5LIB} = join $Config::Config{path_sep}, @dirs, @env;
}
-}
+}}
-#-> sub CPAN::CacheMgr::cachesize ;
-sub cachesize {
- shift->{DU};
-}
-#-> sub CPAN::CacheMgr::tidyup ;
-sub tidyup {
- my($self) = @_;
- return unless -d $self->{ID};
- while ($self->{DU} > $self->{'MAX'} ) {
- my($toremove) = shift @{$self->{FIFO}};
- $CPAN::Frontend->myprint(sprintf(
- "Deleting from cache".
- ": $toremove (%.1f>%.1f MB)\n",
- $self->{DU}, $self->{'MAX'})
- );
- return if $CPAN::Signal;
- $self->force_clean_cache($toremove);
- return if $CPAN::Signal;
- }
-}
+1;
-#-> sub CPAN::CacheMgr::dir ;
-sub dir {
- shift->{ID};
-}
-#-> sub CPAN::CacheMgr::entries ;
-sub entries {
- my($self,$dir) = @_;
- return unless defined $dir;
- $self->debug("reading dir[$dir]") if $CPAN::DEBUG;
- $dir ||= $self->{ID};
- my($cwd) = CPAN::anycwd();
- chdir $dir or Carp::croak("Can't chdir to $dir: $!");
- my $dh = DirHandle->new(File::Spec->curdir)
- or Carp::croak("Couldn't opendir $dir: $!");
- my(@entries);
- for ($dh->read) {
- next if $_ eq "." || $_ eq "..";
- if (-f $_) {
- push @entries, File::Spec->catfile($dir,$_);
- } elsif (-d _) {
- push @entries, File::Spec->catdir($dir,$_);
- } else {
- $CPAN::Frontend->mywarn("Warning: weird direntry in $dir: $_\n");
- }
- }
- chdir $cwd or Carp::croak("Can't chdir to $cwd: $!");
- sort { -M $b <=> -M $a} @entries;
-}
-
-#-> sub CPAN::CacheMgr::disk_usage ;
-sub disk_usage {
- my($self,$dir) = @_;
- return if exists $self->{SIZE}{$dir};
- return if $CPAN::Signal;
- my($Du) = 0;
- unless (-x $dir) {
- unless (chmod 0755, $dir) {
- $CPAN::Frontend->mywarn("I have neither the -x permission nor the permission ".
- "to change the permission; cannot estimate disk usage ".
- "of '$dir'\n");
- sleep 5;
- return;
- }
- }
- find(
- sub {
- $File::Find::prune++ if $CPAN::Signal;
- return if -l $_;
- if ($^O eq 'MacOS') {
- require Mac::Files;
- my $cat = Mac::Files::FSpGetCatInfo($_);
- $Du += $cat->ioFlLgLen() + $cat->ioFlRLgLen() if $cat;
- } else {
- if (-d _) {
- unless (-x _) {
- unless (chmod 0755, $_) {
- $CPAN::Frontend->mywarn("I have neither the -x permission nor ".
- "the permission to change the permission; ".
- "can only partially estimate disk usage ".
- "of '$_'\n");
- sleep 5;
- return;
- }
- }
- } else {
- $Du += (-s _);
- }
- }
- },
- $dir
- );
- return if $CPAN::Signal;
- $self->{SIZE}{$dir} = $Du/1024/1024;
- push @{$self->{FIFO}}, $dir;
- $self->debug("measured $dir is $Du") if $CPAN::DEBUG;
- $self->{DU} += $Du/1024/1024;
- $self->{DU};
-}
+__END__
-#-> sub CPAN::CacheMgr::force_clean_cache ;
-sub force_clean_cache {
- my($self,$dir) = @_;
- return unless -e $dir;
- $self->debug("have to rmtree $dir, will free $self->{SIZE}{$dir}")
- if $CPAN::DEBUG;
- File::Path::rmtree($dir);
- $self->{DU} -= $self->{SIZE}{$dir};
- delete $self->{SIZE}{$dir};
-}
+=head1 NAME
-#-> sub CPAN::CacheMgr::new ;
-sub new {
- my $class = shift;
- my $time = time;
- my($debug,$t2);
- $debug = "";
- my $self = {
- ID => $CPAN::Config->{'build_dir'},
- MAX => $CPAN::Config->{'build_cache'},
- SCAN => $CPAN::Config->{'scan_cache'} || 'atstart',
- DU => 0
- };
- File::Path::mkpath($self->{ID});
- my $dh = DirHandle->new($self->{ID});
- bless $self, $class;
- $self->scan_cache;
- $t2 = time;
- $debug .= "timing of CacheMgr->new: ".($t2 - $time);
- $time = $t2;
- CPAN->debug($debug) if $CPAN::DEBUG;
- $self;
-}
+CPAN - query, download and build perl modules from CPAN sites
-#-> sub CPAN::CacheMgr::scan_cache ;
-sub scan_cache {
- my $self = shift;
- return if $self->{SCAN} eq 'never';
- $CPAN::Frontend->mydie("Unknown scan_cache argument: $self->{SCAN}")
- unless $self->{SCAN} eq 'atstart';
- $CPAN::Frontend->myprint(
- sprintf("Scanning cache %s for sizes\n",
- $self->{ID}));
- my $e;
- for $e ($self->entries($self->{ID})) {
- next if $e eq ".." || $e eq ".";
- $self->disk_usage($e);
- return if $CPAN::Signal;
- }
- $self->tidyup;
-}
+=head1 SYNOPSIS
-package CPAN::Shell;
-use strict;
+Interactive mode:
-#-> sub CPAN::Shell::h ;
-sub h {
- my($class,$about) = @_;
- if (defined $about) {
- $CPAN::Frontend->myprint("Detailed help not yet implemented\n");
- } else {
- $CPAN::Frontend->myprint(q{
-Display Information
- command argument description
- a,b,d,m WORD or /REGEXP/ about authors, bundles, distributions, modules
- i WORD or /REGEXP/ about any of the above
- r NONE report updatable modules
- ls AUTHOR or GLOB about files in the author's directory
- (with WORD being a module, bundle or author name or a distribution
- name of the form AUTHOR/DISTRIBUTION)
-
-Download, Test, Make, Install...
- get download clean make clean
- make make (implies get) look open subshell in dist directory
- test make test (implies make) readme display these README files
- install make install (implies test) perldoc display POD documentation
-
-Pragmas
- force COMMAND unconditionally do command
- notest COMMAND skip testing
-
-Other
- h,? display this menu ! perl-code eval a perl command
- o conf [opt] set and query options q quit the cpan shell
- reload cpan load CPAN.pm again reload index load newer indices
- autobundle Snapshot recent latest CPAN uploads});
- }
-}
+ perl -MCPAN -e shell
-*help = \&h;
+--or--
-#-> sub CPAN::Shell::a ;
-sub a {
- my($self,@arg) = @_;
- # authors are always UPPERCASE
- for (@arg) {
- $_ = uc $_ unless /=/;
- }
- $CPAN::Frontend->myprint($self->format_result('Author',@arg));
-}
+ cpan
-sub handle_ls {
- my($self,$pragma,$s) = @_;
- # ls is really very different, but we had it once as an ordinary
- # command in the Shell (upto rev. 321) and we could not handle
- # force well then
- my(@accept,@preexpand);
- if ($s =~ /[\*\?\/]/) {
- if ($CPAN::META->has_inst("Text::Glob")) {
- if (my($au,$pathglob) = $s =~ m|(.*?)/(.*)|) {
- my $rau = Text::Glob::glob_to_regex(uc $au);
- CPAN::Shell->debug("au[$au]pathglob[$pathglob]rau[$rau]")
- if $CPAN::DEBUG;
- push @preexpand, map { $_->id . "/" . $pathglob }
- CPAN::Shell->expand_by_method('CPAN::Author',['id'],"/$rau/");
- } else {
- my $rau = Text::Glob::glob_to_regex(uc $s);
- push @preexpand, map { $_->id }
- CPAN::Shell->expand_by_method('CPAN::Author',
- ['id'],
- "/$rau/");
- }
- } else {
- $CPAN::Frontend->mydie("Text::Glob not installed, cannot proceed");
- }
- } else {
- push @preexpand, uc $s;
- }
- for (@preexpand) {
- unless (/^[A-Z0-9\-]+(\/|$)/i) {
- $CPAN::Frontend->mywarn("ls command rejects argument $_: not an author\n");
- next;
- }
- push @accept, $_;
- }
- my $silent = @accept>1;
- my $last_alpha = "";
- for my $a (@accept){
- my($author,$pathglob);
- if ($a =~ m|(.*?)/(.*)|) {
- my $a2 = $1;
- $pathglob = $2;
- $author = CPAN::Shell->expand_by_method('CPAN::Author',
- ['id'],
- $a2) or die "No author found for $a2";
- } else {
- $author = CPAN::Shell->expand_by_method('CPAN::Author',
- ['id'],
- $a) or die "No author found for $a";
- }
- if ($silent) {
- my $alpha = substr $author->id, 0, 1;
- my $ad;
- if ($alpha eq $last_alpha) {
- $ad = "";
- } else {
- $ad = "[$alpha]";
- $last_alpha = $alpha;
- }
- $CPAN::Frontend->myprint($ad);
- }
- $author->ls($pathglob,$silent); # silent if more than one author
- }
-}
+Basic commands:
-#-> sub CPAN::Shell::local_bundles ;
-sub local_bundles {
- my($self,@which) = @_;
- my($incdir,$bdir,$dh);
- foreach $incdir ($CPAN::Config->{'cpan_home'},@INC) {
- my @bbase = "Bundle";
- while (my $bbase = shift @bbase) {
- $bdir = File::Spec->catdir($incdir,split /::/, $bbase);
- CPAN->debug("bdir[$bdir]\@bbase[@bbase]") if $CPAN::DEBUG;
- if ($dh = DirHandle->new($bdir)) { # may fail
- my($entry);
- for $entry ($dh->read) {
- next if $entry =~ /^\./;
- if (-d File::Spec->catdir($bdir,$entry)){
- push @bbase, "$bbase\::$entry";
- } else {
- next unless $entry =~ s/\.pm(?!\n)\Z//;
- $CPAN::META->instance('CPAN::Bundle',"$bbase\::$entry");
- }
- }
- }
- }
- }
-}
+ # Modules:
-#-> sub CPAN::Shell::b ;
-sub b {
- my($self,@which) = @_;
- CPAN->debug("which[@which]") if $CPAN::DEBUG;
- $self->local_bundles;
- $CPAN::Frontend->myprint($self->format_result('Bundle',@which));
-}
+ cpan> install Acme::Meta # in the shell
-#-> sub CPAN::Shell::d ;
-sub d { $CPAN::Frontend->myprint(shift->format_result('Distribution',@_));}
+ CPAN::Shell->install("Acme::Meta"); # in perl
-#-> sub CPAN::Shell::m ;
-sub m { # emacs confused here }; sub mimimimimi { # emacs in sync here
- my $self = shift;
- $CPAN::Frontend->myprint($self->format_result('Module',@_));
-}
+ # Distributions:
-#-> sub CPAN::Shell::i ;
-sub i {
- my($self) = shift;
- my(@args) = @_;
- @args = '/./' unless @args;
- my(@result);
- for my $type (qw/Bundle Distribution Module/) {
- push @result, $self->expand($type,@args);
- }
- # Authors are always uppercase.
- push @result, $self->expand("Author", map { uc $_ } @args);
-
- my $result = @result == 1 ?
- $result[0]->as_string :
- @result == 0 ?
- "No objects found of any type for argument @args\n" :
- join("",
- (map {$_->as_glimpse} @result),
- scalar @result, " items found\n",
- );
- $CPAN::Frontend->myprint($result);
-}
+ cpan> install NWCLARK/Acme-Meta-0.02.tar.gz # in the shell
-#-> sub CPAN::Shell::o ;
-
-# CPAN::Shell::o and CPAN::Config::edit are closely related. 'o conf'
-# should have been called set and 'o debug' maybe 'set debug'
-sub o {
- my($self,$o_type,@o_what) = @_;
- $o_type ||= "";
- CPAN->debug("o_type[$o_type] o_what[".join(" | ",@o_what)."]\n");
- if ($o_type eq 'conf') {
- shift @o_what if @o_what && $o_what[0] eq 'help';
- if (!@o_what) { # print all things, "o conf"
- my($k,$v);
- $CPAN::Frontend->myprint("CPAN::Config options");
- if (exists $INC{'CPAN/Config.pm'}) {
- $CPAN::Frontend->myprint(" from $INC{'CPAN/Config.pm'}");
- }
- if (exists $INC{'CPAN/MyConfig.pm'}) {
- $CPAN::Frontend->myprint(" and $INC{'CPAN/MyConfig.pm'}");
- }
- $CPAN::Frontend->myprint(":\n");
- for $k (sort keys %CPAN::HandleConfig::can) {
- $v = $CPAN::HandleConfig::can{$k};
- $CPAN::Frontend->myprint(sprintf " %-18s [%s]\n", $k, $v);
- }
- $CPAN::Frontend->myprint("\n");
- for $k (sort keys %$CPAN::Config) {
- CPAN::HandleConfig->prettyprint($k);
- }
- $CPAN::Frontend->myprint("\n");
- } elsif (!CPAN::HandleConfig->edit(@o_what)) {
- $CPAN::Frontend->myprint(qq{Type 'o conf' to view all configuration }.
- qq{items\n\n});
- }
- } elsif ($o_type eq 'debug') {
- my(%valid);
- @o_what = () if defined $o_what[0] && $o_what[0] =~ /help/i;
- if (@o_what) {
- while (@o_what) {
- my($what) = shift @o_what;
- if ($what =~ s/^-// && exists $CPAN::DEBUG{$what}) {
- $CPAN::DEBUG &= $CPAN::DEBUG ^ $CPAN::DEBUG{$what};
- next;
- }
- if ( exists $CPAN::DEBUG{$what} ) {
- $CPAN::DEBUG |= $CPAN::DEBUG{$what};
- } elsif ($what =~ /^\d/) {
- $CPAN::DEBUG = $what;
- } elsif (lc $what eq 'all') {
- my($max) = 0;
- for (values %CPAN::DEBUG) {
- $max += $_;
- }
- $CPAN::DEBUG = $max;
- } else {
- my($known) = 0;
- for (keys %CPAN::DEBUG) {
- next unless lc($_) eq lc($what);
- $CPAN::DEBUG |= $CPAN::DEBUG{$_};
- $known = 1;
- }
- $CPAN::Frontend->myprint("unknown argument [$what]\n")
- unless $known;
- }
- }
- } else {
- my $raw = "Valid options for debug are ".
- join(", ",sort(keys %CPAN::DEBUG), 'all').
- qq{ or a number. Completion works on the options. }.
- qq{Case is ignored.};
- require Text::Wrap;
- $CPAN::Frontend->myprint(Text::Wrap::fill("","",$raw));
- $CPAN::Frontend->myprint("\n\n");
- }
- if ($CPAN::DEBUG) {
- $CPAN::Frontend->myprint("Options set for debugging:\n");
- my($k,$v);
- for $k (sort {$CPAN::DEBUG{$a} <=> $CPAN::DEBUG{$b}} keys %CPAN::DEBUG) {
- $v = $CPAN::DEBUG{$k};
- $CPAN::Frontend->myprint(sprintf " %-14s(%s)\n", $k, $v)
- if $v & $CPAN::DEBUG;
- }
- } else {
- $CPAN::Frontend->myprint("Debugging turned off completely.\n");
- }
- } else {
- $CPAN::Frontend->myprint(qq{
-Known options:
- conf set or get configuration variables
- debug set or get debugging options
-});
- }
-}
+ CPAN::Shell->
+ install("NWCLARK/Acme-Meta-0.02.tar.gz"); # in perl
-sub paintdots_onreload {
- my($ref) = shift;
- sub {
- if ( $_[0] =~ /[Ss]ubroutine ([\w:]+) redefined/ ) {
- my($subr) = $1;
- ++$$ref;
- local($|) = 1;
- # $CPAN::Frontend->myprint(".($subr)");
- $CPAN::Frontend->myprint(".");
- return;
- }
- warn @_;
- };
-}
+ # module objects:
-#-> sub CPAN::Shell::reload ;
-sub reload {
- my($self,$command,@arg) = @_;
- $command ||= "";
- $self->debug("self[$self]command[$command]arg[@arg]") if $CPAN::DEBUG;
- if ($command =~ /cpan/i) {
- my $redef = 0;
- chdir $CPAN::iCwd if $CPAN::iCwd; # may fail
- my $failed;
- MFILE: for my $f (qw(CPAN.pm CPAN/HandleConfig.pm CPAN/FirstTime.pm CPAN/Tarzip.pm
- CPAN/Debug.pm CPAN/Version.pm)) {
- next unless $INC{$f};
- my $pwd = CPAN::anycwd();
- CPAN->debug("reloading the whole '$f' from '$INC{$f}' while pwd='$pwd'")
- if $CPAN::DEBUG;
- my $read;
- for my $inc (@INC) {
- $read = File::Spec->catfile($inc,split /\//, $f);
- last if -f $read;
- }
- unless (-f $read) {
- $failed++;
- $CPAN::Frontend->mywarn("Found no file to reload for '$f'\n");
- next MFILE;
- }
- my $fh = FileHandle->new($read) or
- $CPAN::Frontend->mydie("Could not open $read: $!");
- local($/);
- local $^W = 1;
- local($SIG{__WARN__}) = paintdots_onreload(\$redef);
- my $eval = <$fh>;
- CPAN->debug(sprintf("evaling [%s...]\n",substr($eval,0,64)))
- if $CPAN::DEBUG;
- eval $eval;
- if ($@){
- $failed++;
- warn $@;
- }
- }
- $CPAN::Frontend->myprint("\n$redef subroutines redefined\n");
- $failed++ unless $redef;
- if ($failed) {
- $CPAN::Frontend->mywarn("\n$failed errors during reload. You better quit ".
- "this session.\n");
- }
- } elsif ($command =~ /index/) {
- CPAN::Index->force_reload;
- } else {
- $CPAN::Frontend->myprint(qq{cpan re-evals the CPAN.pm file
-index re-reads the index files\n});
- }
-}
+ $mo = CPAN::Shell->expandany($mod);
+ $mo = CPAN::Shell->expand("Module",$mod); # same thing
-#-> sub CPAN::Shell::_binary_extensions ;
-sub _binary_extensions {
- my($self) = shift @_;
- my(@result,$module,%seen,%need,$headerdone);
- for $module ($self->expand('Module','/./')) {
- my $file = $module->cpan_file;
- next if $file eq "N/A";
- next if $file =~ /^Contact Author/;
- my $dist = $CPAN::META->instance('CPAN::Distribution',$file);
- next if $dist->isa_perl;
- next unless $module->xs_file;
- local($|) = 1;
- $CPAN::Frontend->myprint(".");
- push @result, $module;
- }
-# print join " | ", @result;
- $CPAN::Frontend->myprint("\n");
- return @result;
-}
+ # distribution objects:
-#-> sub CPAN::Shell::recompile ;
-sub recompile {
- my($self) = shift @_;
- my($module,@module,$cpan_file,%dist);
- @module = $self->_binary_extensions();
- for $module (@module){ # we force now and compile later, so we
- # don't do it twice
- $cpan_file = $module->cpan_file;
- my $pack = $CPAN::META->instance('CPAN::Distribution',$cpan_file);
- $pack->force;
- $dist{$cpan_file}++;
- }
- for $cpan_file (sort keys %dist) {
- $CPAN::Frontend->myprint(" CPAN: Recompiling $cpan_file\n\n");
- my $pack = $CPAN::META->instance('CPAN::Distribution',$cpan_file);
- $pack->install;
- $CPAN::Signal = 0; # it's tempting to reset Signal, so we can
- # stop a package from recompiling,
- # e.g. IO-1.12 when we have perl5.003_10
- }
-}
+ $do = CPAN::Shell->expand("Module",$mod)->distribution;
+ $do = CPAN::Shell->expandany($distro); # same thing
+ $do = CPAN::Shell->expand("Distribution",
+ $distro); # same thing
-#-> sub CPAN::Shell::_u_r_common ;
-sub _u_r_common {
- my($self) = shift @_;
- my($what) = shift @_;
- CPAN->debug("self[$self] what[$what] args[@_]") if $CPAN::DEBUG;
- Carp::croak "Usage: \$obj->_u_r_common(a|r|u)" unless
- $what && $what =~ /^[aru]$/;
- my(@args) = @_;
- @args = '/./' unless @args;
- my(@result,$module,%seen,%need,$headerdone,
- $version_undefs,$version_zeroes);
- $version_undefs = $version_zeroes = 0;
- my $sprintf = "%s%-25s%s %9s %9s %s\n";
- my @expand = $self->expand('Module',@args);
- my $expand = scalar @expand;
- if (0) { # Looks like noise to me, was very useful for debugging
- # for metadata cache
- $CPAN::Frontend->myprint(sprintf "%d matches in the database\n", $expand);
- }
- MODULE: for $module (@expand) {
- my $file = $module->cpan_file;
- next MODULE unless defined $file; # ??
- $file =~ s|^./../||;
- my($latest) = $module->cpan_version;
- my($inst_file) = $module->inst_file;
- my($have);
- return if $CPAN::Signal;
- if ($inst_file){
- if ($what eq "a") {
- $have = $module->inst_version;
- } elsif ($what eq "r") {
- $have = $module->inst_version;
- local($^W) = 0;
- if ($have eq "undef"){
- $version_undefs++;
- } elsif ($have == 0){
- $version_zeroes++;
- }
- next MODULE unless CPAN::Version->vgt($latest, $have);
-# to be pedantic we should probably say:
-# && !($have eq "undef" && $latest ne "undef" && $latest gt "");
-# to catch the case where CPAN has a version 0 and we have a version undef
- } elsif ($what eq "u") {
- next MODULE;
- }
- } else {
- if ($what eq "a") {
- next MODULE;
- } elsif ($what eq "r") {
- next MODULE;
- } elsif ($what eq "u") {
- $have = "-";
- }
- }
- return if $CPAN::Signal; # this is sometimes lengthy
- $seen{$file} ||= 0;
- if ($what eq "a") {
- push @result, sprintf "%s %s\n", $module->id, $have;
- } elsif ($what eq "r") {
- push @result, $module->id;
- next MODULE if $seen{$file}++;
- } elsif ($what eq "u") {
- push @result, $module->id;
- next MODULE if $seen{$file}++;
- next MODULE if $file =~ /^Contact/;
- }
- unless ($headerdone++){
- $CPAN::Frontend->myprint("\n");
- $CPAN::Frontend->myprint(sprintf(
- $sprintf,
- "",
- "Package namespace",
- "",
- "installed",
- "latest",
- "in CPAN file"
- ));
- }
- my $color_on = "";
- my $color_off = "";
- if (
- $COLOR_REGISTERED
- &&
- $CPAN::META->has_inst("Term::ANSIColor")
- &&
- $module->description
- ) {
- $color_on = Term::ANSIColor::color("green");
- $color_off = Term::ANSIColor::color("reset");
- }
- $CPAN::Frontend->myprint(sprintf $sprintf,
- $color_on,
- $module->id,
- $color_off,
- $have,
- $latest,
- $file);
- $need{$module->id}++;
- }
- unless (%need) {
- if ($what eq "u") {
- $CPAN::Frontend->myprint("No modules found for @args\n");
- } elsif ($what eq "r") {
- $CPAN::Frontend->myprint("All modules are up to date for @args\n");
- }
- }
- if ($what eq "r") {
- if ($version_zeroes) {
- my $s_has = $version_zeroes > 1 ? "s have" : " has";
- $CPAN::Frontend->myprint(qq{$version_zeroes installed module$s_has }.
- qq{a version number of 0\n});
- }
- if ($version_undefs) {
- my $s_has = $version_undefs > 1 ? "s have" : " has";
- $CPAN::Frontend->myprint(qq{$version_undefs installed module$s_has no }.
- qq{parseable version number\n});
- }
- }
- @result;
-}
+=head1 DESCRIPTION
-#-> sub CPAN::Shell::r ;
-sub r {
- shift->_u_r_common("r",@_);
-}
+The CPAN module automates or at least simplifies the make and install
+of perl modules and extensions. It includes some primitive searching
+capabilities and knows how to use Net::FTP, LWP, and certain external
+download clients to fetch distributions from the net.
-#-> sub CPAN::Shell::u ;
-sub u {
- shift->_u_r_common("u",@_);
-}
+These are fetched from one or more mirrored CPAN (Comprehensive
+Perl Archive Network) sites and unpacked in a dedicated directory.
-# XXX intentionally undocumented because not considered enough
-#-> sub CPAN::Shell::failed ;
-sub failed {
- my($self) = @_;
- my $print = "";
- DIST: for my $d ($CPAN::META->all_objects("CPAN::Distribution")) {
- my $failed = "";
- for my $nosayer (qw(make make_test make_install)) {
- next unless exists $d->{$nosayer};
- next unless substr($d->{$nosayer},0,2) eq "NO";
- $failed = $nosayer;
- last;
- }
- next DIST unless $failed;
- my $id = $d->id;
- $id =~ s|^./../||;
- $print .= sprintf " %-45s: %s %s\n", $id, $failed, $d->{$failed};
- }
- if ($print) {
- $CPAN::Frontend->myprint("Failed installations in this session:\n$print");
- } else {
- $CPAN::Frontend->myprint("No installations failed in this session\n");
- }
-}
+The CPAN module also supports named and versioned
+I<bundles> of modules. Bundles simplify handling of sets of
+related modules. See Bundles below.
-# XXX intentionally undocumented because not considered enough
-#-> sub CPAN::Shell::status ;
-sub status {
- my($self) = @_;
- require Devel::Size;
- my $ps = FileHandle->new;
- open $ps, "/proc/$$/status";
- my $vm = 0;
- while (<$ps>) {
- next unless /VmSize:\s+(\d+)/;
- $vm = $1;
- last;
- }
- $CPAN::Frontend->mywarn(sprintf(
- "%-27s %6d\n%-27s %6d\n",
- "vm",
- $vm,
- "CPAN::META",
- Devel::Size::total_size($CPAN::META)/1024,
- ));
- for my $k (sort keys %$CPAN::META) {
- next unless substr($k,0,4) eq "read";
- warn sprintf " %-26s %6d\n", $k, Devel::Size::total_size($CPAN::META->{$k})/1024;
- for my $k2 (sort keys %{$CPAN::META->{$k}}) {
- warn sprintf " %-25s %6d %6d\n",
- $k2,
- Devel::Size::total_size($CPAN::META->{$k}{$k2})/1024,
- scalar keys %{$CPAN::META->{$k}{$k2}};
- }
- }
-}
+The package contains a session manager and a cache manager. The
+session manager keeps track of what has been fetched, built, and
+installed in the current session. The cache manager keeps track of the
+disk space occupied by the make processes and deletes excess space
+using a simple FIFO mechanism.
-#-> sub CPAN::Shell::autobundle ;
-sub autobundle {
- my($self) = shift;
- CPAN::HandleConfig->load unless $CPAN::Config_loaded++;
- my(@bundle) = $self->_u_r_common("a",@_);
- my($todir) = File::Spec->catdir($CPAN::Config->{'cpan_home'},"Bundle");
- File::Path::mkpath($todir);
- unless (-d $todir) {
- $CPAN::Frontend->myprint("Couldn't mkdir $todir for some reason\n");
- return;
- }
- my($y,$m,$d) = (localtime)[5,4,3];
- $y+=1900;
- $m++;
- my($c) = 0;
- my($me) = sprintf "Snapshot_%04d_%02d_%02d_%02d", $y, $m, $d, $c;
- my($to) = File::Spec->catfile($todir,"$me.pm");
- while (-f $to) {
- $me = sprintf "Snapshot_%04d_%02d_%02d_%02d", $y, $m, $d, ++$c;
- $to = File::Spec->catfile($todir,"$me.pm");
- }
- my($fh) = FileHandle->new(">$to") or Carp::croak "Can't open >$to: $!";
- $fh->print(
- "package Bundle::$me;\n\n",
- "\$VERSION = '0.01';\n\n",
- "1;\n\n",
- "__END__\n\n",
- "=head1 NAME\n\n",
- "Bundle::$me - Snapshot of installation on ",
- $Config::Config{'myhostname'},
- " on ",
- scalar(localtime),
- "\n\n=head1 SYNOPSIS\n\n",
- "perl -MCPAN -e 'install Bundle::$me'\n\n",
- "=head1 CONTENTS\n\n",
- join("\n", @bundle),
- "\n\n=head1 CONFIGURATION\n\n",
- Config->myconfig,
- "\n\n=head1 AUTHOR\n\n",
- "This Bundle has been generated automatically ",
- "by the autobundle routine in CPAN.pm.\n",
- );
- $fh->close;
- $CPAN::Frontend->myprint("\nWrote bundle file
- $to\n\n");
-}
+All methods provided are accessible in a programmer style and in an
+interactive shell style.
-#-> sub CPAN::Shell::expandany ;
-sub expandany {
- my($self,$s) = @_;
- CPAN->debug("s[$s]") if $CPAN::DEBUG;
- if ($s =~ m|/|) { # looks like a file
- $s = CPAN::Distribution->normalize($s);
- return $CPAN::META->instance('CPAN::Distribution',$s);
- # Distributions spring into existence, not expand
- } elsif ($s =~ m|^Bundle::|) {
- $self->local_bundles; # scanning so late for bundles seems
- # both attractive and crumpy: always
- # current state but easy to forget
- # somewhere
- return $self->expand('Bundle',$s);
- } else {
- return $self->expand('Module',$s)
- if $CPAN::META->exists('CPAN::Module',$s);
- }
- return;
-}
+=head2 CPAN::shell([$prompt, $command]) Starting Interactive Mode
-#-> sub CPAN::Shell::expand ;
-sub expand {
- my $self = shift;
- my($type,@args) = @_;
- CPAN->debug("type[$type]args[@args]") if $CPAN::DEBUG;
- my $class = "CPAN::$type";
- my $methods = ['id'];
- for my $meth (qw(name)) {
- next if $] < 5.00303; # no "can"
- next unless $class->can($meth);
- push @$methods, $meth;
- }
- $self->expand_by_method($class,$methods,@args);
-}
+Enter interactive mode by running
-sub expand_by_method {
- my $self = shift;
- my($class,$methods,@args) = @_;
- my($arg,@m);
- for $arg (@args) {
- my($regex,$command);
- if ($arg =~ m|^/(.*)/$|) {
- $regex = $1;
- } elsif ($arg =~ m/=/) {
- $command = 1;
- }
- my $obj;
- CPAN->debug(sprintf "class[%s]regex[%s]command[%s]",
- $class,
- defined $regex ? $regex : "UNDEFINED",
- defined $command ? $command : "UNDEFINED",
- ) if $CPAN::DEBUG;
- if (defined $regex) {
- for $obj (
- $CPAN::META->all_objects($class)
- ) {
- unless ($obj->id){
- # BUG, we got an empty object somewhere
- require Data::Dumper;
- CPAN->debug(sprintf(
- "Bug in CPAN: Empty id on obj[%s][%s]",
- $obj,
- Data::Dumper::Dumper($obj)
- )) if $CPAN::DEBUG;
- next;
- }
- for my $method (@$methods) {
- if ($obj->$method() =~ /$regex/i) {
- push @m, $obj;
- last;
- }
- }
- }
- } elsif ($command) {
- die "equal sign in command disabled (immature interface), ".
- "you can set
- ! \$CPAN::Shell::ADVANCED_QUERY=1
-to enable it. But please note, this is HIGHLY EXPERIMENTAL code
-that may go away anytime.\n"
- unless $ADVANCED_QUERY;
- my($method,$criterion) = $arg =~ /(.+?)=(.+)/;
- my($matchcrit) = $criterion =~ m/^~(.+)/;
- for my $self (
- sort
- {$a->id cmp $b->id}
- $CPAN::META->all_objects($class)
- ) {
- my $lhs = $self->$method() or next; # () for 5.00503
- if ($matchcrit) {
- push @m, $self if $lhs =~ m/$matchcrit/;
- } else {
- push @m, $self if $lhs eq $criterion;
- }
- }
- } else {
- my($xarg) = $arg;
- if ( $class eq 'CPAN::Bundle' ) {
- $xarg =~ s/^(Bundle::)?(.*)/Bundle::$2/;
- } elsif ($class eq "CPAN::Distribution") {
- $xarg = CPAN::Distribution->normalize($arg);
- } else {
- $xarg =~ s/:+/::/g;
- }
- if ($CPAN::META->exists($class,$xarg)) {
- $obj = $CPAN::META->instance($class,$xarg);
- } elsif ($CPAN::META->exists($class,$arg)) {
- $obj = $CPAN::META->instance($class,$arg);
- } else {
- next;
- }
- push @m, $obj;
- }
- }
- @m = sort {$a->id cmp $b->id} @m;
- if ( $CPAN::DEBUG ) {
- my $wantarray = wantarray;
- my $join_m = join ",", map {$_->id} @m;
- $self->debug("wantarray[$wantarray]join_m[$join_m]");
- }
- return wantarray ? @m : $m[0];
-}
+ perl -MCPAN -e shell
-#-> sub CPAN::Shell::format_result ;
-sub format_result {
- my($self) = shift;
- my($type,@args) = @_;
- @args = '/./' unless @args;
- my(@result) = $self->expand($type,@args);
- my $result = @result == 1 ?
- $result[0]->as_string :
- @result == 0 ?
- "No objects of type $type found for argument @args\n" :
- join("",
- (map {$_->as_glimpse} @result),
- scalar @result, " items found\n",
- );
- $result;
-}
+or
-#-> sub CPAN::Shell::report_fh ;
-{
- my $installation_report_fh;
- my $previously_noticed = 0;
-
- sub report_fh {
- return $installation_report_fh if $installation_report_fh;
- $installation_report_fh = File::Temp->new(
- template => 'cpan_install_XXXX',
- suffix => '.txt',
- unlink => 0,
- );
- unless ( $installation_report_fh ) {
- warn("Couldn't open installation report file; " .
- "no report file will be generated."
- ) unless $previously_noticed++;
- }
- }
-}
+ cpan
+which puts you into a readline interface. If C<Term::ReadKey> and
+either of C<Term::ReadLine::Perl> or C<Term::ReadLine::Gnu> are installed,
+history and command completion are supported.
-# The only reason for this method is currently to have a reliable
-# debugging utility that reveals which output is going through which
-# channel. No, I don't like the colors ;-)
+Once at the command line, type C<h> for one-page help
+screen; the rest should be self-explanatory.
-#-> sub CPAN::Shell::print_ornameted ;
-sub print_ornamented {
- my($self,$what,$ornament) = @_;
- my $longest = 0;
- return unless defined $what;
+The function call C<shell> takes two optional arguments: one the
+prompt, the second the default initial command line (the latter
+only works if a real ReadLine interface module is installed).
- local $| = 1; # Flush immediately
- if ( $CPAN::Be_Silent ) {
- print {report_fh()} $what;
- return;
- }
+The most common uses of the interactive modes are
- if ($CPAN::Config->{term_is_latin}){
- # courtesy jhi:
- $what
- =~ s{([\xC0-\xDF])([\x80-\xBF])}{chr(ord($1)<<6&0xC0|ord($2)&0x3F)}eg; #};
- }
- if ($PRINT_ORNAMENTING) {
- unless (defined &color) {
- if ($CPAN::META->has_inst("Term::ANSIColor")) {
- import Term::ANSIColor "color";
- } else {
- *color = sub { return "" };
- }
- }
- my $line;
- for $line (split /\n/, $what) {
- $longest = length($line) if length($line) > $longest;
- }
- my $sprintf = "%-" . $longest . "s";
- while ($what){
- $what =~ s/(.*\n?)//m;
- my $line = $1;
- last unless $line;
- my($nl) = chomp $line ? "\n" : "";
- # print "line[$line]ornament[$ornament]sprintf[$sprintf]\n";
- print color($ornament), sprintf($sprintf,$line), color("reset"), $nl;
- }
- } else {
- # chomp $what;
- # $what .= "\n"; # newlines unless $PRINT_ORNAMENTING
- print $what;
- }
-}
+=over 2
-sub myprint {
- my($self,$what) = @_;
+=item Searching for authors, bundles, distribution files and modules
- $self->print_ornamented($what, 'bold blue on_yellow');
-}
+There are corresponding one-letter commands C<a>, C<b>, C<d>, and C<m>
+for each of the four categories and another, C<i> for any of the
+mentioned four. Each of the four entities is implemented as a class
+with slightly differing methods for displaying an object.
-sub myexit {
- my($self,$what) = @_;
- $self->myprint($what);
- exit;
-}
+Arguments to these commands are either strings exactly matching
+the identification string of an object, or regular expressions
+matched case-insensitively against various attributes of the
+objects. The parser only recognizes a regular expression when you
+enclose it with slashes.
-sub mywarn {
- my($self,$what) = @_;
- $self->print_ornamented($what, 'bold red on_yellow');
-}
+The principle is that the number of objects found influences how an
+item is displayed. If the search finds one item, the result is
+displayed with the rather verbose method C<as_string>, but if
+more than one is found, each object is displayed with the terse method
+C<as_glimpse>.
+
+Examples:
+
+ cpan> m Acme::MetaSyntactic
+ Module id = Acme::MetaSyntactic
+ CPAN_USERID BOOK (Philippe Bruhat (BooK) <[...]>)
+ CPAN_VERSION 0.99
+ CPAN_FILE B/BO/BOOK/Acme-MetaSyntactic-0.99.tar.gz
+ UPLOAD_DATE 2006-11-06
+ MANPAGE Acme::MetaSyntactic - Themed metasyntactic variables names
+ INST_FILE /usr/local/lib/perl/5.10.0/Acme/MetaSyntactic.pm
+ INST_VERSION 0.99
+ cpan> a BOOK
+ Author id = BOOK
+ EMAIL [...]
+ FULLNAME Philippe Bruhat (BooK)
+ cpan> d BOOK/Acme-MetaSyntactic-0.99.tar.gz
+ Distribution id = B/BO/BOOK/Acme-MetaSyntactic-0.99.tar.gz
+ CPAN_USERID BOOK (Philippe Bruhat (BooK) <[...]>)
+ CONTAINSMODS Acme::MetaSyntactic Acme::MetaSyntactic::Alias [...]
+ UPLOAD_DATE 2006-11-06
+ cpan> m /lorem/
+ Module = Acme::MetaSyntactic::loremipsum (BOOK/Acme-MetaSyntactic-0.99.tar.gz)
+ Module Text::Lorem (ADEOLA/Text-Lorem-0.3.tar.gz)
+ Module Text::Lorem::More (RKRIMEN/Text-Lorem-More-0.12.tar.gz)
+ Module Text::Lorem::More::Source (RKRIMEN/Text-Lorem-More-0.12.tar.gz)
+ cpan> i /berlin/
+ Distribution BEATNIK/Filter-NumberLines-0.02.tar.gz
+ Module = DateTime::TimeZone::Europe::Berlin (DROLSKY/DateTime-TimeZone-0.7904.tar.gz)
+ Module Filter::NumberLines (BEATNIK/Filter-NumberLines-0.02.tar.gz)
+ Author [...]
+
+The examples illustrate several aspects: the first three queries
+target modules, authors, or distros directly and yield exactly one
+result. The last two use regular expressions and yield several
+results. The last one targets all of bundles, modules, authors, and
+distros simultaneously. When more than one result is available, they
+are printed in one-line format.
+
+=item C<get>, C<make>, C<test>, C<install>, C<clean> modules or distributions
-sub myconfess {
- my($self,$what) = @_;
- $self->print_ornamented($what, 'bold red on_white');
- Carp::confess "died";
-}
+These commands take any number of arguments and investigate what is
+necessary to perform the action. If the argument is a distribution
+file name (recognized by embedded slashes), it is processed. If it is
+a module, CPAN determines the distribution file in which this module
+is included and processes that, following any dependencies named in
+the module's META.yml or Makefile.PL (this behavior is controlled by
+the configuration parameter C<prerequisites_policy>.)
-sub mydie {
- my($self,$what) = @_;
- $self->print_ornamented($what, 'bold red on_white');
- die "\n";
-}
+C<get> downloads a distribution file and untars or unzips it, C<make>
+builds it, C<test> runs the test suite, and C<install> installs it.
-sub setup_output {
- return if -t STDOUT;
- my $odef = select STDERR;
- $| = 1;
- select STDOUT;
- $| = 1;
- select $odef;
-}
+Any C<make> or C<test> is run unconditionally. An
-#-> sub CPAN::Shell::rematein ;
-# RE-adme||MA-ke||TE-st||IN-stall
-sub rematein {
- my $self = shift;
- my($meth,@some) = @_;
- my @pragma;
- while($meth =~ /^(force|notest)$/) {
- push @pragma, $meth;
- $meth = shift @some or
- $CPAN::Frontend->mydie("Pragma $pragma[-1] used without method: ".
- "cannot continue");
- }
- setup_output();
- CPAN->debug("pragma[@pragma]meth[$meth]some[@some]") if $CPAN::DEBUG;
-
- # Here is the place to set "test_count" on all involved parties to
- # 0. We then can pass this counter on to the involved
- # distributions and those can refuse to test if test_count > X. In
- # the first stab at it we could use a 1 for "X".
-
- # But when do I reset the distributions to start with 0 again?
- # Jost suggested to have a random or cycling interaction ID that
- # we pass through. But the ID is something that is just left lying
- # around in addition to the counter, so I'd prefer to set the
- # counter to 0 now, and repeat at the end of the loop. But what
- # about dependencies? They appear later and are not reset, they
- # enter the queue but not its copy. How do they get a sensible
- # test_count?
-
- # construct the queue
- my($s,@s,@qcopy);
- STHING: foreach $s (@some) {
- my $obj;
- if (ref $s) {
- CPAN->debug("s is an object[$s]") if $CPAN::DEBUG;
- $obj = $s;
- } elsif ($s =~ m|^/|) { # looks like a regexp
- $CPAN::Frontend->mywarn("Sorry, $meth with a regular expression is ".
- "not supported\n");
- sleep 2;
- next;
- } elsif ($meth eq "ls") {
- $self->handle_ls(\@pragma,$s);
- next STHING;
- } else {
- CPAN->debug("calling expandany [$s]") if $CPAN::DEBUG;
- $obj = CPAN::Shell->expandany($s);
- }
- if (ref $obj) {
- $obj->color_cmd_tmps(0,1);
- CPAN::Queue->new($obj->id);
- push @qcopy, $obj;
- } elsif ($CPAN::META->exists('CPAN::Author',uc($s))) {
- $obj = $CPAN::META->instance('CPAN::Author',uc($s));
- if ($meth =~ /^(dump|ls)$/) {
- $obj->$meth();
- } else {
- $CPAN::Frontend->myprint(
- join "",
- "Don't be silly, you can't $meth ",
- $obj->fullname,
- " ;-)\n"
- );
- sleep 2;
- }
- } else {
- $CPAN::Frontend
- ->myprint(qq{Warning: Cannot $meth $s, }.
- qq{don\'t know what it is.
-Try the command
+ install <distribution_file>
- i /$s/
+is also run unconditionally. But for
-to find objects with matching identifiers.
-});
- sleep 2;
- }
- }
+ install <module>
- # queuerunner (please be warned: when I started to change the
- # queue to hold objects instead of names, I made one or two
- # mistakes and never found which. I reverted back instead)
- while ($s = CPAN::Queue->first) {
- my $obj;
- if (ref $s) {
- $obj = $s; # I do not believe, we would survive if this happened
- } else {
- $obj = CPAN::Shell->expandany($s);
- }
- for my $pragma (@pragma) {
- if ($pragma
- &&
- ($] < 5.00303 || $obj->can($pragma))){
- ### compatibility with 5.003
- $obj->$pragma($meth); # the pragma "force" in
- # "CPAN::Distribution" must know
- # what we are intending
- }
- }
- if ($]>=5.00303 && $obj->can('called_for')) {
- $obj->called_for($s);
- }
- CPAN->debug(
- qq{pragma[@pragma]meth[$meth]obj[$obj]as_string\[}.
- $obj->as_string.
- qq{\]}
- ) if $CPAN::DEBUG;
-
- if ($obj->$meth()){
- CPAN::Queue->delete($s);
- } else {
- CPAN->debug("failed");
- }
+CPAN checks whether an install is needed and prints
+I<module up to date> if the distribution file containing
+the module doesn't need updating.
- $obj->undelay;
- CPAN::Queue->delete_first($s);
- }
- for my $obj (@qcopy) {
- $obj->color_cmd_tmps(0,0);
- delete $obj->{incommandcolor};
- }
-}
+CPAN also keeps track of what it has done within the current session
+and doesn't try to build a package a second time regardless of whether it
+succeeded or not. It does not repeat a test run if the test
+has been run successfully before. Same for install runs.
-#-> sub CPAN::Shell::recent ;
-sub recent {
- my($self) = @_;
+The C<force> pragma may precede another command (currently: C<get>,
+C<make>, C<test>, or C<install>) to execute the command from scratch
+and attempt to continue past certain errors. See the section below on
+the C<force> and the C<fforce> pragma.
- CPAN::Distribution::_display_url( $self, $CPAN::Defaultrecent );
- return;
-}
+The C<notest> pragma skips the test part in the build
+process.
-{
- # set up the dispatching methods
- no strict "refs";
- for my $command (qw(
- clean
- cvs_import
- dump
- force
- get
- install
- look
- ls
- make
- notest
- perldoc
- readme
- test
- )) {
- *$command = sub { shift->rematein($command, @_); };
- }
-}
+Example:
-package CPAN::LWP::UserAgent;
-use strict;
+ cpan> notest install Tk
-sub config {
- return if $SETUPDONE;
- if ($CPAN::META->has_usable('LWP::UserAgent')) {
- require LWP::UserAgent;
- @ISA = qw(Exporter LWP::UserAgent);
- $SETUPDONE++;
- } else {
- $CPAN::Frontend->mywarn("LWP::UserAgent not available\n");
- }
-}
+A C<clean> command results in a
-sub get_basic_credentials {
- my($self, $realm, $uri, $proxy) = @_;
- return unless $proxy;
- if ($USER && $PASSWD) {
- } elsif (defined $CPAN::Config->{proxy_user} &&
- defined $CPAN::Config->{proxy_pass}) {
- $USER = $CPAN::Config->{proxy_user};
- $PASSWD = $CPAN::Config->{proxy_pass};
- } else {
- require ExtUtils::MakeMaker;
- ExtUtils::MakeMaker->import(qw(prompt));
- $USER = prompt("Proxy authentication needed!
- (Note: to permanently configure username and password run
- o conf proxy_user your_username
- o conf proxy_pass your_password
- )\nUsername:");
- if ($CPAN::META->has_inst("Term::ReadKey")) {
- Term::ReadKey::ReadMode("noecho");
- } else {
- $CPAN::Frontend->mywarn("Warning: Term::ReadKey seems not to be available, your password will be echoed to the terminal!\n");
- }
- $PASSWD = prompt("Password:");
- if ($CPAN::META->has_inst("Term::ReadKey")) {
- Term::ReadKey::ReadMode("restore");
- }
- $CPAN::Frontend->myprint("\n\n");
- }
- return($USER,$PASSWD);
-}
+ make clean
-# mirror(): Its purpose is to deal with proxy authentication. When we
-# call SUPER::mirror, we relly call the mirror method in
-# LWP::UserAgent. LWP::UserAgent will then call
-# $self->get_basic_credentials or some equivalent and this will be
-# $self->dispatched to our own get_basic_credentials method.
-
-# Our own get_basic_credentials sets $USER and $PASSWD, two globals.
-
-# 407 stands for HTTP_PROXY_AUTHENTICATION_REQUIRED. Which means
-# although we have gone through our get_basic_credentials, the proxy
-# server refuses to connect. This could be a case where the username or
-# password has changed in the meantime, so I'm trying once again without
-# $USER and $PASSWD to give the get_basic_credentials routine another
-# chance to set $USER and $PASSWD.
-
-# mirror(): Its purpose is to deal with proxy authentication. When we
-# call SUPER::mirror, we relly call the mirror method in
-# LWP::UserAgent. LWP::UserAgent will then call
-# $self->get_basic_credentials or some equivalent and this will be
-# $self->dispatched to our own get_basic_credentials method.
-
-# Our own get_basic_credentials sets $USER and $PASSWD, two globals.
-
-# 407 stands for HTTP_PROXY_AUTHENTICATION_REQUIRED. Which means
-# although we have gone through our get_basic_credentials, the proxy
-# server refuses to connect. This could be a case where the username or
-# password has changed in the meantime, so I'm trying once again without
-# $USER and $PASSWD to give the get_basic_credentials routine another
-# chance to set $USER and $PASSWD.
-
-sub mirror {
- my($self,$url,$aslocal) = @_;
- my $result = $self->SUPER::mirror($url,$aslocal);
- if ($result->code == 407) {
- undef $USER;
- undef $PASSWD;
- $result = $self->SUPER::mirror($url,$aslocal);
- }
- $result;
-}
+being executed within the distribution file's working directory.
-package CPAN::FTP;
-use strict;
+=item C<readme>, C<perldoc>, C<look> module or distribution
-#-> sub CPAN::FTP::ftp_get ;
-sub ftp_get {
- my($class,$host,$dir,$file,$target) = @_;
- $class->debug(
- qq[Going to fetch file [$file] from dir [$dir]
- on host [$host] as local [$target]\n]
- ) if $CPAN::DEBUG;
- my $ftp = Net::FTP->new($host);
- return 0 unless defined $ftp;
- $ftp->debug(1) if $CPAN::DEBUG{'FTP'} & $CPAN::DEBUG;
- $class->debug(qq[Going to login("anonymous","$Config::Config{cf_email}")]);
- unless ( $ftp->login("anonymous",$Config::Config{'cf_email'}) ){
- warn "Couldn't login on $host";
- return;
- }
- unless ( $ftp->cwd($dir) ){
- warn "Couldn't cwd $dir";
- return;
- }
- $ftp->binary;
- $class->debug(qq[Going to ->get("$file","$target")\n]) if $CPAN::DEBUG;
- unless ( $ftp->get($file,$target) ){
- warn "Couldn't fetch $file from $host\n";
- return;
- }
- $ftp->quit; # it's ok if this fails
- return 1;
-}
+C<readme> displays the README file of the associated distribution.
+C<Look> gets and untars (if not yet done) the distribution file,
+changes to the appropriate directory and opens a subshell process in
+that directory. C<perldoc> displays the module's pod documentation
+in html or plain text format.
-# If more accuracy is wanted/needed, Chris Leach sent me this patch...
-
- # > *** /install/perl/live/lib/CPAN.pm- Wed Sep 24 13:08:48 1997
- # > --- /tmp/cp Wed Sep 24 13:26:40 1997
- # > ***************
- # > *** 1562,1567 ****
- # > --- 1562,1580 ----
- # > return 1 if substr($url,0,4) eq "file";
- # > return 1 unless $url =~ m|://([^/]+)|;
- # > my $host = $1;
- # > + my $proxy = $CPAN::Config->{'http_proxy'} || $ENV{'http_proxy'};
- # > + if ($proxy) {
- # > + $proxy =~ m|://([^/:]+)|;
- # > + $proxy = $1;
- # > + my $noproxy = $CPAN::Config->{'no_proxy'} || $ENV{'no_proxy'};
- # > + if ($noproxy) {
- # > + if ($host !~ /$noproxy$/) {
- # > + $host = $proxy;
- # > + }
- # > + } else {
- # > + $host = $proxy;
- # > + }
- # > + }
- # > require Net::Ping;
- # > return 1 unless $Net::Ping::VERSION >= 2;
- # > my $p;
-
-
-#-> sub CPAN::FTP::localize ;
-sub localize {
- my($self,$file,$aslocal,$force) = @_;
- $force ||= 0;
- Carp::croak "Usage: ->localize(cpan_file,as_local_file[,$force])"
- unless defined $aslocal;
- $self->debug("file[$file] aslocal[$aslocal] force[$force]")
- if $CPAN::DEBUG;
-
- if ($^O eq 'MacOS') {
- # Comment by AK on 2000-09-03: Uniq short filenames would be
- # available in CHECKSUMS file
- my($name, $path) = File::Basename::fileparse($aslocal, '');
- if (length($name) > 31) {
- $name =~ s/(
- \.(
- readme(\.(gz|Z))? |
- (tar\.)?(gz|Z) |
- tgz |
- zip |
- pm\.(gz|Z)
- )
- )$//x;
- my $suf = $1;
- my $size = 31 - length($suf);
- while (length($name) > $size) {
- chop $name;
- }
- $name .= $suf;
- $aslocal = File::Spec->catfile($path, $name);
- }
- }
+=item C<ls> author
- if (-f $aslocal && -r _ && !($force & 1)){
- if (-s $aslocal) {
- return $aslocal;
- } else {
- # empty file from a previous unsuccessful attempt to download it
- unlink $aslocal or
- $CPAN::Frontend->mydie("Found a zero-length '$aslocal' that I could not remove.");
- }
- }
- my($restore) = 0;
- if (-f $aslocal){
- rename $aslocal, "$aslocal.bak";
- $restore++;
- }
+=item C<ls> globbing_expression
- my($aslocal_dir) = File::Basename::dirname($aslocal);
- File::Path::mkpath($aslocal_dir);
- $CPAN::Frontend->mywarn(qq{Warning: You are not allowed to write into }.
- qq{directory "$aslocal_dir".
- I\'ll continue, but if you encounter problems, they may be due
- to insufficient permissions.\n}) unless -w $aslocal_dir;
-
- # Inheritance is not easier to manage than a few if/else branches
- if ($CPAN::META->has_usable('LWP::UserAgent')) {
- unless ($Ua) {
- CPAN::LWP::UserAgent->config;
- eval {$Ua = CPAN::LWP::UserAgent->new;}; # Why is has_usable still not fit enough?
- if ($@) {
- $CPAN::Frontend->mywarn("CPAN::LWP::UserAgent->new dies with $@\n")
- if $CPAN::DEBUG;
- } else {
- my($var);
- $Ua->proxy('ftp', $var)
- if $var = $CPAN::Config->{ftp_proxy} || $ENV{ftp_proxy};
- $Ua->proxy('http', $var)
- if $var = $CPAN::Config->{http_proxy} || $ENV{http_proxy};
-
-
-# >>>>> On Wed, 13 Dec 2000 09:21:34 -0500, "Robison, Jonathon (J.M.)" <jrobiso2@visteon.com> said:
-#
-# > I note that although CPAN.pm can use proxies, it doesn't seem equipped to
-# > use ones that require basic autorization.
-#
-# > Example of when I use it manually in my own stuff:
-#
-# > $ua->proxy(['http','ftp'], http://my.proxy.server:83');
-# > $req->proxy_authorization_basic("username","password");
-# > $res = $ua->request($req);
-#
-
- $Ua->no_proxy($var)
- if $var = $CPAN::Config->{no_proxy} || $ENV{no_proxy};
- }
- }
- }
- for my $prx (qw(ftp_proxy http_proxy no_proxy)) {
- $ENV{$prx} = $CPAN::Config->{$prx} if $CPAN::Config->{$prx};
- }
+The first form lists all distribution files in and below an author's
+CPAN directory as stored in the CHECKUMS files distributed on
+CPAN. The listing recurses into subdirectories.
- # Try the list of urls for each single object. We keep a record
- # where we did get a file from
- my(@reordered,$last);
- $CPAN::Config->{urllist} ||= [];
- unless (ref $CPAN::Config->{urllist} eq 'ARRAY') {
- warn "Malformed urllist; ignoring. Configuration file corrupt?\n";
- }
- $last = $#{$CPAN::Config->{urllist}};
- if ($force & 2) { # local cpans probably out of date, don't reorder
- @reordered = (0..$last);
- } else {
- @reordered =
- sort {
- (substr($CPAN::Config->{urllist}[$b],0,4) eq "file")
- <=>
- (substr($CPAN::Config->{urllist}[$a],0,4) eq "file")
- or
- defined($Thesite)
- and
- ($b == $Thesite)
- <=>
- ($a == $Thesite)
- } 0..$last;
- }
- my(@levels);
- if ($Themethod) {
- @levels = ($Themethod, grep {$_ ne $Themethod} qw/easy hard hardest/);
- } else {
- @levels = qw/easy hard hardest/;
- }
- @levels = qw/easy/ if $^O eq 'MacOS';
- my($levelno);
- for $levelno (0..$#levels) {
- my $level = $levels[$levelno];
- my $method = "host$level";
- my @host_seq = $level eq "easy" ?
- @reordered : 0..$last; # reordered has CDROM up front
- @host_seq = (0) unless @host_seq;
- my $ret = $self->$method(\@host_seq,$file,$aslocal);
- if ($ret) {
- $Themethod = $level;
- my $now = time;
- # utime $now, $now, $aslocal; # too bad, if we do that, we
- # might alter a local mirror
- $self->debug("level[$level]") if $CPAN::DEBUG;
- return $ret;
- } else {
- unlink $aslocal;
- last if $CPAN::Signal; # need to cleanup
- }
- }
- unless ($CPAN::Signal) {
- my(@mess);
- push @mess,
- qq{Please check, if the URLs I found in your configuration file \(}.
- join(", ", @{$CPAN::Config->{urllist}}).
- qq{\) are valid. The urllist can be edited.},
- qq{E.g. with 'o conf urllist push ftp://myurl/'};
- $CPAN::Frontend->myprint(Text::Wrap::wrap("","",@mess). "\n\n");
- sleep 2;
- $CPAN::Frontend->myprint("Could not fetch $file\n");
- }
- if ($restore) {
- rename "$aslocal.bak", $aslocal;
- $CPAN::Frontend->myprint("Trying to get away with old file:\n" .
- $self->ls($aslocal));
- return $aslocal;
- }
- return;
-}
+The second form limits or expands the output with shell
+globbing as in the following examples:
-sub hosteasy {
- my($self,$host_seq,$file,$aslocal) = @_;
- my($i);
- HOSTEASY: for $i (@$host_seq) {
- my $url = $CPAN::Config->{urllist}[$i] || $CPAN::Defaultsite;
- $url .= "/" unless substr($url,-1) eq "/";
- $url .= $file;
- $self->debug("localizing perlish[$url]") if $CPAN::DEBUG;
- if ($url =~ /^file:/) {
- my $l;
- if ($CPAN::META->has_inst('URI::URL')) {
- my $u = URI::URL->new($url);
- $l = $u->path;
- } else { # works only on Unix, is poorly constructed, but
- # hopefully better than nothing.
- # RFC 1738 says fileurl BNF is
- # fileurl = "file://" [ host | "localhost" ] "/" fpath
- # Thanks to "Mark D. Baushke" <mdb@cisco.com> for
- # the code
- ($l = $url) =~ s|^file://[^/]*/|/|; # discard the host part
- $l =~ s|^file:||; # assume they
- # meant
- # file://localhost
- $l =~ s|^/||s unless -f $l; # e.g. /P:
- $self->debug("without URI::URL we try local file $l") if $CPAN::DEBUG;
- }
- if ( -f $l && -r _) {
- $Thesite = $i;
- return $l;
- }
- # Maybe mirror has compressed it?
- if (-f "$l.gz") {
- $self->debug("found compressed $l.gz") if $CPAN::DEBUG;
- CPAN::Tarzip->new("$l.gz")->gunzip($aslocal);
- if ( -f $aslocal) {
- $Thesite = $i;
- return $aslocal;
- }
- }
- }
- if ($CPAN::META->has_usable('LWP')) {
- $CPAN::Frontend->myprint("Fetching with LWP:
- $url
-");
- unless ($Ua) {
- CPAN::LWP::UserAgent->config;
- eval { $Ua = CPAN::LWP::UserAgent->new; };
- if ($@) {
- $CPAN::Frontend->mywarn("CPAN::LWP::UserAgent->new dies with $@\n");
- }
- }
- my $res = $Ua->mirror($url, $aslocal);
- if ($res->is_success) {
- $Thesite = $i;
- my $now = time;
- utime $now, $now, $aslocal; # download time is more
- # important than upload time
- return $aslocal;
- } elsif ($url !~ /\.gz(?!\n)\Z/) {
- my $gzurl = "$url.gz";
- $CPAN::Frontend->myprint("Fetching with LWP:
- $gzurl
-");
- $res = $Ua->mirror($gzurl, "$aslocal.gz");
- if ($res->is_success &&
- CPAN::Tarzip->new("$aslocal.gz")->gunzip($aslocal)
- ) {
- $Thesite = $i;
- return $aslocal;
- }
- } else {
- $CPAN::Frontend->myprint(sprintf(
- "LWP failed with code[%s] message[%s]\n",
- $res->code,
- $res->message,
- ));
- # Alan Burlison informed me that in firewall environments
- # Net::FTP can still succeed where LWP fails. So we do not
- # skip Net::FTP anymore when LWP is available.
- }
- } else {
- $CPAN::Frontend->myprint("LWP not available\n");
- }
- return if $CPAN::Signal;
- if ($url =~ m|^ftp://(.*?)/(.*)/(.*)|) {
- # that's the nice and easy way thanks to Graham
- my($host,$dir,$getfile) = ($1,$2,$3);
- if ($CPAN::META->has_usable('Net::FTP')) {
- $dir =~ s|/+|/|g;
- $CPAN::Frontend->myprint("Fetching with Net::FTP:
- $url
-");
- $self->debug("getfile[$getfile]dir[$dir]host[$host]" .
- "aslocal[$aslocal]") if $CPAN::DEBUG;
- if (CPAN::FTP->ftp_get($host,$dir,$getfile,$aslocal)) {
- $Thesite = $i;
- return $aslocal;
- }
- if ($aslocal !~ /\.gz(?!\n)\Z/) {
- my $gz = "$aslocal.gz";
- $CPAN::Frontend->myprint("Fetching with Net::FTP
- $url.gz
-");
- if (CPAN::FTP->ftp_get($host,
- $dir,
- "$getfile.gz",
- $gz) &&
- CPAN::Tarzip->new($gz)->gunzip($aslocal)
- ){
- $Thesite = $i;
- return $aslocal;
- }
- }
- # next HOSTEASY;
- }
- }
- return if $CPAN::Signal;
- }
-}
+ ls JV/make*
+ ls GSAR/*make*
+ ls */*make*
-sub hosthard {
- my($self,$host_seq,$file,$aslocal) = @_;
-
- # Came back if Net::FTP couldn't establish connection (or
- # failed otherwise) Maybe they are behind a firewall, but they
- # gave us a socksified (or other) ftp program...
-
- my($i);
- my($devnull) = $CPAN::Config->{devnull} || "";
- # < /dev/null ";
- my($aslocal_dir) = File::Basename::dirname($aslocal);
- File::Path::mkpath($aslocal_dir);
- HOSTHARD: for $i (@$host_seq) {
- my $url = $CPAN::Config->{urllist}[$i] || $CPAN::Defaultsite;
- $url .= "/" unless substr($url,-1) eq "/";
- $url .= $file;
- my($proto,$host,$dir,$getfile);
-
- # Courtesy Mark Conty mark_conty@cargill.com change from
- # if ($url =~ m|^ftp://(.*?)/(.*)/(.*)|) {
- # to
- if ($url =~ m|^([^:]+)://(.*?)/(.*)/(.*)|) {
- # proto not yet used
- ($proto,$host,$dir,$getfile) = ($1,$2,$3,$4);
- } else {
- next HOSTHARD; # who said, we could ftp anything except ftp?
- }
- next HOSTHARD if $proto eq "file"; # file URLs would have had
- # success above. Likely a bogus URL
-
- $self->debug("localizing funkyftpwise[$url]") if $CPAN::DEBUG;
-
- # Try the most capable first and leave ncftp* for last as it only
- # does FTP.
- for my $f (qw(curl wget lynx ncftpget ncftp)) {
- my $funkyftp = $CPAN::Config->{$f};
- next unless defined $funkyftp;
- next if $funkyftp =~ /^\s*$/;
-
- my($asl_ungz, $asl_gz);
- ($asl_ungz = $aslocal) =~ s/\.gz//;
- $asl_gz = "$asl_ungz.gz";
-
- my($src_switch) = "";
- my($chdir) = "";
- my($stdout_redir) = " > $asl_ungz";
- if ($f eq "lynx"){
- $src_switch = " -source";
- } elsif ($f eq "ncftp"){
- $src_switch = " -c";
- } elsif ($f eq "wget"){
- $src_switch = " -O $asl_ungz";
- $stdout_redir = "";
- } elsif ($f eq 'curl'){
- $src_switch = ' -L';
- }
-
- if ($f eq "ncftpget"){
- $chdir = "cd $aslocal_dir && ";
- $stdout_redir = "";
- }
- $CPAN::Frontend->myprint(
- qq[
-Trying with "$funkyftp$src_switch" to get
- $url
-]);
- my($system) =
- "$chdir$funkyftp$src_switch \"$url\" $devnull$stdout_redir";
- $self->debug("system[$system]") if $CPAN::DEBUG;
- my($wstatus);
- if (($wstatus = system($system)) == 0
- &&
- ($f eq "lynx" ?
- -s $asl_ungz # lynx returns 0 when it fails somewhere
- : 1
- )
- ) {
- if (-s $aslocal) {
- # Looks good
- } elsif ($asl_ungz ne $aslocal) {
- # test gzip integrity
- if (CPAN::Tarzip->new($asl_ungz)->gtest) {
- # e.g. foo.tar is gzipped --> foo.tar.gz
- rename $asl_ungz, $aslocal;
- } else {
- CPAN::Tarzip->new($asl_gz)->gzip($asl_ungz);
- }
- }
- $Thesite = $i;
- return $aslocal;
- } elsif ($url !~ /\.gz(?!\n)\Z/) {
- unlink $asl_ungz if
- -f $asl_ungz && -s _ == 0;
- my $gz = "$aslocal.gz";
- my $gzurl = "$url.gz";
- $CPAN::Frontend->myprint(
- qq[
-Trying with "$funkyftp$src_switch" to get
- $url.gz
-]);
- my($system) = "$funkyftp$src_switch \"$url.gz\" $devnull > $asl_gz";
- $self->debug("system[$system]") if $CPAN::DEBUG;
- my($wstatus);
- if (($wstatus = system($system)) == 0
- &&
- -s $asl_gz
- ) {
- # test gzip integrity
- my $ct = CPAN::Tarzip->new($asl_gz);
- if ($ct->gtest) {
- $ct->gunzip($aslocal);
- } else {
- # somebody uncompressed file for us?
- rename $asl_ungz, $aslocal;
- }
- $Thesite = $i;
- return $aslocal;
- } else {
- unlink $asl_gz if -f $asl_gz;
- }
- } else {
- my $estatus = $wstatus >> 8;
- my $size = -f $aslocal ?
- ", left\n$aslocal with size ".-s _ :
- "\nWarning: expected file [$aslocal] doesn't exist";
- $CPAN::Frontend->myprint(qq{
-System call "$system"
-returned status $estatus (wstat $wstatus)$size
-});
- }
- return if $CPAN::Signal;
- } # transfer programs
- } # host
-}
+The last example is very slow and outputs extra progress indicators
+that break the alignment of the result.
-sub hosthardest {
- my($self,$host_seq,$file,$aslocal) = @_;
-
- my($i);
- my($aslocal_dir) = File::Basename::dirname($aslocal);
- File::Path::mkpath($aslocal_dir);
- my $ftpbin = $CPAN::Config->{ftp};
- HOSTHARDEST: for $i (@$host_seq) {
- unless (length $ftpbin && MM->maybe_command($ftpbin)) {
- $CPAN::Frontend->myprint("No external ftp command available\n\n");
- last HOSTHARDEST;
- }
- my $url = $CPAN::Config->{urllist}[$i] || $CPAN::Defaultsite;
- $url .= "/" unless substr($url,-1) eq "/";
- $url .= $file;
- $self->debug("localizing ftpwise[$url]") if $CPAN::DEBUG;
- unless ($url =~ m|^ftp://(.*?)/(.*)/(.*)|) {
- next;
- }
- my($host,$dir,$getfile) = ($1,$2,$3);
- my $timestamp = 0;
- my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,
- $ctime,$blksize,$blocks) = stat($aslocal);
- $timestamp = $mtime ||= 0;
- my($netrc) = CPAN::FTP::netrc->new;
- my($netrcfile) = $netrc->netrc;
- my($verbose) = $CPAN::DEBUG{'FTP'} & $CPAN::DEBUG ? " -v" : "";
- my $targetfile = File::Basename::basename($aslocal);
- my(@dialog);
- push(
- @dialog,
- "lcd $aslocal_dir",
- "cd /",
- map("cd $_", split /\//, $dir), # RFC 1738
- "bin",
- "get $getfile $targetfile",
- "quit"
- );
- if (! $netrcfile) {
- CPAN->debug("No ~/.netrc file found") if $CPAN::DEBUG;
- } elsif ($netrc->hasdefault || $netrc->contains($host)) {
- CPAN->debug(sprintf("hasdef[%d]cont($host)[%d]",
- $netrc->hasdefault,
- $netrc->contains($host))) if $CPAN::DEBUG;
- if ($netrc->protected) {
- $CPAN::Frontend->myprint(qq{
- Trying with external ftp to get
- $url
- As this requires some features that are not thoroughly tested, we\'re
- not sure, that we get it right....
+Note that globbing only lists directories explicitly asked for, for
+example FOO/* will not list FOO/bar/Acme-Sthg-n.nn.tar.gz. This may be
+regarded as a bug that may be changed in some future version.
-}
- );
- $self->talk_ftp("$ftpbin$verbose $host",
- @dialog);
- ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
- $atime,$mtime,$ctime,$blksize,$blocks) = stat($aslocal);
- $mtime ||= 0;
- if ($mtime > $timestamp) {
- $CPAN::Frontend->myprint("GOT $aslocal\n");
- $Thesite = $i;
- return $aslocal;
- } else {
- $CPAN::Frontend->myprint("Hmm... Still failed!\n");
- }
- return if $CPAN::Signal;
- } else {
- $CPAN::Frontend->mywarn(qq{Your $netrcfile is not }.
- qq{correctly protected.\n});
- }
- } else {
- $CPAN::Frontend->mywarn("Your ~/.netrc neither contains $host
- nor does it have a default entry\n");
- }
-
- # OK, they don't have a valid ~/.netrc. Use 'ftp -n'
- # then and login manually to host, using e-mail as
- # password.
- $CPAN::Frontend->myprint(qq{Issuing "$ftpbin$verbose -n"\n});
- unshift(
- @dialog,
- "open $host",
- "user anonymous $Config::Config{'cf_email'}"
- );
- $self->talk_ftp("$ftpbin$verbose -n", @dialog);
- ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
- $atime,$mtime,$ctime,$blksize,$blocks) = stat($aslocal);
- $mtime ||= 0;
- if ($mtime > $timestamp) {
- $CPAN::Frontend->myprint("GOT $aslocal\n");
- $Thesite = $i;
- return $aslocal;
- } else {
- $CPAN::Frontend->myprint("Bad luck... Still failed!\n");
- }
- return if $CPAN::Signal;
- $CPAN::Frontend->myprint("Can't access URL $url.\n\n");
- sleep 2;
- } # host
-}
+=item C<failed>
-sub talk_ftp {
- my($self,$command,@dialog) = @_;
- my $fh = FileHandle->new;
- $fh->open("|$command") or die "Couldn't open ftp: $!";
- foreach (@dialog) { $fh->print("$_\n") }
- $fh->close; # Wait for process to complete
- my $wstatus = $?;
- my $estatus = $wstatus >> 8;
- $CPAN::Frontend->myprint(qq{
-Subprocess "|$command"
- returned status $estatus (wstat $wstatus)
-}) if $wstatus;
-}
+The C<failed> command reports all distributions that failed on one of
+C<make>, C<test> or C<install> for some reason in the currently
+running shell session.
-# find2perl needs modularization, too, all the following is stolen
-# from there
-# CPAN::FTP::ls
-sub ls {
- my($self,$name) = @_;
- my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$sizemm,
- $atime,$mtime,$ctime,$blksize,$blocks) = lstat($name);
+=item Persistence between sessions
- my($perms,%user,%group);
- my $pname = $name;
+If the C<YAML> or the C<YAML::Syck> module is installed a record of
+the internal state of all modules is written to disk after each step.
+The files contain a signature of the currently running perl version
+for later perusal.
- if ($blocks) {
- $blocks = int(($blocks + 1) / 2);
- }
- else {
- $blocks = int(($sizemm + 1023) / 1024);
- }
+If the configurations variable C<build_dir_reuse> is set to a true
+value, then CPAN.pm reads the collected YAML files. If the stored
+signature matches the currently running perl, the stored state is
+loaded into memory such that persistence between sessions
+is effectively established.
- if (-f _) { $perms = '-'; }
- elsif (-d _) { $perms = 'd'; }
- elsif (-c _) { $perms = 'c'; $sizemm = &sizemm; }
- elsif (-b _) { $perms = 'b'; $sizemm = &sizemm; }
- elsif (-p _) { $perms = 'p'; }
- elsif (-S _) { $perms = 's'; }
- else { $perms = 'l'; $pname .= ' -> ' . readlink($_); }
-
- my(@rwx) = ('---','--x','-w-','-wx','r--','r-x','rw-','rwx');
- my(@moname) = qw(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec);
- my $tmpmode = $mode;
- my $tmp = $rwx[$tmpmode & 7];
- $tmpmode >>= 3;
- $tmp = $rwx[$tmpmode & 7] . $tmp;
- $tmpmode >>= 3;
- $tmp = $rwx[$tmpmode & 7] . $tmp;
- substr($tmp,2,1) =~ tr/-x/Ss/ if -u _;
- substr($tmp,5,1) =~ tr/-x/Ss/ if -g _;
- substr($tmp,8,1) =~ tr/-x/Tt/ if -k _;
- $perms .= $tmp;
-
- my $user = $user{$uid} || $uid; # too lazy to implement lookup
- my $group = $group{$gid} || $gid;
-
- my($sec,$min,$hour,$mday,$mon,$year) = localtime($mtime);
- my($timeyear);
- my($moname) = $moname[$mon];
- if (-M _ > 365.25 / 2) {
- $timeyear = $year + 1900;
- }
- else {
- $timeyear = sprintf("%02d:%02d", $hour, $min);
- }
+=item The C<force> and the C<fforce> pragma
- sprintf "%5lu %4ld %-10s %2d %-8s %-8s %8s %s %2d %5s %s\n",
- $ino,
- $blocks,
- $perms,
- $nlink,
- $user,
- $group,
- $sizemm,
- $moname,
- $mday,
- $timeyear,
- $pname;
-}
+To speed things up in complex installation scenarios, CPAN.pm keeps
+track of what it has already done and refuses to do some things a
+second time. A C<get>, a C<make>, and an C<install> are not repeated.
+A C<test> is repeated only if the previous test was unsuccessful. The
+diagnostic message when CPAN.pm refuses to do something a second time
+is one of I<Has already been >C<unwrapped|made|tested successfully> or
+something similar. Another situation where CPAN refuses to act is an
+C<install> if the corresponding C<test> was not successful.
-package CPAN::FTP::netrc;
-use strict;
+In all these cases, the user can override this stubborn behaviour by
+prepending the command with the word force, for example:
-sub new {
- my($class) = @_;
- my $file = File::Spec->catfile($ENV{HOME},".netrc");
-
- my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
- $atime,$mtime,$ctime,$blksize,$blocks)
- = stat($file);
- $mode ||= 0;
- my $protected = 0;
-
- my($fh,@machines,$hasdefault);
- $hasdefault = 0;
- $fh = FileHandle->new or die "Could not create a filehandle";
-
- if($fh->open($file)){
- $protected = ($mode & 077) == 0;
- local($/) = "";
- NETRC: while (<$fh>) {
- my(@tokens) = split " ", $_;
- TOKEN: while (@tokens) {
- my($t) = shift @tokens;
- if ($t eq "default"){
- $hasdefault++;
- last NETRC;
- }
- last TOKEN if $t eq "macdef";
- if ($t eq "machine") {
- push @machines, shift @tokens;
- }
- }
- }
- } else {
- $file = $hasdefault = $protected = "";
- }
+ cpan> force get Foo
+ cpan> force make AUTHOR/Bar-3.14.tar.gz
+ cpan> force test Baz
+ cpan> force install Acme::Meta
- bless {
- 'mach' => [@machines],
- 'netrc' => $file,
- 'hasdefault' => $hasdefault,
- 'protected' => $protected,
- }, $class;
-}
+Each I<forced> command is executed with the corresponding part of its
+memory erased.
-# CPAN::FTP::hasdefault;
-sub hasdefault { shift->{'hasdefault'} }
-sub netrc { shift->{'netrc'} }
-sub protected { shift->{'protected'} }
-sub contains {
- my($self,$mach) = @_;
- for ( @{$self->{'mach'}} ) {
- return 1 if $_ eq $mach;
- }
- return 0;
-}
+The C<fforce> pragma is a variant that emulates a C<force get> which
+erases the entire memory followed by the action specified, effectively
+restarting the whole get/make/test/install procedure from scratch.
-package CPAN::Complete;
-use strict;
+=item Lockfile
-sub gnu_cpl {
- my($text, $line, $start, $end) = @_;
- my(@perlret) = cpl($text, $line, $start);
- # find longest common match. Can anybody show me how to peruse
- # T::R::Gnu to have this done automatically? Seems expensive.
- return () unless @perlret;
- my($newtext) = $text;
- for (my $i = length($text)+1;;$i++) {
- last unless length($perlret[0]) && length($perlret[0]) >= $i;
- my $try = substr($perlret[0],0,$i);
- my @tries = grep {substr($_,0,$i) eq $try} @perlret;
- # warn "try[$try]tries[@tries]";
- if (@tries == @perlret) {
- $newtext = $try;
- } else {
- last;
- }
- }
- ($newtext,@perlret);
-}
+Interactive sessions maintain a lockfile, by default C<~/.cpan/.lock>.
+Batch jobs can run without a lockfile and not disturb each other.
-#-> sub CPAN::Complete::cpl ;
-sub cpl {
- my($word,$line,$pos) = @_;
- $word ||= "";
- $line ||= "";
- $pos ||= 0;
- CPAN->debug("word [$word] line[$line] pos[$pos]") if $CPAN::DEBUG;
- $line =~ s/^\s*//;
- if ($line =~ s/^(force\s*)//) {
- $pos -= length($1);
- }
- my @return;
- if ($pos == 0) {
- @return = grep /^$word/, @CPAN::Complete::COMMANDS;
- } elsif ( $line !~ /^[\!abcdghimorutl]/ ) {
- @return = ();
- } elsif ($line =~ /^(a|ls)\s/) {
- @return = cplx('CPAN::Author',uc($word));
- } elsif ($line =~ /^b\s/) {
- CPAN::Shell->local_bundles;
- @return = cplx('CPAN::Bundle',$word);
- } elsif ($line =~ /^d\s/) {
- @return = cplx('CPAN::Distribution',$word);
- } elsif ($line =~ m/^(
- [mru]|make|clean|dump|get|test|install|readme|look|cvs_import|perldoc|recent
- )\s/x ) {
- if ($word =~ /^Bundle::/) {
- CPAN::Shell->local_bundles;
- }
- @return = (cplx('CPAN::Module',$word),cplx('CPAN::Bundle',$word));
- } elsif ($line =~ /^i\s/) {
- @return = cpl_any($word);
- } elsif ($line =~ /^reload\s/) {
- @return = cpl_reload($word,$line,$pos);
- } elsif ($line =~ /^o\s/) {
- @return = cpl_option($word,$line,$pos);
- } elsif ($line =~ m/^\S+\s/ ) {
- # fallback for future commands and what we have forgotten above
- @return = (cplx('CPAN::Module',$word),cplx('CPAN::Bundle',$word));
- } else {
- @return = ();
- }
- return @return;
-}
+The shell offers to run in I<downgraded mode> when another process is
+holding the lockfile. This is an experimental feature that is not yet
+tested very well. This second shell then does not write the history
+file, does not use the metadata file, and has a different prompt.
-#-> sub CPAN::Complete::cplx ;
-sub cplx {
- my($class, $word) = @_;
- # I believed for many years that this was sorted, today I
- # realized, it wasn't sorted anymore. Now (rev 1.301 / v 1.55) I
- # make it sorted again. Maybe sort was dropped when GNU-readline
- # support came in? The RCS file is difficult to read on that:-(
- sort grep /^\Q$word\E/, map { $_->id } $CPAN::META->all_objects($class);
-}
+=item Signals
-#-> sub CPAN::Complete::cpl_any ;
-sub cpl_any {
- my($word) = shift;
- return (
- cplx('CPAN::Author',$word),
- cplx('CPAN::Bundle',$word),
- cplx('CPAN::Distribution',$word),
- cplx('CPAN::Module',$word),
- );
-}
+CPAN.pm installs signal handlers for SIGINT and SIGTERM. While you are
+in the cpan-shell, it is intended that you can press C<^C> anytime and
+return to the cpan-shell prompt. A SIGTERM will cause the cpan-shell
+to clean up and leave the shell loop. You can emulate the effect of a
+SIGTERM by sending two consecutive SIGINTs, which usually means by
+pressing C<^C> twice.
-#-> sub CPAN::Complete::cpl_reload ;
-sub cpl_reload {
- my($word,$line,$pos) = @_;
- $word ||= "";
- my(@words) = split " ", $line;
- CPAN->debug("word[$word] line[$line] pos[$pos]") if $CPAN::DEBUG;
- my(@ok) = qw(cpan index);
- return @ok if @words == 1;
- return grep /^\Q$word\E/, @ok if @words == 2 && $word;
-}
-
-#-> sub CPAN::Complete::cpl_option ;
-sub cpl_option {
- my($word,$line,$pos) = @_;
- $word ||= "";
- my(@words) = split " ", $line;
- CPAN->debug("word[$word] line[$line] pos[$pos]") if $CPAN::DEBUG;
- my(@ok) = qw(conf debug);
- return @ok if @words == 1;
- return grep /^\Q$word\E/, @ok if @words == 2 && length($word);
- if (0) {
- } elsif ($words[1] eq 'index') {
- return ();
- } elsif ($words[1] eq 'conf') {
- return CPAN::HandleConfig::cpl(@_);
- } elsif ($words[1] eq 'debug') {
- return sort grep /^\Q$word\E/,
- sort keys %CPAN::DEBUG, 'all';
- }
-}
-
-package CPAN::Index;
-use strict;
-
-#-> sub CPAN::Index::force_reload ;
-sub force_reload {
- my($class) = @_;
- $CPAN::Index::LAST_TIME = 0;
- $class->reload(1);
-}
-
-#-> sub CPAN::Index::reload ;
-sub reload {
- my($cl,$force) = @_;
- my $time = time;
-
- # XXX check if a newer one is available. (We currently read it
- # from time to time)
- for ($CPAN::Config->{index_expire}) {
- $_ = 0.001 unless $_ && $_ > 0.001;
- }
- unless (1 || $CPAN::Have_warned->{readmetadatacache}++) {
- # debug here when CPAN doesn't seem to read the Metadata
- require Carp;
- Carp::cluck("META-PROTOCOL[$CPAN::META->{PROTOCOL}]");
- }
- unless ($CPAN::META->{PROTOCOL}) {
- $cl->read_metadata_cache;
- $CPAN::META->{PROTOCOL} ||= "1.0";
- }
- if ( $CPAN::META->{PROTOCOL} < PROTOCOL ) {
- # warn "Setting last_time to 0";
- $LAST_TIME = 0; # No warning necessary
- }
- return if $LAST_TIME + $CPAN::Config->{index_expire}*86400 > $time
- and ! $force;
- if (0) {
- # IFF we are developing, it helps to wipe out the memory
- # between reloads, otherwise it is not what a user expects.
- undef $CPAN::META; # Neue Gruendlichkeit since v1.52(r1.274)
- $CPAN::META = CPAN->new;
- }
- {
- my($debug,$t2);
- local $LAST_TIME = $time;
- local $CPAN::META->{PROTOCOL} = PROTOCOL;
-
- my $needshort = $^O eq "dos";
-
- $cl->rd_authindex($cl
- ->reload_x(
- "authors/01mailrc.txt.gz",
- $needshort ?
- File::Spec->catfile('authors', '01mailrc.gz') :
- File::Spec->catfile('authors', '01mailrc.txt.gz'),
- $force));
- $t2 = time;
- $debug = "timing reading 01[".($t2 - $time)."]";
- $time = $t2;
- return if $CPAN::Signal; # this is sometimes lengthy
- $cl->rd_modpacks($cl
- ->reload_x(
- "modules/02packages.details.txt.gz",
- $needshort ?
- File::Spec->catfile('modules', '02packag.gz') :
- File::Spec->catfile('modules', '02packages.details.txt.gz'),
- $force));
- $t2 = time;
- $debug .= "02[".($t2 - $time)."]";
- $time = $t2;
- return if $CPAN::Signal; # this is sometimes lengthy
- $cl->rd_modlist($cl
- ->reload_x(
- "modules/03modlist.data.gz",
- $needshort ?
- File::Spec->catfile('modules', '03mlist.gz') :
- File::Spec->catfile('modules', '03modlist.data.gz'),
- $force));
- $cl->write_metadata_cache;
- $t2 = time;
- $debug .= "03[".($t2 - $time)."]";
- $time = $t2;
- CPAN->debug($debug) if $CPAN::DEBUG;
- }
- $LAST_TIME = $time;
- $CPAN::META->{PROTOCOL} = PROTOCOL;
-}
-
-#-> sub CPAN::Index::reload_x ;
-sub reload_x {
- my($cl,$wanted,$localname,$force) = @_;
- $force |= 2; # means we're dealing with an index here
- CPAN::HandleConfig->load; # we should guarantee loading wherever we rely
- # on Config XXX
- $localname ||= $wanted;
- my $abs_wanted = File::Spec->catfile($CPAN::Config->{'keep_source_where'},
- $localname);
- if (
- -f $abs_wanted &&
- -M $abs_wanted < $CPAN::Config->{'index_expire'} &&
- !($force & 1)
- ) {
- my $s = $CPAN::Config->{'index_expire'} == 1 ? "" : "s";
- $cl->debug(qq{$abs_wanted younger than $CPAN::Config->{'index_expire'} }.
- qq{day$s. I\'ll use that.});
- return $abs_wanted;
- } else {
- $force |= 1; # means we're quite serious about it.
- }
- return CPAN::FTP->localize($wanted,$abs_wanted,$force);
-}
-
-#-> sub CPAN::Index::rd_authindex ;
-sub rd_authindex {
- my($cl, $index_target) = @_;
- my @lines;
- return unless defined $index_target;
- $CPAN::Frontend->myprint("Going to read $index_target\n");
- local(*FH);
- tie *FH, 'CPAN::Tarzip', $index_target;
- local($/) = "\n";
- local($_);
- push @lines, split /\012/ while <FH>;
- foreach (@lines) {
- my($userid,$fullname,$email) =
- m/alias\s+(\S+)\s+\"([^\"\<]+)\s+\<([^\>]+)\>\"/;
- next unless $userid && $fullname && $email;
-
- # instantiate an author object
- my $userobj = $CPAN::META->instance('CPAN::Author',$userid);
- $userobj->set('FULLNAME' => $fullname, 'EMAIL' => $email);
- return if $CPAN::Signal;
- }
-}
-
-sub userid {
- my($self,$dist) = @_;
- $dist = $self->{'id'} unless defined $dist;
- my($ret) = $dist =~ m|(?:\w/\w\w/)?([^/]+)/|;
- $ret;
-}
-
-#-> sub CPAN::Index::rd_modpacks ;
-sub rd_modpacks {
- my($self, $index_target) = @_;
- my @lines;
- return unless defined $index_target;
- $CPAN::Frontend->myprint("Going to read $index_target\n");
- my $fh = CPAN::Tarzip->TIEHANDLE($index_target);
- local($/) = "\n";
- local $_;
- while ($_ = $fh->READLINE) {
- s/\012/\n/g;
- my @ls = map {"$_\n"} split /\n/, $_;
- unshift @ls, "\n" x length($1) if /^(\n+)/;
- push @lines, @ls;
- }
- # read header
- my($line_count,$last_updated);
- while (@lines) {
- my $shift = shift(@lines);
- last if $shift =~ /^\s*$/;
- $shift =~ /^Line-Count:\s+(\d+)/ and $line_count = $1;
- $shift =~ /^Last-Updated:\s+(.+)/ and $last_updated = $1;
- }
- if (not defined $line_count) {
-
- warn qq{Warning: Your $index_target does not contain a Line-Count header.
-Please check the validity of the index file by comparing it to more
-than one CPAN mirror. I'll continue but problems seem likely to
-happen.\a
-};
-
- sleep 5;
- } elsif ($line_count != scalar @lines) {
-
- warn sprintf qq{Warning: Your %s
-contains a Line-Count header of %d but I see %d lines there. Please
-check the validity of the index file by comparing it to more than one
-CPAN mirror. I'll continue but problems seem likely to happen.\a\n},
-$index_target, $line_count, scalar(@lines);
-
- }
- if (not defined $last_updated) {
-
- warn qq{Warning: Your $index_target does not contain a Last-Updated header.
-Please check the validity of the index file by comparing it to more
-than one CPAN mirror. I'll continue but problems seem likely to
-happen.\a
-};
-
- sleep 5;
- } else {
-
- $CPAN::Frontend
- ->myprint(sprintf qq{ Database was generated on %s\n},
- $last_updated);
- $DATE_OF_02 = $last_updated;
-
- if ($CPAN::META->has_inst('HTTP::Date')) {
- require HTTP::Date;
- my($age) = (time - HTTP::Date::str2time($last_updated))/3600/24;
- if ($age > 30) {
+CPAN.pm ignores SIGPIPE. If the user sets C<inactivity_timeout>, a
+SIGALRM is used during the run of the C<perl Makefile.PL> or C<perl
+Build.PL> subprocess.
- $CPAN::Frontend
- ->mywarn(sprintf
- qq{Warning: This index file is %d days old.
- Please check the host you chose as your CPAN mirror for staleness.
- I'll continue but problems seem likely to happen.\a\n},
- $age);
+=back
- }
- } else {
- $CPAN::Frontend->myprint(" HTTP::Date not available\n");
- }
- }
+=head2 CPAN::Shell
+The commands available in the shell interface are methods in
+the package CPAN::Shell. If you enter the shell command, your
+input is split by the Text::ParseWords::shellwords() routine, which
+acts like most shells do. The first word is interpreted as the
+method to be invoked, and the rest of the words are treated as the method's arguments.
+Continuation lines are supported by ending a line with a
+literal backslash.
- # A necessity since we have metadata_cache: delete what isn't
- # there anymore
- my $secondtime = $CPAN::META->exists("CPAN::Module","CPAN");
- CPAN->debug("secondtime[$secondtime]") if $CPAN::DEBUG;
- my(%exists);
- foreach (@lines) {
- chomp;
- # before 1.56 we split into 3 and discarded the rest. From
- # 1.57 we assign remaining text to $comment thus allowing to
- # influence isa_perl
- my($mod,$version,$dist,$comment) = split " ", $_, 4;
- my($bundle,$id,$userid);
-
- if ($mod eq 'CPAN' &&
- ! (
- CPAN::Queue->exists('Bundle::CPAN') ||
- CPAN::Queue->exists('CPAN')
- )
- ) {
- local($^W)= 0;
- if ($version > $CPAN::VERSION){
- $CPAN::Frontend->myprint(qq{
- There's a new CPAN.pm version (v$version) available!
- [Current version is v$CPAN::VERSION]
- You might want to try
- install Bundle::CPAN
- reload cpan
- without quitting the current session. It should be a seamless upgrade
- while we are running...
-}); #});
- sleep 2;
- $CPAN::Frontend->myprint(qq{\n});
- }
- last if $CPAN::Signal;
- } elsif ($mod =~ /^Bundle::(.*)/) {
- $bundle = $1;
- }
-
- if ($bundle){
- $id = $CPAN::META->instance('CPAN::Bundle',$mod);
- # Let's make it a module too, because bundles have so much
- # in common with modules.
-
- # Changed in 1.57_63: seems like memory bloat now without
- # any value, so commented out
-
- # $CPAN::META->instance('CPAN::Module',$mod);
-
- } else {
-
- # instantiate a module object
- $id = $CPAN::META->instance('CPAN::Module',$mod);
-
- }
-
- # Although CPAN prohibits same name with different version the
- # indexer may have changed the version for the same distro
- # since the last time ("Force Reindexing" feature)
- if ($id->cpan_file ne $dist
- ||
- $id->cpan_version ne $version
- ){
- $userid = $id->userid || $self->userid($dist);
- $id->set(
- 'CPAN_USERID' => $userid,
- 'CPAN_VERSION' => $version,
- 'CPAN_FILE' => $dist,
- );
- }
-
- # instantiate a distribution object
- if ($CPAN::META->exists('CPAN::Distribution',$dist)) {
- # we do not need CONTAINSMODS unless we do something with
- # this dist, so we better produce it on demand.
-
- ## my $obj = $CPAN::META->instance(
- ## 'CPAN::Distribution' => $dist
- ## );
- ## $obj->{CONTAINSMODS}{$mod} = undef; # experimental
- } else {
- $CPAN::META->instance(
- 'CPAN::Distribution' => $dist
- )->set(
- 'CPAN_USERID' => $userid,
- 'CPAN_COMMENT' => $comment,
- );
- }
- if ($secondtime) {
- for my $name ($mod,$dist) {
- CPAN->debug("exists name[$name]") if $CPAN::DEBUG;
- $exists{$name} = undef;
- }
- }
- return if $CPAN::Signal;
- }
- undef $fh;
- if ($secondtime) {
- for my $class (qw(CPAN::Module CPAN::Bundle CPAN::Distribution)) {
- for my $o ($CPAN::META->all_objects($class)) {
- next if exists $exists{$o->{ID}};
- $CPAN::META->delete($class,$o->{ID});
- CPAN->debug("deleting ID[$o->{ID}] in class[$class]")
- if $CPAN::DEBUG;
- }
- }
- }
-}
+=head2 autobundle
-#-> sub CPAN::Index::rd_modlist ;
-sub rd_modlist {
- my($cl,$index_target) = @_;
- return unless defined $index_target;
- $CPAN::Frontend->myprint("Going to read $index_target\n");
- my $fh = CPAN::Tarzip->TIEHANDLE($index_target);
- my @eval;
- local($/) = "\n";
- local $_;
- while ($_ = $fh->READLINE) {
- s/\012/\n/g;
- my @ls = map {"$_\n"} split /\n/, $_;
- unshift @ls, "\n" x length($1) if /^(\n+)/;
- push @eval, @ls;
- }
- while (@eval) {
- my $shift = shift(@eval);
- if ($shift =~ /^Date:\s+(.*)/){
- return if $DATE_OF_03 eq $1;
- ($DATE_OF_03) = $1;
- }
- last if $shift =~ /^\s*$/;
- }
- undef $fh;
- push @eval, q{CPAN::Modulelist->data;};
- local($^W) = 0;
- my($comp) = Safe->new("CPAN::Safe1");
- my($eval) = join("", @eval);
- my $ret = $comp->reval($eval);
- Carp::confess($@) if $@;
- return if $CPAN::Signal;
- for (keys %$ret) {
- my $obj = $CPAN::META->instance("CPAN::Module",$_);
- delete $ret->{$_}{modid}; # not needed here, maybe elsewhere
- $obj->set(%{$ret->{$_}});
- return if $CPAN::Signal;
- }
-}
+C<autobundle> writes a bundle file into the
+C<$CPAN::Config-E<gt>{cpan_home}/Bundle> directory. The file contains
+a list of all modules that are both available from CPAN and currently
+installed within @INC. The name of the bundle file is based on the
+current date and a counter.
-#-> sub CPAN::Index::write_metadata_cache ;
-sub write_metadata_cache {
- my($self) = @_;
- return unless $CPAN::Config->{'cache_metadata'};
- return unless $CPAN::META->has_usable("Storable");
- my $cache;
- foreach my $k (qw(CPAN::Bundle CPAN::Author CPAN::Module
- CPAN::Distribution)) {
- $cache->{$k} = $CPAN::META->{readonly}{$k}; # unsafe meta access, ok
- }
- my $metadata_file = File::Spec->catfile($CPAN::Config->{cpan_home},"Metadata");
- $cache->{last_time} = $LAST_TIME;
- $cache->{DATE_OF_02} = $DATE_OF_02;
- $cache->{PROTOCOL} = PROTOCOL;
- $CPAN::Frontend->myprint("Going to write $metadata_file\n");
- eval { Storable::nstore($cache, $metadata_file) };
- $CPAN::Frontend->mywarn($@) if $@; # ?? missing "\n" after $@ in mywarn ??
-}
+=head2 hosts
-#-> sub CPAN::Index::read_metadata_cache ;
-sub read_metadata_cache {
- my($self) = @_;
- return unless $CPAN::Config->{'cache_metadata'};
- return unless $CPAN::META->has_usable("Storable");
- my $metadata_file = File::Spec->catfile($CPAN::Config->{cpan_home},"Metadata");
- return unless -r $metadata_file and -f $metadata_file;
- $CPAN::Frontend->myprint("Going to read $metadata_file\n");
- my $cache;
- eval { $cache = Storable::retrieve($metadata_file) };
- $CPAN::Frontend->mywarn($@) if $@; # ?? missing "\n" after $@ in mywarn ??
- if (!$cache || ref $cache ne 'HASH'){
- $LAST_TIME = 0;
- return;
- }
- if (exists $cache->{PROTOCOL}) {
- if (PROTOCOL > $cache->{PROTOCOL}) {
- $CPAN::Frontend->mywarn(sprintf("Ignoring Metadata cache written ".
- "with protocol v%s, requiring v%s\n",
- $cache->{PROTOCOL},
- PROTOCOL)
- );
- return;
- }
- } else {
- $CPAN::Frontend->mywarn("Ignoring Metadata cache written ".
- "with protocol v1.0\n");
- return;
- }
- my $clcnt = 0;
- my $idcnt = 0;
- while(my($class,$v) = each %$cache) {
- next unless $class =~ /^CPAN::/;
- $CPAN::META->{readonly}{$class} = $v; # unsafe meta access, ok
- while (my($id,$ro) = each %$v) {
- $CPAN::META->{readwrite}{$class}{$id} ||=
- $class->new(ID=>$id, RO=>$ro);
- $idcnt++;
- }
- $clcnt++;
- }
- unless ($clcnt) { # sanity check
- $CPAN::Frontend->myprint("Warning: Found no data in $metadata_file\n");
- return;
- }
- if ($idcnt < 1000) {
- $CPAN::Frontend->myprint("Warning: Found only $idcnt objects ".
- "in $metadata_file\n");
- return;
- }
- $CPAN::META->{PROTOCOL} ||=
- $cache->{PROTOCOL}; # reading does not up or downgrade, but it
- # does initialize to some protocol
- $LAST_TIME = $cache->{last_time};
- $DATE_OF_02 = $cache->{DATE_OF_02};
- $CPAN::Frontend->myprint(" Database was generated on $DATE_OF_02\n")
- if defined $DATE_OF_02; # An old cache may not contain DATE_OF_02
- return;
-}
+Note: this feature is still in alpha state and may change in future
+versions of CPAN.pm
-package CPAN::InfoObj;
-use strict;
+This commands provides a statistical overview over recent download
+activities. The data for this is collected in the YAML file
+C<FTPstats.yml> in your C<cpan_home> directory. If no YAML module is
+configured or YAML not installed, no stats are provided.
-sub ro {
- my $self = shift;
- exists $self->{RO} and return $self->{RO};
-}
+=head2 mkmyconfig
-sub cpan_userid {
- my $self = shift;
- my $ro = $self->ro or return;
- return $ro->{CPAN_USERID};
-}
+mkmyconfig() writes your own CPAN::MyConfig file into your C<~/.cpan/>
+directory so that you can save your own preferences instead of the
+system-wide ones.
-sub id { shift->{ID}; }
+=head2 recent ***EXPERIMENTAL COMMAND***
-#-> sub CPAN::InfoObj::new ;
-sub new {
- my $this = bless {}, shift;
- %$this = @_;
- $this
-}
+The C<recent> command downloads a list of recent uploads to CPAN and
+displays them I<slowly>. While the command is running, a $SIG{INT}
+exits the loop after displaying the current item.
-# The set method may only be used by code that reads index data or
-# otherwise "objective" data from the outside world. All session
-# related material may do anything else with instance variables but
-# must not touch the hash under the RO attribute. The reason is that
-# the RO hash gets written to Metadata file and is thus persistent.
-
-#-> sub CPAN::InfoObj::set ;
-sub set {
- my($self,%att) = @_;
- my $class = ref $self;
-
- # This must be ||=, not ||, because only if we write an empty
- # reference, only then the set method will write into the readonly
- # area. But for Distributions that spring into existence, maybe
- # because of a typo, we do not like it that they are written into
- # the readonly area and made permanent (at least for a while) and
- # that is why we do not "allow" other places to call ->set.
- unless ($self->id) {
- CPAN->debug("Bug? Empty ID, rejecting");
- return;
- }
- my $ro = $self->{RO} =
- $CPAN::META->{readonly}{$class}{$self->id} ||= {};
+B<Note>: This command requires XML::LibXML installed.
- while (my($k,$v) = each %att) {
- $ro->{$k} = $v;
- }
-}
+B<Note>: This whole command currently is just a hack and will
+probably change in future versions of CPAN.pm, but the general
+approach will likely remain.
-#-> sub CPAN::InfoObj::as_glimpse ;
-sub as_glimpse {
- my($self) = @_;
- my(@m);
- my $class = ref($self);
- $class =~ s/^CPAN:://;
- push @m, sprintf "%-15s %s\n", $class, $self->{ID};
- join "", @m;
-}
+B<Note>: See also L<smoke>
-#-> sub CPAN::InfoObj::as_string ;
-sub as_string {
- my($self) = @_;
- my(@m);
- my $class = ref($self);
- $class =~ s/^CPAN:://;
- push @m, $class, " id = $self->{ID}\n";
- my $ro = $self->ro;
- for (sort keys %$ro) {
- # next if m/^(ID|RO)$/;
- my $extra = "";
- if ($_ eq "CPAN_USERID") {
- $extra .= " (".$self->author;
- my $email; # old perls!
- if ($email = $CPAN::META->instance("CPAN::Author",
- $self->cpan_userid
- )->email) {
- $extra .= " <$email>";
- } else {
- $extra .= " <no email>";
- }
- $extra .= ")";
- } elsif ($_ eq "FULLNAME") { # potential UTF-8 conversion
- push @m, sprintf " %-12s %s\n", $_, $self->fullname;
- next;
- }
- next unless defined $ro->{$_};
- push @m, sprintf " %-12s %s%s\n", $_, $ro->{$_}, $extra;
- }
- for (sort keys %$self) {
- next if m/^(ID|RO)$/;
- if (ref($self->{$_}) eq "ARRAY") {
- push @m, sprintf " %-12s %s\n", $_, "@{$self->{$_}}";
- } elsif (ref($self->{$_}) eq "HASH") {
- push @m, sprintf(
- " %-12s %s\n",
- $_,
- join(" ",keys %{$self->{$_}}),
- );
- } else {
- push @m, sprintf " %-12s %s\n", $_, $self->{$_};
- }
- }
- join "", @m, "\n";
-}
-
-#-> sub CPAN::InfoObj::author ;
-sub author {
- my($self) = @_;
- $CPAN::META->instance("CPAN::Author",$self->cpan_userid)->fullname;
-}
-
-#-> sub CPAN::InfoObj::dump ;
-sub dump {
- my($self) = @_;
- require Data::Dumper;
- print Data::Dumper::Dumper($self);
-}
-
-package CPAN::Author;
-use strict;
-
-#-> sub CPAN::Author::id
-sub id {
- my $self = shift;
- my $id = $self->{ID};
- $CPAN::Frontend->mydie("Illegal author id[$id]") unless $id =~ /^[A-Z]/;
- $id;
-}
-
-#-> sub CPAN::Author::as_glimpse ;
-sub as_glimpse {
- my($self) = @_;
- my(@m);
- my $class = ref($self);
- $class =~ s/^CPAN:://;
- push @m, sprintf(qq{%-15s %s ("%s" <%s>)\n},
- $class,
- $self->{ID},
- $self->fullname,
- $self->email);
- join "", @m;
-}
+=head2 recompile
-#-> sub CPAN::Author::fullname ;
-sub fullname {
- shift->ro->{FULLNAME};
-}
-*name = \&fullname;
-
-#-> sub CPAN::Author::email ;
-sub email { shift->ro->{EMAIL}; }
-
-#-> sub CPAN::Author::ls ;
-sub ls {
- my $self = shift;
- my $glob = shift || "";
- my $silent = shift || 0;
- my $id = $self->id;
-
- # adapted from CPAN::Distribution::verifyCHECKSUM ;
- my(@csf); # chksumfile
- @csf = $self->id =~ /(.)(.)(.*)/;
- $csf[1] = join "", @csf[0,1];
- $csf[2] = join "", @csf[1,2]; # ("A","AN","ANDK")
- my(@dl);
- @dl = $self->dir_listing([$csf[0],"CHECKSUMS"], 0, 1);
- unless (grep {$_->[2] eq $csf[1]} @dl) {
- $CPAN::Frontend->myprint("Directory $csf[1]/ does not exist\n") unless $silent ;
- return;
- }
- @dl = $self->dir_listing([@csf[0,1],"CHECKSUMS"], 0, 1);
- unless (grep {$_->[2] eq $csf[2]} @dl) {
- $CPAN::Frontend->myprint("Directory $id/ does not exist\n") unless $silent;
- return;
- }
- @dl = $self->dir_listing([@csf,"CHECKSUMS"], 1, 1);
- if ($glob) {
- my $rglob = Text::Glob::glob_to_regex($glob);
- @dl = grep { $_->[2] =~ /$rglob/ } @dl;
- }
- $CPAN::Frontend->myprint(join "", map {
- sprintf("%8d %10s %s/%s\n", $_->[0], $_->[1], $id, $_->[2])
- } sort { $a->[2] cmp $b->[2] } @dl);
-}
+recompile() is a special command that takes no argument and
+runs the make/test/install cycle with brute force over all installed
+dynamically loadable extensions (aka XS modules) with 'force' in
+effect. The primary purpose of this command is to finish a network
+installation. Imagine you have a common source tree for two different
+architectures. You decide to do a completely independent fresh
+installation. You start on one architecture with the help of a Bundle
+file produced earlier. CPAN installs the whole Bundle for you, but
+when you try to repeat the job on the second architecture, CPAN
+responds with a C<"Foo up to date"> message for all modules. So you
+invoke CPAN's recompile on the second architecture and you're done.
-# returns an array of arrays, the latter contain (size,mtime,filename)
-#-> sub CPAN::Author::dir_listing ;
-sub dir_listing {
- my $self = shift;
- my $chksumfile = shift;
- my $recursive = shift;
- my $may_ftp = shift;
- my $lc_want =
- File::Spec->catfile($CPAN::Config->{keep_source_where},
- "authors", "id", @$chksumfile);
-
- my $fh;
-
- # Purge and refetch old (pre-PGP) CHECKSUMS; they are a security
- # hazard. (Without GPG installed they are not that much better,
- # though.)
- $fh = FileHandle->new;
- if (open($fh, $lc_want)) {
- my $line = <$fh>; close $fh;
- unlink($lc_want) unless $line =~ /PGP/;
- }
+Another popular use for C<recompile> is to act as a rescue in case your
+perl breaks binary compatibility. If one of the modules that CPAN uses
+is in turn depending on binary compatibility (so you cannot run CPAN
+commands), then you should try the CPAN::Nox module for recovery.
- local($") = "/";
- # connect "force" argument with "index_expire".
- my $force = 0;
- if (my @stat = stat $lc_want) {
- $force = $stat[9] + $CPAN::Config->{index_expire}*86400 <= time;
- }
- my $lc_file;
- if ($may_ftp) {
- $lc_file = CPAN::FTP->localize(
- "authors/id/@$chksumfile",
- $lc_want,
- $force,
- );
- unless ($lc_file) {
- $CPAN::Frontend->myprint("Trying $lc_want.gz\n");
- $chksumfile->[-1] .= ".gz";
- $lc_file = CPAN::FTP->localize("authors/id/@$chksumfile",
- "$lc_want.gz",1);
- if ($lc_file) {
- $lc_file =~ s{\.gz(?!\n)\Z}{}; #};
- CPAN::Tarzip->new("$lc_file.gz")->gunzip($lc_file);
- } else {
- return;
- }
- }
- } else {
- $lc_file = $lc_want;
- # we *could* second-guess and if the user has a file: URL,
- # then we could look there. But on the other hand, if they do
- # have a file: URL, wy did they choose to set
- # $CPAN::Config->{show_upload_date} to false?
- }
+=head2 report Bundle|Distribution|Module
- # adapted from CPAN::Distribution::CHECKSUM_check_file ;
- $fh = FileHandle->new;
- my($cksum);
- if (open $fh, $lc_file){
- local($/);
- my $eval = <$fh>;
- $eval =~ s/\015?\012/\n/g;
- close $fh;
- my($comp) = Safe->new();
- $cksum = $comp->reval($eval);
- if ($@) {
- rename $lc_file, "$lc_file.bad";
- Carp::confess($@) if $@;
- }
- } elsif ($may_ftp) {
- Carp::carp "Could not open $lc_file for reading.";
- } else {
- # Maybe should warn: "You may want to set show_upload_date to a true value"
- return;
- }
- my(@result,$f);
- for $f (sort keys %$cksum) {
- if (exists $cksum->{$f}{isdir}) {
- if ($recursive) {
- my(@dir) = @$chksumfile;
- pop @dir;
- push @dir, $f, "CHECKSUMS";
- push @result, map {
- [$_->[0], $_->[1], "$f/$_->[2]"]
- } $self->dir_listing(\@dir,1,$may_ftp);
- } else {
- push @result, [ 0, "-", $f ];
- }
- } else {
- push @result, [
- ($cksum->{$f}{"size"}||0),
- $cksum->{$f}{"mtime"}||"---",
- $f
- ];
- }
- }
- @result;
-}
+The C<report> command temporarily turns on the C<test_report> config
+variable, then runs the C<force test> command with the given
+arguments. The C<force> pragma reruns the tests and repeats
+every step that might have failed before.
-package CPAN::Distribution;
-use strict;
+=head2 smoke ***EXPERIMENTAL COMMAND***
-# Accessors
-sub cpan_comment { shift->ro->{CPAN_COMMENT} }
+B<*** WARNING: this command downloads and executes software from CPAN to
+your computer of completely unknown status. You should never do
+this with your normal account and better have a dedicated well
+separated and secured machine to do this. ***>
-sub undelay {
- my $self = shift;
- delete $self->{later};
-}
+The C<smoke> command takes the list of recent uploads to CPAN as
+provided by the C<recent> command and tests them all. While the
+command is running $SIG{INT} is defined to mean that the current item
+shall be skipped.
-# CPAN::Distribution::normalize
-sub normalize {
- my($self,$s) = @_;
- $s = $self->id unless defined $s;
- if (
- $s =~ tr|/|| == 1
- or
- $s !~ m|[A-Z]/[A-Z-]{2}/[A-Z-]{2,}/|
- ) {
- return $s if $s =~ m:^N/A|^Contact Author: ;
- $s =~ s|^(.)(.)([^/]*/)(.+)$|$1/$1$2/$1$2$3$4| or
- $CPAN::Frontend->mywarn("Strange distribution name [$s]\n");
- CPAN->debug("s[$s]") if $CPAN::DEBUG;
- }
- $s;
-}
+B<Note>: This whole command currently is just a hack and will
+probably change in future versions of CPAN.pm, but the general
+approach will likely remain.
-# mark as dirty/clean
-#-> sub CPAN::Distribution::color_cmd_tmps ;
-sub color_cmd_tmps {
- my($self) = shift;
- my($depth) = shift || 0;
- my($color) = shift || 0;
- my($ancestors) = shift || [];
- # a distribution needs to recurse into its prereq_pms
-
- return if exists $self->{incommandcolor}
- && $self->{incommandcolor}==$color;
- if ($depth>=100){
- $CPAN::Frontend->mydie(CPAN::Exception::RecursiveDependency->new($ancestors));
- }
- # warn "color_cmd_tmps $depth $color " . $self->id; # sleep 1;
- my $prereq_pm = $self->prereq_pm;
- if (defined $prereq_pm) {
- for my $pre (keys %$prereq_pm) {
- my $premo = CPAN::Shell->expand("Module",$pre);
- $premo->color_cmd_tmps($depth+1,$color,[@$ancestors, $self->id]);
- }
- }
- if ($color==0) {
- delete $self->{sponsored_mods};
- delete $self->{badtestcnt};
- }
- $self->{incommandcolor} = $color;
-}
+B<Note>: See also L<recent>
-#-> sub CPAN::Distribution::as_string ;
-sub as_string {
- my $self = shift;
- $self->containsmods;
- $self->upload_date;
- $self->SUPER::as_string(@_);
-}
+=head2 upgrade [Module|/Regex/]...
-#-> sub CPAN::Distribution::containsmods ;
-sub containsmods {
- my $self = shift;
- return keys %{$self->{CONTAINSMODS}} if exists $self->{CONTAINSMODS};
- my $dist_id = $self->{ID};
- for my $mod ($CPAN::META->all_objects("CPAN::Module")) {
- my $mod_file = $mod->cpan_file or next;
- my $mod_id = $mod->{ID} or next;
- # warn "mod_file[$mod_file] dist_id[$dist_id] mod_id[$mod_id]";
- # sleep 1;
- $self->{CONTAINSMODS}{$mod_id} = undef if $mod_file eq $dist_id;
- }
- keys %{$self->{CONTAINSMODS}};
-}
+The C<upgrade> command first runs an C<r> command with the given
+arguments and then installs the newest versions of all modules that
+were listed by that.
-#-> sub CPAN::Distribution::upload_date ;
-sub upload_date {
- my $self = shift;
- return $self->{UPLOAD_DATE} if exists $self->{UPLOAD_DATE};
- my(@local_wanted) = split(/\//,$self->id);
- my $filename = pop @local_wanted;
- push @local_wanted, "CHECKSUMS";
- my $author = CPAN::Shell->expand("Author",$self->cpan_userid);
- return unless $author;
- my @dl = $author->dir_listing(\@local_wanted,0,$CPAN::Config->{show_upload_date});
- return unless @dl;
- my($dirent) = grep { $_->[2] eq $filename } @dl;
- # warn sprintf "dirent[%s]id[%s]", $dirent, $self->id;
- return unless $dirent->[1];
- return $self->{UPLOAD_DATE} = $dirent->[1];
-}
+=head2 The four C<CPAN::*> Classes: Author, Bundle, Module, Distribution
-#-> sub CPAN::Distribution::uptodate ;
-sub uptodate {
- my($self) = @_;
- my $c;
- foreach $c ($self->containsmods) {
- my $obj = CPAN::Shell->expandany($c);
- return 0 unless $obj->uptodate;
- }
- return 1;
-}
+Although it may be considered internal, the class hierarchy does matter
+for both users and programmer. CPAN.pm deals with the four
+classes mentioned above, and those classes all share a set of methods. Classical
+single polymorphism is in effect. A metaclass object registers all
+objects of all kinds and indexes them with a string. The strings
+referencing objects have a separated namespace (well, not completely
+separated):
-#-> sub CPAN::Distribution::called_for ;
-sub called_for {
- my($self,$id) = @_;
- $self->{CALLED_FOR} = $id if defined $id;
- return $self->{CALLED_FOR};
-}
+ Namespace Class
-#-> sub CPAN::Distribution::safe_chdir ;
-sub safe_chdir {
- my($self,$todir) = @_;
- # we die if we cannot chdir and we are debuggable
- Carp::confess("safe_chdir called without todir argument")
- unless defined $todir and length $todir;
- if (chdir $todir) {
- $self->debug(sprintf "changed directory to %s", CPAN::anycwd())
- if $CPAN::DEBUG;
- } else {
- unless (-x $todir) {
- unless (chmod 0755, $todir) {
- my $cwd = CPAN::anycwd();
- $CPAN::Frontend->mywarn("I have neither the -x permission nor the permission ".
- "to change the permission; cannot chdir ".
- "to '$todir'\n");
- sleep 5;
- $CPAN::Frontend->mydie(qq{Could not chdir from cwd[$cwd] }.
- qq{to todir[$todir]: $!});
- }
- }
- if (chdir $todir) {
- $self->debug(sprintf "changed directory to %s", CPAN::anycwd())
- if $CPAN::DEBUG;
- } else {
- my $cwd = CPAN::anycwd();
- $CPAN::Frontend->mydie(qq{Could not chdir from cwd[$cwd] }.
- qq{to todir[$todir] (a chmod has been issued): $!});
- }
- }
-}
+ words containing a "/" (slash) Distribution
+ words starting with Bundle:: Bundle
+ everything else Module or Author
-#-> sub CPAN::Distribution::get ;
-sub get {
- my($self) = @_;
- EXCUSE: {
- my @e;
- exists $self->{'build_dir'} and push @e,
- "Is already unwrapped into directory $self->{'build_dir'}";
- $CPAN::Frontend->myprint(join "", map {" $_\n"} @e) and return if @e;
- }
- my $sub_wd = CPAN::anycwd(); # for cleaning up as good as possible
-
- #
- # Get the file on local disk
- #
-
- my($local_file);
- my($local_wanted) =
- File::Spec->catfile(
- $CPAN::Config->{keep_source_where},
- "authors",
- "id",
- split(/\//,$self->id)
- );
-
- $self->debug("Doing localize") if $CPAN::DEBUG;
- unless ($local_file =
- CPAN::FTP->localize("authors/id/$self->{ID}",
- $local_wanted)) {
- my $note = "";
- if ($CPAN::Index::DATE_OF_02) {
- $note = "Note: Current database in memory was generated ".
- "on $CPAN::Index::DATE_OF_02\n";
- }
- $CPAN::Frontend->mydie("Giving up on '$local_wanted'\n$note");
- }
- $self->debug("local_file[$local_file]") if $CPAN::DEBUG;
- $self->{localfile} = $local_file;
- return if $CPAN::Signal;
-
- #
- # Check integrity
- #
- if ($CPAN::META->has_inst("Digest::SHA")) {
- $self->debug("Digest::SHA is installed, verifying");
- $self->verifyCHECKSUM;
- } else {
- $self->debug("Digest::SHA is NOT installed");
- }
- return if $CPAN::Signal;
-
- #
- # Create a clean room and go there
- #
- $CPAN::META->{cachemgr} ||= CPAN::CacheMgr->new(); # unsafe meta access, ok
- my $builddir = $CPAN::META->{cachemgr}->dir; # unsafe meta access, ok
- $self->safe_chdir($builddir);
- $self->debug("Removing tmp") if $CPAN::DEBUG;
- File::Path::rmtree("tmp");
- mkdir "tmp", 0755 or Carp::croak "Couldn't mkdir tmp: $!";
- if ($CPAN::Signal){
- $self->safe_chdir($sub_wd);
- return;
- }
- $self->safe_chdir("tmp");
-
- #
- # Unpack the goods
- #
- $self->debug("local_file[$local_file]") if $CPAN::DEBUG;
- my $ct = CPAN::Tarzip->new($local_file);
- if ($local_file =~ /(\.tar\.(bz2|gz|Z)|\.tgz)(?!\n)\Z/i){
- $self->{was_uncompressed}++ unless $ct->gtest();
- $self->untar_me($ct);
- } elsif ( $local_file =~ /\.zip(?!\n)\Z/i ) {
- $self->unzip_me($ct);
- } elsif ( $local_file =~ /\.pm(\.(gz|Z))?(?!\n)\Z/) {
- $self->{was_uncompressed}++ unless $ct->gtest();
- $self->debug("calling pm2dir for local_file[$local_file]") if $CPAN::DEBUG;
- $self->pm2dir_me($local_file);
- } else {
- $self->{archived} = "NO";
- $self->safe_chdir($sub_wd);
- return;
- }
+Modules know their associated Distribution objects. They always refer
+to the most recent official release. Developers may mark their releases
+as unstable development versions (by inserting an underbar into the
+module version number which will also be reflected in the distribution
+name when you run 'make dist'), so the really hottest and newest
+distribution is not always the default. If a module Foo circulates
+on CPAN in both version 1.23 and 1.23_90, CPAN.pm offers a convenient
+way to install version 1.23 by saying
- # we are still in the tmp directory!
- # Let's check if the package has its own directory.
- my $dh = DirHandle->new(File::Spec->curdir)
- or Carp::croak("Couldn't opendir .: $!");
- my @readdir = grep $_ !~ /^\.\.?(?!\n)\Z/s, $dh->read; ### MAC??
- $dh->close;
- my ($distdir,$packagedir);
- if (@readdir == 1 && -d $readdir[0]) {
- $distdir = $readdir[0];
- $packagedir = File::Spec->catdir($builddir,$distdir);
- $self->debug("packagedir[$packagedir]builddir[$builddir]distdir[$distdir]")
- if $CPAN::DEBUG;
- -d $packagedir and $CPAN::Frontend->myprint("Removing previously used ".
- "$packagedir\n");
- File::Path::rmtree($packagedir);
- File::Copy::move($distdir,$packagedir) or
- Carp::confess("Couldn't move $distdir to $packagedir: $!");
- $self->debug(sprintf("moved distdir[%s] to packagedir[%s] -e[%s]-d[%s]",
- $distdir,
- $packagedir,
- -e $packagedir,
- -d $packagedir,
- )) if $CPAN::DEBUG;
- } else {
- my $userid = $self->cpan_userid;
- unless ($userid) {
- CPAN->debug("no userid? self[$self]");
- $userid = "anon";
- }
- my $pragmatic_dir = $userid . '000';
- $pragmatic_dir =~ s/\W_//g;
- $pragmatic_dir++ while -d "../$pragmatic_dir";
- $packagedir = File::Spec->catdir($builddir,$pragmatic_dir);
- $self->debug("packagedir[$packagedir]") if $CPAN::DEBUG;
- File::Path::mkpath($packagedir);
- my($f);
- for $f (@readdir) { # is already without "." and ".."
- my $to = File::Spec->catdir($packagedir,$f);
- File::Copy::move($f,$to) or Carp::confess("Couldn't move $f to $to: $!");
- }
- }
- if ($CPAN::Signal){
- $self->safe_chdir($sub_wd);
- return;
- }
+ install Foo
- $self->{'build_dir'} = $packagedir;
- $self->safe_chdir($builddir);
- File::Path::rmtree("tmp");
-
- $self->safe_chdir($packagedir);
- if ($CPAN::META->has_inst("Module::Signature")) {
- if (-f "SIGNATURE") {
- $self->debug("Module::Signature is installed, verifying") if $CPAN::DEBUG;
- my $rv = Module::Signature::verify();
- if ($rv != Module::Signature::SIGNATURE_OK() and
- $rv != Module::Signature::SIGNATURE_MISSING()) {
- $CPAN::Frontend->myprint(
- qq{\nSignature invalid for }.
- qq{distribution file. }.
- qq{Please investigate.\n\n}.
- $self->as_string,
- $CPAN::META->instance(
- 'CPAN::Author',
- $self->cpan_userid,
- )->as_string
- );
-
- my $wrap = qq{I\'d recommend removing $self->{localfile}. Its signature
-is invalid. Maybe you have configured your 'urllist' with
-a bad URL. Please check this array with 'o conf urllist', and
-retry.};
- $CPAN::Frontend->mydie(Text::Wrap::wrap("","",$wrap));
- }
- } else {
- $CPAN::Frontend->myprint(qq{Package came without SIGNATURE\n\n});
- }
- } else {
- $self->debug("Module::Signature is NOT installed") if $CPAN::DEBUG;
- }
- $self->safe_chdir($builddir);
- return if $CPAN::Signal;
+This would install the complete distribution file (say
+BAR/Foo-1.23.tar.gz) with all accompanying material. But if you would
+like to install version 1.23_90, you need to know where the
+distribution file resides on CPAN relative to the authors/id/
+directory. If the author is BAR, this might be BAR/Foo-1.23_90.tar.gz;
+so you would have to say
+ install BAR/Foo-1.23_90.tar.gz
- my($mpl) = File::Spec->catfile($packagedir,"Makefile.PL");
- my($mpl_exists) = -f $mpl;
- unless ($mpl_exists) {
- # NFS has been reported to have racing problems after the
- # renaming of a directory in some environments.
- # This trick helps.
- sleep 1;
- my $mpldh = DirHandle->new($packagedir)
- or Carp::croak("Couldn't opendir $packagedir: $!");
- $mpl_exists = grep /^Makefile\.PL$/, $mpldh->read;
- $mpldh->close;
- }
- my $prefer_installer = "eumm"; # eumm|mb
- if (-f File::Spec->catfile($packagedir,"Build.PL")) {
- if ($mpl_exists) { # they *can* choose
- if ($CPAN::META->has_inst("Module::Build")) {
- $prefer_installer = $CPAN::Config->{prefer_installer};
- }
- } else {
- $prefer_installer = "mb";
- }
- }
- if (lc($prefer_installer) eq "mb") {
- $self->{modulebuild} = "YES";
- } elsif (! $mpl_exists) {
- $self->debug(sprintf("makefilepl[%s]anycwd[%s]",
- $mpl,
- CPAN::anycwd(),
- )) if $CPAN::DEBUG;
- my($configure) = File::Spec->catfile($packagedir,"Configure");
- if (-f $configure) {
- # do we have anything to do?
- $self->{'configure'} = $configure;
- } elsif (-f File::Spec->catfile($packagedir,"Makefile")) {
- $CPAN::Frontend->myprint(qq{
-Package comes with a Makefile and without a Makefile.PL.
-We\'ll try to build it with that Makefile then.
-});
- $self->{writemakefile} = "YES";
- sleep 2;
- } else {
- my $cf = $self->called_for || "unknown";
- if ($cf =~ m|/|) {
- $cf =~ s|.*/||;
- $cf =~ s|\W.*||;
- }
- $cf =~ s|[/\\:]||g; # risk of filesystem damage
- $cf = "unknown" unless length($cf);
- $CPAN::Frontend->myprint(qq{Package seems to come without Makefile.PL.
- (The test -f "$mpl" returned false.)
- Writing one on our own (setting NAME to $cf)\a\n});
- $self->{had_no_makefile_pl}++;
- sleep 3;
-
- # Writing our own Makefile.PL
-
- my $fh = FileHandle->new;
- $fh->open(">$mpl")
- or Carp::croak("Could not open >$mpl: $!");
- $fh->print(
-qq{# This Makefile.PL has been autogenerated by the module CPAN.pm
-# because there was no Makefile.PL supplied.
-# Autogenerated on: }.scalar localtime().qq{
-
-use ExtUtils::MakeMaker;
-WriteMakefile(NAME => q[$cf]);
+The first example will be driven by an object of the class
+CPAN::Module, the second by an object of class CPAN::Distribution.
-});
- $fh->close;
- }
- }
+=head2 Integrating local directories
- return $self;
-}
+Note: this feature is still in alpha state and may change in future
+versions of CPAN.pm
-# CPAN::Distribution::untar_me ;
-sub untar_me {
- my($self,$ct) = @_;
- $self->{archived} = "tar";
- if ($ct->untar()) {
- $self->{unwrapped} = "YES";
- } else {
- $self->{unwrapped} = "NO";
- }
-}
+Distribution objects are normally distributions from the CPAN, but
+there is a slightly degenerate case for Distribution objects, too, of
+projects held on the local disk. These distribution objects have the
+same name as the local directory and end with a dot. A dot by itself
+is also allowed for the current directory at the time CPAN.pm was
+used. All actions such as C<make>, C<test>, and C<install> are applied
+directly to that directory. This gives the command C<cpan .> an
+interesting touch: while the normal mantra of installing a CPAN module
+without CPAN.pm is one of
-# CPAN::Distribution::unzip_me ;
-sub unzip_me {
- my($self,$ct) = @_;
- $self->{archived} = "zip";
- if ($ct->unzip()) {
- $self->{unwrapped} = "YES";
- } else {
- $self->{unwrapped} = "NO";
- }
- return;
-}
+ perl Makefile.PL perl Build.PL
+ ( go and get prerequisites )
+ make ./Build
+ make test ./Build test
+ make install ./Build install
-sub pm2dir_me {
- my($self,$local_file) = @_;
- $self->{archived} = "pm";
- my $to = File::Basename::basename($local_file);
- if ($to =~ s/\.(gz|Z)(?!\n)\Z//) {
- if (CPAN::Tarzip->new($local_file)->gunzip($to)) {
- $self->{unwrapped} = "YES";
- } else {
- $self->{unwrapped} = "NO";
- }
- } else {
- File::Copy::cp($local_file,".");
- $self->{unwrapped} = "YES";
- }
-}
+the command C<cpan .> does all of this at once. It figures out which
+of the two mantras is appropriate, fetches and installs all
+prerequisites, takes care of them recursively, and finally finishes the
+installation of the module in the current directory, be it a CPAN
+module or not.
-#-> sub CPAN::Distribution::new ;
-sub new {
- my($class,%att) = @_;
+The typical usage case is for private modules or working copies of
+projects from remote repositories on the local disk.
- # $CPAN::META->{cachemgr} ||= CPAN::CacheMgr->new();
+=head2 Redirection
- my $this = { %att };
- return bless $this, $class;
-}
+The usual shell redirection symbols C< | > and C<< > >> are recognized
+by the cpan shell B<only when surrounded by whitespace>. So piping to
+pager or redirecting output into a file works somewhat as in a normal
+shell, with the stipulation that you must type extra spaces.
-#-> sub CPAN::Distribution::look ;
-sub look {
- my($self) = @_;
+=head1 CONFIGURATION
- if ($^O eq 'MacOS') {
- $self->Mac::BuildTools::look;
- return;
- }
+When the CPAN module is used for the first time, a configuration
+dialogue tries to determine a couple of site specific options. The
+result of the dialog is stored in a hash reference C< $CPAN::Config >
+in a file CPAN/Config.pm.
- if ( $CPAN::Config->{'shell'} ) {
- $CPAN::Frontend->myprint(qq{
-Trying to open a subshell in the build directory...
-});
- } else {
- $CPAN::Frontend->myprint(qq{
-Your configuration does not define a value for subshells.
-Please define it with "o conf shell <your shell>"
-});
- return;
- }
- my $dist = $self->id;
- my $dir;
- unless ($dir = $self->dir) {
- $self->get;
- }
- unless ($dir ||= $self->dir) {
- $CPAN::Frontend->mywarn(qq{
-Could not determine which directory to use for looking at $dist.
-});
- return;
- }
- my $pwd = CPAN::anycwd();
- $self->safe_chdir($dir);
- $CPAN::Frontend->myprint(qq{Working directory is $dir\n});
- unless (system($CPAN::Config->{'shell'}) == 0) {
- my $code = $? >> 8;
- $CPAN::Frontend->mywarn("Subprocess shell exit code $code\n");
- }
- $self->safe_chdir($pwd);
-}
+Default values defined in the CPAN/Config.pm file can be
+overridden in a user specific file: CPAN/MyConfig.pm. Such a file is
+best placed in C<$HOME/.cpan/CPAN/MyConfig.pm>, because C<$HOME/.cpan> is
+added to the search path of the CPAN module before the use() or
+require() statements. The mkmyconfig command writes this file for you.
-# CPAN::Distribution::cvs_import ;
-sub cvs_import {
- my($self) = @_;
- $self->get;
- my $dir = $self->dir;
-
- my $package = $self->called_for;
- my $module = $CPAN::META->instance('CPAN::Module', $package);
- my $version = $module->cpan_version;
-
- my $userid = $self->cpan_userid;
-
- my $cvs_dir = (split /\//, $dir)[-1];
- $cvs_dir =~ s/-\d+[^-]+(?!\n)\Z//;
- my $cvs_root =
- $CPAN::Config->{cvsroot} || $ENV{CVSROOT};
- my $cvs_site_perl =
- $CPAN::Config->{cvs_site_perl} || $ENV{CVS_SITE_PERL};
- if ($cvs_site_perl) {
- $cvs_dir = "$cvs_site_perl/$cvs_dir";
- }
- my $cvs_log = qq{"imported $package $version sources"};
- $version =~ s/\./_/g;
- my @cmd = ('cvs', '-d', $cvs_root, 'import', '-m', $cvs_log,
- "$cvs_dir", $userid, "v$version");
+The C<o conf> command has various bells and whistles:
- my $pwd = CPAN::anycwd();
- chdir($dir) or $CPAN::Frontend->mydie(qq{Could not chdir to "$dir": $!});
+=over
- $CPAN::Frontend->myprint(qq{Working directory is $dir\n});
+=item completion support
- $CPAN::Frontend->myprint(qq{@cmd\n});
- system(@cmd) == 0 or
- $CPAN::Frontend->mydie("cvs import failed");
- chdir($pwd) or $CPAN::Frontend->mydie(qq{Could not chdir to "$pwd": $!});
-}
+If you have a ReadLine module installed, you can hit TAB at any point
+of the commandline and C<o conf> will offer you completion for the
+built-in subcommands and/or config variable names.
-#-> sub CPAN::Distribution::readme ;
-sub readme {
- my($self) = @_;
- my($dist) = $self->id;
- my($sans,$suffix) = $dist =~ /(.+)\.(tgz|tar[\._-]gz|tar\.Z|zip)$/;
- $self->debug("sans[$sans] suffix[$suffix]\n") if $CPAN::DEBUG;
- my($local_file);
- my($local_wanted) =
- File::Spec->catfile(
- $CPAN::Config->{keep_source_where},
- "authors",
- "id",
- split(/\//,"$sans.readme"),
- );
- $self->debug("Doing localize") if $CPAN::DEBUG;
- $local_file = CPAN::FTP->localize("authors/id/$sans.readme",
- $local_wanted)
- or $CPAN::Frontend->mydie(qq{No $sans.readme found});;
-
- if ($^O eq 'MacOS') {
- Mac::BuildTools::launch_file($local_file);
- return;
- }
+=item displaying some help: o conf help
- my $fh_pager = FileHandle->new;
- local($SIG{PIPE}) = "IGNORE";
- $fh_pager->open("|$CPAN::Config->{'pager'}")
- or die "Could not open pager $CPAN::Config->{'pager'}: $!";
- my $fh_readme = FileHandle->new;
- $fh_readme->open($local_file)
- or $CPAN::Frontend->mydie(qq{Could not open "$local_file": $!});
- $CPAN::Frontend->myprint(qq{
-Displaying file
- $local_file
-with pager "$CPAN::Config->{'pager'}"
-});
- sleep 2;
- $fh_pager->print(<$fh_readme>);
- $fh_pager->close;
-}
+Displays a short help
-#-> sub CPAN::Distribution::verifyCHECKSUM ;
-sub verifyCHECKSUM {
- my($self) = @_;
- EXCUSE: {
- my @e;
- $self->{CHECKSUM_STATUS} ||= "";
- $self->{CHECKSUM_STATUS} eq "OK" and push @e, "Checksum was ok";
- $CPAN::Frontend->myprint(join "", map {" $_\n"} @e) and return if @e;
- }
- my($lc_want,$lc_file,@local,$basename);
- @local = split(/\//,$self->id);
- pop @local;
- push @local, "CHECKSUMS";
- $lc_want =
- File::Spec->catfile($CPAN::Config->{keep_source_where},
- "authors", "id", @local);
- local($") = "/";
- if (
- -s $lc_want
- &&
- $self->CHECKSUM_check_file($lc_want)
- ) {
- return $self->{CHECKSUM_STATUS} = "OK";
- }
- $lc_file = CPAN::FTP->localize("authors/id/@local",
- $lc_want,1);
- unless ($lc_file) {
- $CPAN::Frontend->myprint("Trying $lc_want.gz\n");
- $local[-1] .= ".gz";
- $lc_file = CPAN::FTP->localize("authors/id/@local",
- "$lc_want.gz",1);
- if ($lc_file) {
- $lc_file =~ s/\.gz(?!\n)\Z//;
- CPAN::Tarzip->new("$lc_file.gz")->gunzip($lc_file);
- } else {
- return;
- }
- }
- $self->CHECKSUM_check_file($lc_file);
-}
+=item displaying current values: o conf [KEY]
-sub SIG_check_file {
- my($self,$chk_file) = @_;
- my $rv = eval { Module::Signature::_verify($chk_file) };
+Displays the current value(s) for this config variable. Without KEY,
+displays all subcommands and config variables.
- if ($rv == Module::Signature::SIGNATURE_OK()) {
- $CPAN::Frontend->myprint("Signature for $chk_file ok\n");
- return $self->{SIG_STATUS} = "OK";
- } else {
- $CPAN::Frontend->myprint(qq{\nSignature invalid for }.
- qq{distribution file. }.
- qq{Please investigate.\n\n}.
- $self->as_string,
- $CPAN::META->instance(
- 'CPAN::Author',
- $self->cpan_userid
- )->as_string);
-
- my $wrap = qq{I\'d recommend removing $chk_file. Its signature
-is invalid. Maybe you have configured your 'urllist' with
-a bad URL. Please check this array with 'o conf urllist', and
-retry.};
-
- $CPAN::Frontend->mydie(Text::Wrap::wrap("","",$wrap));
- }
-}
+Example:
-#-> sub CPAN::Distribution::CHECKSUM_check_file ;
-sub CHECKSUM_check_file {
- my($self,$chk_file) = @_;
- my($cksum,$file,$basename);
+ o conf shell
- if ($CPAN::META->has_inst("Module::Signature") and Module::Signature->VERSION >= 0.26) {
- $self->debug("Module::Signature is installed, verifying");
- $self->SIG_check_file($chk_file);
- } else {
- $self->debug("Module::Signature is NOT installed");
- }
+If KEY starts and ends with a slash, the string in between is
+treated as a regular expression and only keys matching this regex
+are displayed
- $file = $self->{localfile};
- $basename = File::Basename::basename($file);
- my $fh = FileHandle->new;
- if (open $fh, $chk_file){
- local($/);
- my $eval = <$fh>;
- $eval =~ s/\015?\012/\n/g;
- close $fh;
- my($comp) = Safe->new();
- $cksum = $comp->reval($eval);
- if ($@) {
- rename $chk_file, "$chk_file.bad";
- Carp::confess($@) if $@;
- }
- } else {
- Carp::carp "Could not open $chk_file for reading";
- }
+Example:
- if (exists $cksum->{$basename}{sha256}) {
- $self->debug("Found checksum for $basename:" .
- "$cksum->{$basename}{sha256}\n") if $CPAN::DEBUG;
-
- open($fh, $file);
- binmode $fh;
- my $eq = $self->eq_CHECKSUM($fh,$cksum->{$basename}{sha256});
- $fh->close;
- $fh = CPAN::Tarzip->TIEHANDLE($file);
-
- unless ($eq) {
- my $dg = Digest::SHA->new(256);
- my($data,$ref);
- $ref = \$data;
- while ($fh->READ($ref, 4096) > 0){
- $dg->add($data);
- }
- my $hexdigest = $dg->hexdigest;
- $eq += $hexdigest eq $cksum->{$basename}{'sha256-ungz'};
- }
-
- if ($eq) {
- $CPAN::Frontend->myprint("Checksum for $file ok\n");
- return $self->{CHECKSUM_STATUS} = "OK";
- } else {
- $CPAN::Frontend->myprint(qq{\nChecksum mismatch for }.
- qq{distribution file. }.
- qq{Please investigate.\n\n}.
- $self->as_string,
- $CPAN::META->instance(
- 'CPAN::Author',
- $self->cpan_userid
- )->as_string);
-
- my $wrap = qq{I\'d recommend removing $file. Its
-checksum is incorrect. Maybe you have configured your 'urllist' with
-a bad URL. Please check this array with 'o conf urllist', and
-retry.};
-
- $CPAN::Frontend->mydie(Text::Wrap::wrap("","",$wrap));
-
- # former versions just returned here but this seems a
- # serious threat that deserves a die
-
- # $CPAN::Frontend->myprint("\n\n");
- # sleep 3;
- # return;
- }
- # close $fh if fileno($fh);
- } else {
- $self->{CHECKSUM_STATUS} ||= "";
- if ($self->{CHECKSUM_STATUS} eq "NIL") {
- $CPAN::Frontend->mywarn(qq{
-Warning: No checksum for $basename in $chk_file.
-
-The cause for this may be that the file is very new and the checksum
-has not yet been calculated, but it may also be that something is
-going awry right now.
-});
- my $answer = ExtUtils::MakeMaker::prompt("Proceed?", "yes");
- $answer =~ /^\s*y/i or $CPAN::Frontend->mydie("Aborted.");
- }
- $self->{CHECKSUM_STATUS} = "NIL";
- return;
- }
-}
+ o conf /color/
-#-> sub CPAN::Distribution::eq_CHECKSUM ;
-sub eq_CHECKSUM {
- my($self,$fh,$expect) = @_;
- my $dg = Digest::SHA->new(256);
- my($data);
- while (read($fh, $data, 4096)){
- $dg->add($data);
- }
- my $hexdigest = $dg->hexdigest;
- # warn "fh[$fh] hex[$hexdigest] aexp[$expectMD5]";
- $hexdigest eq $expect;
-}
+=item changing of scalar values: o conf KEY VALUE
-#-> sub CPAN::Distribution::force ;
-
-# Both CPAN::Modules and CPAN::Distributions know if "force" is in
-# effect by autoinspection, not by inspecting a global variable. One
-# of the reason why this was chosen to work that way was the treatment
-# of dependencies. They should not automatically inherit the force
-# status. But this has the downside that ^C and die() will return to
-# the prompt but will not be able to reset the force_update
-# attributes. We try to correct for it currently in the read_metadata
-# routine, and immediately before we check for a Signal. I hope this
-# works out in one of v1.57_53ff
-
-sub force {
- my($self, $method) = @_;
- for my $att (qw(
- CHECKSUM_STATUS archived build_dir localfile make install unwrapped
- writemakefile
- )) {
- delete $self->{$att};
- }
- if ($method && $method eq "install") {
- $self->{"force_update"}++; # name should probably have been force_install
- }
-}
+Sets the config variable KEY to VALUE. The empty string can be
+specified as usual in shells, with C<''> or C<"">
-sub notest {
- my($self, $method) = @_;
- # warn "XDEBUG: set notest for $self $method";
- $self->{"notest"}++; # name should probably have been force_install
-}
+Example:
-sub unnotest {
- my($self) = @_;
- # warn "XDEBUG: deleting notest";
- delete $self->{'notest'};
-}
+ o conf wget /usr/bin/wget
-#-> sub CPAN::Distribution::unforce ;
-sub unforce {
- my($self) = @_;
- delete $self->{'force_update'};
-}
+=item changing of list values: o conf KEY SHIFT|UNSHIFT|PUSH|POP|SPLICE|LIST
-#-> sub CPAN::Distribution::isa_perl ;
-sub isa_perl {
- my($self) = @_;
- my $file = File::Basename::basename($self->id);
- if ($file =~ m{ ^ perl
- -?
- (5)
- ([._-])
- (
- \d{3}(_[0-4][0-9])?
- |
- \d*[24680]\.\d+
- )
- \.tar[._-]gz
- (?!\n)\Z
- }xs){
- return "$1.$3";
- } elsif ($self->cpan_comment
- &&
- $self->cpan_comment =~ /isa_perl\(.+?\)/){
- return $1;
- }
-}
+If a config variable name ends with C<list>, it is a list. C<o conf
+KEY shift> removes the first element of the list, C<o conf KEY pop>
+removes the last element of the list. C<o conf KEYS unshift LIST>
+prepends a list of values to the list, C<o conf KEYS push LIST>
+appends a list of valued to the list.
+Likewise, C<o conf KEY splice LIST> passes the LIST to the corresponding
+splice command.
-#-> sub CPAN::Distribution::perl ;
-sub perl {
- return $CPAN::Perl;
-}
+Finally, any other list of arguments is taken as a new list value for
+the KEY variable discarding the previous value.
+Examples:
-#-> sub CPAN::Distribution::make ;
-sub make {
- my($self) = @_;
- my $make = $self->{modulebuild} ? "Build" : "make";
- $CPAN::Frontend->myprint(sprintf "Running %s for %s\n", $make, $self->id);
- # Emergency brake if they said install Pippi and get newest perl
- if ($self->isa_perl) {
- if (
- $self->called_for ne $self->id &&
- ! $self->{force_update}
- ) {
- # if we die here, we break bundles
- $CPAN::Frontend->mywarn(sprintf qq{
-The most recent version "%s" of the module "%s"
-comes with the current version of perl (%s).
-I\'ll build that only if you ask for something like
- force install %s
-or
- install %s
-},
- $CPAN::META->instance(
- 'CPAN::Module',
- $self->called_for
- )->cpan_version,
- $self->called_for,
- $self->isa_perl,
- $self->called_for,
- $self->id);
- sleep 5; return;
- }
- }
- $self->get;
- EXCUSE: {
- my @e;
- !$self->{archived} || $self->{archived} eq "NO" and push @e,
- "Is neither a tar nor a zip archive.";
+ o conf urllist unshift http://cpan.dev.local/CPAN
+ o conf urllist splice 3 1
+ o conf urllist http://cpan1.local http://cpan2.local ftp://ftp.perl.org
- !$self->{unwrapped} || $self->{unwrapped} eq "NO" and push @e,
- "had problems unarchiving. Please build manually";
+=item reverting to saved: o conf defaults
- exists $self->{writemakefile} &&
- $self->{writemakefile} =~ m/ ^ NO\s* ( .* ) /sx and push @e,
- $1 || "Had some problem writing Makefile";
+Reverts all config variables to the state in the saved config file.
- defined $self->{'make'} and push @e,
- "Has already been processed within this session";
+=item saving the config: o conf commit
- exists $self->{later} and length($self->{later}) and
- push @e, $self->{later};
+Saves all config variables to the current config file (CPAN/Config.pm
+or CPAN/MyConfig.pm that was loaded at start).
- $CPAN::Frontend->myprint(join "", map {" $_\n"} @e) and return if @e;
- }
- $CPAN::Frontend->myprint("\n CPAN.pm: Going to build ".$self->id."\n\n");
- my $builddir = $self->dir or
- $CPAN::Frontend->mydie("PANIC: Cannot determine build directory");
- chdir $builddir or Carp::croak("Couldn't chdir $builddir: $!");
- $self->debug("Changed directory to $builddir") if $CPAN::DEBUG;
-
- if ($^O eq 'MacOS') {
- Mac::BuildTools::make($self);
- return;
- }
+=back
- my $system;
- if ($self->{'configure'}) {
- $system = $self->{'configure'};
- } elsif ($self->{modulebuild}) {
- my($perl) = $self->perl or die "Couldn\'t find executable perl\n";
- $system = "$perl Build.PL $CPAN::Config->{mbuildpl_arg}";
- } else {
- my($perl) = $self->perl or die "Couldn\'t find executable perl\n";
- my $switch = "";
-# This needs a handler that can be turned on or off:
-# $switch = "-MExtUtils::MakeMaker ".
-# "-Mops=:default,:filesys_read,:filesys_open,require,chdir"
-# if $] > 5.00310;
- $system = "$perl $switch Makefile.PL $CPAN::Config->{makepl_arg}";
- }
- unless (exists $self->{writemakefile}) {
- local($SIG{ALRM}) = sub { die "inactivity_timeout reached\n" };
- my($ret,$pid);
- $@ = "";
- if ($CPAN::Config->{inactivity_timeout}) {
- eval {
- alarm $CPAN::Config->{inactivity_timeout};
- local $SIG{CHLD}; # = sub { wait };
- if (defined($pid = fork)) {
- if ($pid) { #parent
- # wait;
- waitpid $pid, 0;
- } else { #child
- # note, this exec isn't necessary if
- # inactivity_timeout is 0. On the Mac I'd
- # suggest, we set it always to 0.
- exec $system;
- }
- } else {
- $CPAN::Frontend->myprint("Cannot fork: $!");
- return;
- }
- };
- alarm 0;
- if ($@){
- kill 9, $pid;
- waitpid $pid, 0;
- $CPAN::Frontend->myprint($@);
- $self->{writemakefile} = "NO $@";
- $@ = "";
- return;
- }
- } else {
- $ret = system($system);
- if ($ret != 0) {
- $self->{writemakefile} = "NO Makefile.PL returned status $ret";
- return;
- }
- }
- if (-f "Makefile" || -f "Build") {
- $self->{writemakefile} = "YES";
- delete $self->{make_clean}; # if cleaned before, enable next
- } else {
- $self->{writemakefile} =
- qq{NO Makefile.PL refused to write a Makefile.};
- # It's probably worth it to record the reason, so let's retry
- # local $/;
- # my $fh = IO::File->new("$system |"); # STDERR? STDIN?
- # $self->{writemakefile} .= <$fh>;
- }
- }
- if ($CPAN::Signal){
- delete $self->{force_update};
- return;
- }
- if (my @prereq = $self->unsat_prereq){
- return 1 if $self->follow_prereqs(@prereq); # signal success to the queuerunner
- }
- if ($self->{modulebuild}) {
- $system = "./Build $CPAN::Config->{mbuild_arg}";
- } else {
- $system = join " ", $CPAN::Config->{'make'}, $CPAN::Config->{make_arg};
- }
- if (system($system) == 0) {
- $CPAN::Frontend->myprint(" $system -- OK\n");
- $self->{'make'} = "YES";
- } else {
- $self->{writemakefile} ||= "YES";
- $self->{'make'} = "NO";
- $CPAN::Frontend->myprint(" $system -- NOT OK\n");
- }
-}
+The configuration dialog can be started any time later again by
+issuing the command C< o conf init > in the CPAN shell. A subset of
+the configuration dialog can be run by issuing C<o conf init WORD>
+where WORD is any valid config variable or a regular expression.
-sub follow_prereqs {
- my($self) = shift;
- my(@prereq) = grep {$_ ne "perl"} @_;
- return unless @prereq;
- my $id = $self->id;
- $CPAN::Frontend->myprint("---- Unsatisfied dependencies detected ".
- "during [$id] -----\n");
+=head2 Config Variables
- for my $p (@prereq) {
- $CPAN::Frontend->myprint(" $p\n");
- }
- my $follow = 0;
- if ($CPAN::Config->{prerequisites_policy} eq "follow") {
- $follow = 1;
- } elsif ($CPAN::Config->{prerequisites_policy} eq "ask") {
- require ExtUtils::MakeMaker;
- my $answer = ExtUtils::MakeMaker::prompt(
-"Shall I follow them and prepend them to the queue
-of modules we are processing right now?", "yes");
- $follow = $answer =~ /^\s*y/i;
- } else {
- local($") = ", ";
- $CPAN::Frontend->
- myprint(" Ignoring dependencies on modules @prereq\n");
- }
- if ($follow) {
- # color them as dirty
- for my $p (@prereq) {
- # warn "calling color_cmd_tmps(0,1)";
- CPAN::Shell->expandany($p)->color_cmd_tmps(0,1);
- }
- CPAN::Queue->jumpqueue(@prereq,$id); # queue them and requeue yourself
- $self->{later} = "Delayed until after prerequisites";
- return 1; # signal success to the queuerunner
- }
-}
+The following keys in the hash reference $CPAN::Config are
+currently defined:
-#-> sub CPAN::Distribution::unsat_prereq ;
-sub unsat_prereq {
- my($self) = @_;
- my $prereq_pm = $self->prereq_pm or return;
- my(@need);
- NEED: while (my($need_module, $need_version) = each %$prereq_pm) {
- my $nmo = $CPAN::META->instance("CPAN::Module",$need_module);
- # we were too demanding:
- next if $nmo->uptodate;
-
- # if they have not specified a version, we accept any installed one
- if (not defined $need_version or
- $need_version eq "0" or
- $need_version eq "undef") {
- next if defined $nmo->inst_file;
- }
+ applypatch path to external prg
+ auto_commit commit all changes to config variables to disk
+ build_cache size of cache for directories to build modules
+ build_dir locally accessible directory to build modules
+ build_dir_reuse boolean if distros in build_dir are persistent
+ build_requires_install_policy
+ to install or not to install when a module is
+ only needed for building. yes|no|ask/yes|ask/no
+ bzip2 path to external prg
+ cache_metadata use serializer to cache metadata
+ check_sigs if signatures should be verified
+ colorize_debug Term::ANSIColor attributes for debugging output
+ colorize_output boolean if Term::ANSIColor should colorize output
+ colorize_print Term::ANSIColor attributes for normal output
+ colorize_warn Term::ANSIColor attributes for warnings
+ commandnumber_in_prompt
+ boolean if you want to see current command number
+ commands_quote preferred character to use for quoting external
+ commands when running them. Defaults to double
+ quote on Windows, single tick everywhere else;
+ can be set to space to disable quoting
+ connect_to_internet_ok
+ whether to ask if opening a connection is ok before
+ urllist is specified
+ cpan_home local directory reserved for this package
+ curl path to external prg
+ dontload_hash DEPRECATED
+ dontload_list arrayref: modules in the list will not be
+ loaded by the CPAN::has_inst() routine
+ ftp path to external prg
+ ftp_passive if set, the envariable FTP_PASSIVE is set for downloads
+ ftp_proxy proxy host for ftp requests
+ ftpstats_period max number of days to keep download statistics
+ ftpstats_size max number of items to keep in the download statistics
+ getcwd see below
+ gpg path to external prg
+ gzip location of external program gzip
+ halt_on_failure stop processing after the first failure of queued
+ items or dependencies
+ histfile file to maintain history between sessions
+ histsize maximum number of lines to keep in histfile
+ http_proxy proxy host for http requests
+ inactivity_timeout breaks interactive Makefile.PLs or Build.PLs
+ after this many seconds inactivity. Set to 0 to
+ disable timeouts.
+ index_expire refetch index files after this many days
+ inhibit_startup_message
+ if true, suppress the startup message
+ keep_source_where directory in which to keep the source (if we do)
+ load_module_verbosity
+ report loading of optional modules used by CPAN.pm
+ lynx path to external prg
+ make location of external make program
+ make_arg arguments that should always be passed to 'make'
+ make_install_make_command
+ the make command for running 'make install', for
+ example 'sudo make'
+ make_install_arg same as make_arg for 'make install'
+ makepl_arg arguments passed to 'perl Makefile.PL'
+ mbuild_arg arguments passed to './Build'
+ mbuild_install_arg arguments passed to './Build install'
+ mbuild_install_build_command
+ command to use instead of './Build' when we are
+ in the install stage, for example 'sudo ./Build'
+ mbuildpl_arg arguments passed to 'perl Build.PL'
+ ncftp path to external prg
+ ncftpget path to external prg
+ no_proxy don't proxy to these hosts/domains (comma separated list)
+ pager location of external program more (or any pager)
+ password your password if you CPAN server wants one
+ patch path to external prg
+ patches_dir local directory containing patch files
+ perl5lib_verbosity verbosity level for PERL5LIB additions
+ prefer_installer legal values are MB and EUMM: if a module comes
+ with both a Makefile.PL and a Build.PL, use the
+ former (EUMM) or the latter (MB); if the module
+ comes with only one of the two, that one will be
+ used no matter the setting
+ prerequisites_policy
+ what to do if you are missing module prerequisites
+ ('follow' automatically, 'ask' me, or 'ignore')
+ prefs_dir local directory to store per-distro build options
+ proxy_user username for accessing an authenticating proxy
+ proxy_pass password for accessing an authenticating proxy
+ randomize_urllist add some randomness to the sequence of the urllist
+ scan_cache controls scanning of cache ('atstart' or 'never')
+ shell your favorite shell
+ show_unparsable_versions
+ boolean if r command tells which modules are versionless
+ show_upload_date boolean if commands should try to determine upload date
+ show_zero_versions boolean if r command tells for which modules $version==0
+ tar location of external program tar
+ tar_verbosity verbosity level for the tar command
+ term_is_latin deprecated: if true Unicode is translated to ISO-8859-1
+ (and nonsense for characters outside latin range)
+ term_ornaments boolean to turn ReadLine ornamenting on/off
+ test_report email test reports (if CPAN::Reporter is installed)
+ trust_test_report_history
+ skip testing when previously tested ok (according to
+ CPAN::Reporter history)
+ unzip location of external program unzip
+ urllist arrayref to nearby CPAN sites (or equivalent locations)
+ use_sqlite use CPAN::SQLite for metadata storage (fast and lean)
+ username your username if you CPAN server wants one
+ wait_list arrayref to a wait server to try (See CPAN::WAIT)
+ wget path to external prg
+ yaml_load_code enable YAML code deserialisation via CPAN::DeferredCode
+ yaml_module which module to use to read/write YAML files
- # We only want to install prereqs if either they're not installed
- # or if the installed version is too old. We cannot omit this
- # check, because if 'force' is in effect, nobody else will check.
- if (defined $nmo->inst_file) {
- my(@all_requirements) = split /\s*,\s*/, $need_version;
- local($^W) = 0;
- my $ok = 0;
- RQ: for my $rq (@all_requirements) {
- if ($rq =~ s|>=\s*||) {
- } elsif ($rq =~ s|>\s*||) {
- # 2005-12: one user
- if (CPAN::Version->vgt($nmo->inst_version,$rq)){
- $ok++;
- }
- next RQ;
- } elsif ($rq =~ s|!=\s*||) {
- # 2005-12: no user
- if (CPAN::Version->vcmp($nmo->inst_version,$rq)){
- $ok++;
- next RQ;
- } else {
- last RQ;
- }
- } elsif ($rq =~ m|<=?\s*|) {
- # 2005-12: no user
- $CPAN::Frontend->mywarn("Downgrading not supported (rq[$rq])");
- $ok++;
- next RQ;
- }
- if (! CPAN::Version->vgt($rq, $nmo->inst_version)){
- $ok++;
- }
- CPAN->debug(sprintf "id[%s]inst_file[%s]inst_version[%s]rq[%s]ok[%d]",
- $nmo->id,
- $nmo->inst_file,
- $nmo->inst_version,
- CPAN::Version->readable($rq),
- $ok,
- ) if $CPAN::DEBUG;
- }
- next NEED if $ok == @all_requirements;
- }
+You can set and query each of these options interactively in the cpan
+shell with the C<o conf> or the C<o conf init> command as specified below.
- if ($self->{sponsored_mods}{$need_module}++){
- # We have already sponsored it and for some reason it's still
- # not available. So we do nothing. Or what should we do?
- # if we push it again, we have a potential infinite loop
- next;
- }
- push @need, $need_module;
- }
- @need;
-}
+=over 2
-#-> sub CPAN::Distribution::read_yaml ;
-sub read_yaml {
- my($self) = @_;
- return $self->{yaml_content} if exists $self->{yaml_content};
- my $build_dir = $self->{build_dir};
- my $yaml = File::Spec->catfile($build_dir,"META.yml");
- return unless -f $yaml;
- if ($CPAN::META->has_inst("YAML")) {
- eval { $self->{yaml_content} = YAML::LoadFile($yaml); };
- if ($@) {
- $CPAN::Frontend->mywarn("Error while parsing META.yml: $@");
- return;
- }
- }
- return $self->{yaml_content};
-}
+=item C<o conf E<lt>scalar optionE<gt>>
-#-> sub CPAN::Distribution::prereq_pm ;
-sub prereq_pm {
- my($self) = @_;
- return $self->{prereq_pm} if
- exists $self->{prereq_pm_detected} && $self->{prereq_pm_detected};
- return unless $self->{writemakefile} # no need to have succeeded
- # but we must have run it
- || $self->{mudulebuild};
- my $req;
- if (my $yaml = $self->read_yaml) {
- $req = $yaml->{requires};
- undef $req unless ref $req eq "HASH" && %$req;
- if ($req) {
- if ($yaml->{generated_by} =~ /ExtUtils::MakeMaker version ([\d\._]+)/) {
- my $eummv = do { local $^W = 0; $1+0; };
- if ($eummv < 6.2501) {
- # thanks to Slaven for digging that out: MM before
- # that could be wrong because it could reflect a
- # previous release
- undef $req;
- }
- }
- my $areq;
- my $do_replace;
- while (my($k,$v) = each %$req) {
- if ($v =~ /\d/) {
- $areq->{$k} = $v;
- } elsif ($k =~ /[A-Za-z]/ &&
- $v =~ /[A-Za-z]/ &&
- $CPAN::META->exists("Module",$v)
- ) {
- $CPAN::Frontend->mywarn("Suspicious key-value pair in META.yml's ".
- "requires hash: $k => $v; I'll take both ".
- "key and value as a module name\n");
- sleep 1;
- $areq->{$k} = 0;
- $areq->{$v} = 0;
- $do_replace++;
- }
- }
- $req = $areq if $do_replace;
- }
- if ($req) {
- delete $req->{perl};
- }
- }
- unless ($req) {
- my $build_dir = $self->{build_dir} or die "Panic: no build_dir?";
- my $makefile = File::Spec->catfile($build_dir,"Makefile");
- my $fh;
- if (-f $makefile
- and
- $fh = FileHandle->new("<$makefile\0")) {
- local($/) = "\n";
- while (<$fh>) {
- last if /MakeMaker post_initialize section/;
- my($p) = m{^[\#]
- \s+PREREQ_PM\s+=>\s+(.+)
- }x;
- next unless $p;
- # warn "Found prereq expr[$p]";
-
- # Regexp modified by A.Speer to remember actual version of file
- # PREREQ_PM hash key wants, then add to
- while ( $p =~ m/(?:\s)([\w\:]+)=>q\[(.*?)\],?/g ){
- # In case a prereq is mentioned twice, complain.
- if ( defined $req->{$1} ) {
- warn "Warning: PREREQ_PM mentions $1 more than once, ".
- "last mention wins";
- }
- $req->{$1} = $2;
- }
- last;
- }
- }
- }
- $self->{prereq_pm_detected}++;
- return $self->{prereq_pm} = $req;
-}
+prints the current value of the I<scalar option>
-#-> sub CPAN::Distribution::test ;
-sub test {
- my($self) = @_;
- $self->make;
- if ($CPAN::Signal){
- delete $self->{force_update};
- return;
- }
- # warn "XDEBUG: checking for notest: $self->{notest} $self";
- if ($self->{notest}) {
- $CPAN::Frontend->myprint("Skipping test because of notest pragma\n");
- return 1;
- }
+=item C<o conf E<lt>scalar optionE<gt> E<lt>valueE<gt>>
- my $make = $self->{modulebuild} ? "Build" : "make";
- $CPAN::Frontend->myprint("Running $make test\n");
- if (my @prereq = $self->unsat_prereq){
- return 1 if $self->follow_prereqs(@prereq); # signal success to the queuerunner
- }
- EXCUSE: {
- my @e;
- exists $self->{make} or exists $self->{later} or push @e,
- "Make had some problems, maybe interrupted? Won't test";
+Sets the value of the I<scalar option> to I<value>
- exists $self->{'make'} and
- $self->{'make'} eq 'NO' and
- push @e, "Can't test without successful make";
+=item C<o conf E<lt>list optionE<gt>>
- exists $self->{build_dir} or push @e, "Has no own directory";
- $self->{badtestcnt} ||= 0;
- $self->{badtestcnt} > 0 and
- push @e, "Won't repeat unsuccessful test during this command";
+prints the current value of the I<list option> in MakeMaker's
+neatvalue format.
- exists $self->{later} and length($self->{later}) and
- push @e, $self->{later};
+=item C<o conf E<lt>list optionE<gt> [shift|pop]>
- $CPAN::Frontend->myprint(join "", map {" $_\n"} @e) and return if @e;
- }
- chdir $self->{'build_dir'} or
- Carp::croak("Couldn't chdir to $self->{'build_dir'}");
- $self->debug("Changed directory to $self->{'build_dir'}")
- if $CPAN::DEBUG;
+shifts or pops the array in the I<list option> variable
- if ($^O eq 'MacOS') {
- Mac::BuildTools::make_test($self);
- return;
- }
+=item C<o conf E<lt>list optionE<gt> [unshift|push|splice] E<lt>listE<gt>>
- local $ENV{PERL5LIB} = defined($ENV{PERL5LIB})
- ? $ENV{PERL5LIB}
- : ($ENV{PERLLIB} || "");
+works like the corresponding perl commands.
- $CPAN::META->set_perl5lib;
- my $system;
- if ($self->{modulebuild}) {
- $system = "./Build test";
- } else {
- $system = join " ", $CPAN::Config->{'make'}, "test";
- }
- if (system($system) == 0) {
- $CPAN::Frontend->myprint(" $system -- OK\n");
- $CPAN::META->is_tested($self->{'build_dir'});
- $self->{make_test} = "YES";
- } else {
- $self->{make_test} = "NO";
- $self->{badtestcnt}++;
- $CPAN::Frontend->myprint(" $system -- NOT OK\n");
- }
-}
+=item interactive editing: o conf init [MATCH|LIST]
-#-> sub CPAN::Distribution::clean ;
-sub clean {
- my($self) = @_;
- my $make = $self->{modulebuild} ? "Build" : "make";
- $CPAN::Frontend->myprint("Running $make clean\n");
- unless (exists $self->{build_dir}) {
- $CPAN::Frontend->mywarn("Distribution has no own directory, nothing to do.\n");
- return 1;
- }
- EXCUSE: {
- my @e;
- exists $self->{make_clean} and $self->{make_clean} eq "YES" and
- push @e, "make clean already called once";
- $CPAN::Frontend->myprint(join "", map {" $_\n"} @e) and return if @e;
- }
- chdir $self->{'build_dir'} or
- Carp::croak("Couldn't chdir to $self->{'build_dir'}");
- $self->debug("Changed directory to $self->{'build_dir'}") if $CPAN::DEBUG;
+Runs an interactive configuration dialog for matching variables.
+Without argument runs the dialog over all supported config variables.
+To specify a MATCH the argument must be enclosed by slashes.
- if ($^O eq 'MacOS') {
- Mac::BuildTools::make_clean($self);
- return;
- }
+Examples:
- my $system;
- if ($self->{modulebuild}) {
- $system = "./Build clean";
- } else {
- $system = join " ", $CPAN::Config->{'make'}, "clean";
- }
- if (system($system) == 0) {
- $CPAN::Frontend->myprint(" $system -- OK\n");
-
- # $self->force;
-
- # Jost Krieger pointed out that this "force" was wrong because
- # it has the effect that the next "install" on this distribution
- # will untar everything again. Instead we should bring the
- # object's state back to where it is after untarring.
-
- for my $k (qw(
- force_update
- install
- writemakefile
- make
- make_test
- )) {
- delete $self->{$k};
- }
- $self->{make_clean} = "YES";
+ o conf init ftp_passive ftp_proxy
+ o conf init /color/
- } else {
- # Hmmm, what to do if make clean failed?
+Note: this method of setting config variables often provides more
+explanation about the functioning of a variable than the manpage.
- $CPAN::Frontend->myprint(qq{ $system -- NOT OK
+=back
-make clean did not succeed, marking directory as unusable for further work.
-});
- $self->force("make"); # so that this directory won't be used again
+=head2 CPAN::anycwd($path): Note on config variable getcwd
- }
-}
+CPAN.pm changes the current working directory often and needs to
+determine its own current working directory. By default it uses
+Cwd::cwd, but if for some reason this doesn't work on your system,
+configure alternatives according to the following table:
-#-> sub CPAN::Distribution::install ;
-sub install {
- my($self) = @_;
- $self->test;
- if ($CPAN::Signal){
- delete $self->{force_update};
- return;
- }
- my $make = $self->{modulebuild} ? "Build" : "make";
- $CPAN::Frontend->myprint("Running $make install\n");
- EXCUSE: {
- my @e;
- exists $self->{build_dir} or push @e, "Has no own directory";
+=over 4
- exists $self->{make} or exists $self->{later} or push @e,
- "Make had some problems, maybe interrupted? Won't install";
+=item cwd
- exists $self->{'make'} and
- $self->{'make'} eq 'NO' and
- push @e, "make had returned bad status, install seems impossible";
+Calls Cwd::cwd
- push @e, "make test had returned bad status, ".
- "won't install without force"
- if exists $self->{'make_test'} and
- $self->{'make_test'} eq 'NO' and
- ! $self->{'force_update'};
+=item getcwd
- exists $self->{'install'} and push @e,
- $self->{'install'} eq "YES" ?
- "Already done" : "Already tried without success";
+Calls Cwd::getcwd
- exists $self->{later} and length($self->{later}) and
- push @e, $self->{later};
+=item fastcwd
- $CPAN::Frontend->myprint(join "", map {" $_\n"} @e) and return if @e;
- }
- chdir $self->{'build_dir'} or
- Carp::croak("Couldn't chdir to $self->{'build_dir'}");
- $self->debug("Changed directory to $self->{'build_dir'}")
- if $CPAN::DEBUG;
+Calls Cwd::fastcwd
- if ($^O eq 'MacOS') {
- Mac::BuildTools::make_install($self);
- return;
- }
+=item backtickcwd
- my $system;
- if ($self->{modulebuild}) {
- my($mbuild_install_build_command) = $CPAN::Config->{'mbuild_install_build_command'} ||
- "./Build";
- $system = join(" ",
- $mbuild_install_build_command,
- "install",
- $CPAN::Config->{mbuild_install_arg},
- );
- } else {
- my($make_install_make_command) = $CPAN::Config->{'make_install_make_command'} ||
- $CPAN::Config->{'make'};
- $system = join(" ",
- $make_install_make_command,
- "install",
- $CPAN::Config->{make_install_arg},
- );
- }
+Calls the external command cwd.
- my($stderr) = $^O =~ /Win/i ? "" : " 2>&1 ";
- my($pipe) = FileHandle->new("$system $stderr |");
- my($makeout) = "";
- while (<$pipe>){
- $CPAN::Frontend->myprint($_);
- $makeout .= $_;
- }
- $pipe->close;
- if ($?==0) {
- $CPAN::Frontend->myprint(" $system -- OK\n");
- $CPAN::META->is_installed($self->{'build_dir'});
- return $self->{'install'} = "YES";
- } else {
- $self->{'install'} = "NO";
- $CPAN::Frontend->myprint(" $system -- NOT OK\n");
- if (
- $makeout =~ /permission/s
- && $> > 0
- && (
- ! $CPAN::Config->{make_install_make_command}
- || $CPAN::Config->{make_install_make_command} eq $CPAN::Config->{make}
- )
- ) {
- $CPAN::Frontend->myprint(
- qq{----\n}.
- qq{ You may have to su }.
- qq{to root to install the package\n}.
- qq{ (Or you may want to run something like\n}.
- qq{ o conf make_install_make_command 'sudo make'\n}.
- qq{ to raise your permissions.}
- );
- }
- }
- delete $self->{force_update};
-}
+=back
-#-> sub CPAN::Distribution::dir ;
-sub dir {
- shift->{'build_dir'};
-}
+=head2 Note on the format of the urllist parameter
-#-> sub CPAN::Distribution::perldoc ;
-sub perldoc {
- my($self) = @_;
+urllist parameters are URLs according to RFC 1738. We do a little
+guessing if your URL is not compliant, but if you have problems with
+C<file> URLs, please try the correct format. Either:
- my($dist) = $self->id;
- my $package = $self->called_for;
+ file://localhost/whatever/ftp/pub/CPAN/
- $self->_display_url( $CPAN::Defaultdocs . $package );
-}
+or
-#-> sub CPAN::Distribution::_check_binary ;
-sub _check_binary {
- my ($dist,$shell,$binary) = @_;
- my ($pid,$readme,$out);
+ file:///home/ftp/pub/CPAN/
- $CPAN::Frontend->myprint(qq{ + _check_binary($binary)\n})
- if $CPAN::DEBUG;
+=head2 The urllist parameter has CD-ROM support
- $pid = open $readme, "which $binary|"
- or $CPAN::Frontend->mydie(qq{Could not fork 'which $binary': $!});
- while (<$readme>) {
- $out .= $_;
- }
- close $readme or die "Could not run 'which $binary': $!";
+The C<urllist> parameter of the configuration table contains a list of
+URLs used for downloading. If the list contains any
+C<file> URLs, CPAN always tries there first. This
+feature is disabled for index files. So the recommendation for the
+owner of a CD-ROM with CPAN contents is: include your local, possibly
+outdated CD-ROM as a C<file> URL at the end of urllist, e.g.
- $CPAN::Frontend->myprint(qq{ + $out \n})
- if $CPAN::DEBUG && $out;
+ o conf urllist push file://localhost/CDROM/CPAN
- return $out;
-}
+CPAN.pm will then fetch the index files from one of the CPAN sites
+that come at the beginning of urllist. It will later check for each
+module to see whether there is a local copy of the most recent version.
-#-> sub CPAN::Distribution::_display_url ;
-sub _display_url {
- my($self,$url) = @_;
- my($res,$saved_file,$pid,$readme,$out);
-
- $CPAN::Frontend->myprint(qq{ + _display_url($url)\n})
- if $CPAN::DEBUG;
-
- # should we define it in the config instead?
- my $html_converter = "html2text";
-
- my $web_browser = $CPAN::Config->{'lynx'} || undef;
- my $web_browser_out = $web_browser
- ? CPAN::Distribution->_check_binary($self,$web_browser)
- : undef;
-
- my ($tmpout,$tmperr);
- if (not $web_browser_out) {
- # web browser not found, let's try text only
- my $html_converter_out =
- CPAN::Distribution->_check_binary($self,$html_converter);
-
- if ($html_converter_out ) {
- # html2text found, run it
- $saved_file = CPAN::Distribution->_getsave_url( $self, $url );
- $CPAN::Frontend->myprint(qq{ERROR: problems while getting $url, $!\n})
- unless defined($saved_file);
-
- $pid = open $readme, "$html_converter $saved_file |"
- or $CPAN::Frontend->mydie(qq{
-Could not fork '$html_converter $saved_file': $!});
- my $fh = File::Temp->new(
- template => 'cpan_htmlconvert_XXXX',
- suffix => '.txt',
- unlink => 0,
- );
- while (<$readme>) {
- $fh->print($_);
- }
- close $readme
- or $CPAN::Frontend->mydie(qq{Could not run '$html_converter $saved_file': $!});
- my $tmpin = $fh->filename;
- $CPAN::Frontend->myprint(sprintf(qq{
-Run '%s %s' and
-saved output to %s\n},
- $html_converter,
- $saved_file,
- $tmpin,
- )) if $CPAN::DEBUG;
- close $fh; undef $fh;
- open $fh, $tmpin
- or $CPAN::Frontend->mydie(qq{Could not open "$tmpin": $!});
- my $fh_pager = FileHandle->new;
- local($SIG{PIPE}) = "IGNORE";
- $fh_pager->open("|$CPAN::Config->{'pager'}")
- or $CPAN::Frontend->mydie(qq{
-Could not open pager $CPAN::Config->{'pager'}: $!});
- $CPAN::Frontend->myprint(qq{
-Displaying URL
- $url
-with pager "$CPAN::Config->{'pager'}"
-});
- sleep 2;
- $fh_pager->print(<$fh>);
- $fh_pager->close;
- } else {
- # coldn't find the web browser or html converter
- $CPAN::Frontend->myprint(qq{
-You need to install lynx or $html_converter to use this feature.});
- }
- } else {
- # web browser found, run the action
- my $browser = $CPAN::Config->{'lynx'};
- $CPAN::Frontend->myprint(qq{system[$browser $url]})
- if $CPAN::DEBUG;
- $CPAN::Frontend->myprint(qq{
-Displaying URL
- $url
-with browser $browser
-});
- sleep 2;
- system("$browser $url");
- if ($saved_file) { 1 while unlink($saved_file) }
- }
-}
+Another peculiarity of urllist is that the site that we could
+successfully fetch the last file from automatically gets a preference
+token and is tried as the first site for the next request. So if you
+add a new site at runtime it may happen that the previously preferred
+site will be tried another time. This means that if you want to disallow
+a site for the next transfer, it must be explicitly removed from
+urllist.
-#-> sub CPAN::Distribution::_getsave_url ;
-sub _getsave_url {
- my($dist, $shell, $url) = @_;
-
- $CPAN::Frontend->myprint(qq{ + _getsave_url($url)\n})
- if $CPAN::DEBUG;
-
- my $fh = File::Temp->new(
- template => "cpan_getsave_url_XXXX",
- suffix => ".html",
- unlink => 0,
- );
- my $tmpin = $fh->filename;
- if ($CPAN::META->has_usable('LWP')) {
- $CPAN::Frontend->myprint("Fetching with LWP:
- $url
-");
- my $Ua;
- CPAN::LWP::UserAgent->config;
- eval { $Ua = CPAN::LWP::UserAgent->new; };
- if ($@) {
- $CPAN::Frontend->mywarn("ERROR: CPAN::LWP::UserAgent->new dies with $@\n");
- return;
- } else {
- my($var);
- $Ua->proxy('http', $var)
- if $var = $CPAN::Config->{http_proxy} || $ENV{http_proxy};
- $Ua->no_proxy($var)
- if $var = $CPAN::Config->{no_proxy} || $ENV{no_proxy};
- }
-
- my $req = HTTP::Request->new(GET => $url);
- $req->header('Accept' => 'text/html');
- my $res = $Ua->request($req);
- if ($res->is_success) {
- $CPAN::Frontend->myprint(" + request successful.\n")
- if $CPAN::DEBUG;
- print $fh $res->content;
- close $fh;
- $CPAN::Frontend->myprint(qq{ + saved content to $tmpin \n})
- if $CPAN::DEBUG;
- return $tmpin;
- } else {
- $CPAN::Frontend->myprint(sprintf(
- "LWP failed with code[%s], message[%s]\n",
- $res->code,
- $res->message,
- ));
- return;
- }
- } else {
- $CPAN::Frontend->myprint("LWP not available\n");
- return;
- }
-}
+=head2 Maintaining the urllist parameter
-package CPAN::Bundle;
-use strict;
+If you have YAML.pm (or some other YAML module configured in
+C<yaml_module>) installed, CPAN.pm collects a few statistical data
+about recent downloads. You can view the statistics with the C<hosts>
+command or inspect them directly by looking into the C<FTPstats.yml>
+file in your C<cpan_home> directory.
-sub look {
- my $self = shift;
- $CPAN::Frontend->myprint($self->as_string);
-}
+To get some interesting statistics, it is recommended that
+C<randomize_urllist> be set; this introduces some amount of
+randomness into the URL selection.
-sub undelay {
- my $self = shift;
- delete $self->{later};
- for my $c ( $self->contains ) {
- my $obj = CPAN::Shell->expandany($c) or next;
- $obj->undelay;
- }
-}
+=head2 The C<requires> and C<build_requires> dependency declarations
-# mark as dirty/clean
-#-> sub CPAN::Bundle::color_cmd_tmps ;
-sub color_cmd_tmps {
- my($self) = shift;
- my($depth) = shift || 0;
- my($color) = shift || 0;
- my($ancestors) = shift || [];
- # a module needs to recurse to its cpan_file, a distribution needs
- # to recurse into its prereq_pms, a bundle needs to recurse into its modules
-
- return if exists $self->{incommandcolor}
- && $self->{incommandcolor}==$color;
- if ($depth>=100){
- $CPAN::Frontend->mydie(CPAN::Exception::RecursiveDependency->new($ancestors));
- }
- # warn "color_cmd_tmps $depth $color " . $self->id; # sleep 1;
+Since CPAN.pm version 1.88_51 modules declared as C<build_requires> by
+a distribution are treated differently depending on the config
+variable C<build_requires_install_policy>. By setting
+C<build_requires_install_policy> to C<no>, such a module is not
+installed. It is only built and tested, and then kept in the list of
+tested but uninstalled modules. As such, it is available during the
+build of the dependent module by integrating the path to the
+C<blib/arch> and C<blib/lib> directories in the environment variable
+PERL5LIB. If C<build_requires_install_policy> is set ti C<yes>, then
+both modules declared as C<requires> and those declared as
+C<build_requires> are treated alike. By setting to C<ask/yes> or
+C<ask/no>, CPAN.pm asks the user and sets the default accordingly.
- for my $c ( $self->contains ) {
- my $obj = CPAN::Shell->expandany($c) or next;
- CPAN->debug("c[$c]obj[$obj]") if $CPAN::DEBUG;
- $obj->color_cmd_tmps($depth+1,$color,[@$ancestors, $self->id]);
- }
- if ($color==0) {
- delete $self->{badtestcnt};
- }
- $self->{incommandcolor} = $color;
-}
+=head2 Configuration for individual distributions (I<Distroprefs>)
-#-> sub CPAN::Bundle::as_string ;
-sub as_string {
- my($self) = @_;
- $self->contains;
- # following line must be "=", not "||=" because we have a moving target
- $self->{INST_VERSION} = $self->inst_version;
- return $self->SUPER::as_string;
-}
+(B<Note:> This feature has been introduced in CPAN.pm 1.8854 and is
+still considered beta quality)
-#-> sub CPAN::Bundle::contains ;
-sub contains {
- my($self) = @_;
- my($inst_file) = $self->inst_file || "";
- my($id) = $self->id;
- $self->debug("inst_file[$inst_file]id[$id]") if $CPAN::DEBUG;
- unless ($inst_file) {
- # Try to get at it in the cpan directory
- $self->debug("no inst_file") if $CPAN::DEBUG;
- my $cpan_file;
- $CPAN::Frontend->mydie("I don't know a bundle with ID $id\n") unless
- $cpan_file = $self->cpan_file;
- if ($cpan_file eq "N/A") {
- $CPAN::Frontend->mydie("Bundle $id not found on disk and not on CPAN.
- Maybe stale symlink? Maybe removed during session? Giving up.\n");
- }
- my $dist = $CPAN::META->instance('CPAN::Distribution',
- $self->cpan_file);
- $dist->get;
- $self->debug($dist->as_string) if $CPAN::DEBUG;
- my($todir) = $CPAN::Config->{'cpan_home'};
- my(@me,$from,$to,$me);
- @me = split /::/, $self->id;
- $me[-1] .= ".pm";
- $me = File::Spec->catfile(@me);
- $from = $self->find_bundle_file($dist->{'build_dir'},$me);
- $to = File::Spec->catfile($todir,$me);
- File::Path::mkpath(File::Basename::dirname($to));
- File::Copy::copy($from, $to)
- or Carp::confess("Couldn't copy $from to $to: $!");
- $inst_file = $to;
- }
- my @result;
- my $fh = FileHandle->new;
- local $/ = "\n";
- open($fh,$inst_file) or die "Could not open '$inst_file': $!";
- my $in_cont = 0;
- $self->debug("inst_file[$inst_file]") if $CPAN::DEBUG;
- while (<$fh>) {
- $in_cont = m/^=(?!head1\s+CONTENTS)/ ? 0 :
- m/^=head1\s+CONTENTS/ ? 1 : $in_cont;
- next unless $in_cont;
- next if /^=/;
- s/\#.*//;
- next if /^\s+$/;
- chomp;
- push @result, (split " ", $_, 2)[0];
- }
- close $fh;
- delete $self->{STATUS};
- $self->{CONTAINS} = \@result;
- $self->debug("CONTAINS[@result]") if $CPAN::DEBUG;
- unless (@result) {
- $CPAN::Frontend->mywarn(qq{
-The bundle file "$inst_file" may be a broken
-bundlefile. It seems not to contain any bundle definition.
-Please check the file and if it is bogus, please delete it.
-Sorry for the inconvenience.
-});
- }
- @result;
-}
+Distributions on CPAN usually behave according to what we call the
+CPAN mantra. Or since the advent of Module::Build we should talk about
+two mantras:
-#-> sub CPAN::Bundle::find_bundle_file
-sub find_bundle_file {
- my($self,$where,$what) = @_;
- $self->debug("where[$where]what[$what]") if $CPAN::DEBUG;
-### The following two lines let CPAN.pm become Bundle/CPAN.pm :-(
-### my $bu = File::Spec->catfile($where,$what);
-### return $bu if -f $bu;
- my $manifest = File::Spec->catfile($where,"MANIFEST");
- unless (-f $manifest) {
- require ExtUtils::Manifest;
- my $cwd = CPAN::anycwd();
- chdir $where or $CPAN::Frontend->mydie(qq{Could not chdir to "$where": $!});
- ExtUtils::Manifest::mkmanifest();
- chdir $cwd or $CPAN::Frontend->mydie(qq{Could not chdir to "$cwd": $!});
- }
- my $fh = FileHandle->new($manifest)
- or Carp::croak("Couldn't open $manifest: $!");
- local($/) = "\n";
- my $what2 = $what;
- if ($^O eq 'MacOS') {
- $what =~ s/^://;
- $what =~ tr|:|/|;
- $what2 =~ s/:Bundle://;
- $what2 =~ tr|:|/|;
- } else {
- $what2 =~ s|Bundle[/\\]||;
- }
- my $bu;
- while (<$fh>) {
- next if /^\s*\#/;
- my($file) = /(\S+)/;
- if ($file =~ m|\Q$what\E$|) {
- $bu = $file;
- # return File::Spec->catfile($where,$bu); # bad
- last;
- }
- # retry if she managed to
- # have no Bundle directory
- $bu = $file if $file =~ m|\Q$what2\E$|;
- }
- $bu =~ tr|/|:| if $^O eq 'MacOS';
- return File::Spec->catfile($where, $bu) if $bu;
- Carp::croak("Couldn't find a Bundle file in $where");
-}
+ perl Makefile.PL perl Build.PL
+ make ./Build
+ make test ./Build test
+ make install ./Build install
-# needs to work quite differently from Module::inst_file because of
-# cpan_home/Bundle/ directory and the possibility that we have
-# shadowing effect. As it makes no sense to take the first in @INC for
-# Bundles, we parse them all for $VERSION and take the newest.
+But some modules cannot be built with this mantra. They try to get
+some extra data from the user via the environment, extra arguments, or
+interactively--thus disturbing the installation of large bundles like
+Phalanx100 or modules with many dependencies like Plagger.
-#-> sub CPAN::Bundle::inst_file ;
-sub inst_file {
- my($self) = @_;
- my($inst_file);
- my(@me);
- @me = split /::/, $self->id;
- $me[-1] .= ".pm";
- my($incdir,$bestv);
- foreach $incdir ($CPAN::Config->{'cpan_home'},@INC) {
- my $bfile = File::Spec->catfile($incdir, @me);
- CPAN->debug("bfile[$bfile]") if $CPAN::DEBUG;
- next unless -f $bfile;
- my $foundv = MM->parse_version($bfile);
- if (!$bestv || CPAN::Version->vgt($foundv,$bestv)) {
- $self->{INST_FILE} = $bfile;
- $self->{INST_VERSION} = $bestv = $foundv;
- }
- }
- $self->{INST_FILE};
-}
+The distroprefs system of C<CPAN.pm> addresses this problem by
+allowing the user to specify extra informations and recipes in YAML
+files to either
-#-> sub CPAN::Bundle::inst_version ;
-sub inst_version {
- my($self) = @_;
- $self->inst_file; # finds INST_VERSION as side effect
- $self->{INST_VERSION};
-}
+=over
-#-> sub CPAN::Bundle::rematein ;
-sub rematein {
- my($self,$meth) = @_;
- $self->debug("self[$self] meth[$meth]") if $CPAN::DEBUG;
- my($id) = $self->id;
- Carp::croak "Can't $meth $id, don't have an associated bundle file. :-(\n"
- unless $self->inst_file || $self->cpan_file;
- my($s,%fail);
- for $s ($self->contains) {
- my($type) = $s =~ m|/| ? 'CPAN::Distribution' :
- $s =~ m|^Bundle::| ? 'CPAN::Bundle' : 'CPAN::Module';
- if ($type eq 'CPAN::Distribution') {
- $CPAN::Frontend->mywarn(qq{
-The Bundle }.$self->id.qq{ contains
-explicitly a file $s.
-});
- sleep 3;
- }
- # possibly noisy action:
- $self->debug("type[$type] s[$s]") if $CPAN::DEBUG;
- my $obj = $CPAN::META->instance($type,$s);
- $obj->$meth();
- if ($obj->isa('CPAN::Bundle')
- &&
- exists $obj->{install_failed}
- &&
- ref($obj->{install_failed}) eq "HASH"
- ) {
- for (keys %{$obj->{install_failed}}) {
- $self->{install_failed}{$_} = undef; # propagate faiure up
- # to me in a
- # recursive call
- $fail{$s} = 1; # the bundle itself may have succeeded but
- # not all children
- }
- } else {
- my $success;
- $success = $obj->can("uptodate") ? $obj->uptodate : 0;
- $success ||= $obj->{'install'} && $obj->{'install'} eq "YES";
- if ($success) {
- delete $self->{install_failed}{$s};
- } else {
- $fail{$s} = 1;
- }
- }
- }
+=item
- # recap with less noise
- if ( $meth eq "install" ) {
- if (%fail) {
- require Text::Wrap;
- my $raw = sprintf(qq{Bundle summary:
-The following items in bundle %s had installation problems:},
- $self->id
- );
- $CPAN::Frontend->myprint(Text::Wrap::fill("","",$raw));
- $CPAN::Frontend->myprint("\n");
- my $paragraph = "";
- my %reported;
- for $s ($self->contains) {
- if ($fail{$s}){
- $paragraph .= "$s ";
- $self->{install_failed}{$s} = undef;
- $reported{$s} = undef;
- }
- }
- my $report_propagated;
- for $s (sort keys %{$self->{install_failed}}) {
- next if exists $reported{$s};
- $paragraph .= "and the following items had problems
-during recursive bundle calls: " unless $report_propagated++;
- $paragraph .= "$s ";
- }
- $CPAN::Frontend->myprint(Text::Wrap::fill(" "," ",$paragraph));
- $CPAN::Frontend->myprint("\n");
- } else {
- $self->{'install'} = 'YES';
- }
- }
-}
+pass additional arguments to one of the four commands,
-#sub CPAN::Bundle::xs_file
-sub xs_file {
- # If a bundle contains another that contains an xs_file we have
- # here, we just don't bother I suppose
- return 0;
-}
+=item
-#-> sub CPAN::Bundle::force ;
-sub force { shift->rematein('force',@_); }
-#-> sub CPAN::Bundle::notest ;
-sub notest { shift->rematein('notest',@_); }
-#-> sub CPAN::Bundle::get ;
-sub get { shift->rematein('get',@_); }
-#-> sub CPAN::Bundle::make ;
-sub make { shift->rematein('make',@_); }
-#-> sub CPAN::Bundle::test ;
-sub test {
- my $self = shift;
- $self->{badtestcnt} ||= 0;
- $self->rematein('test',@_);
-}
-#-> sub CPAN::Bundle::install ;
-sub install {
- my $self = shift;
- $self->rematein('install',@_);
-}
-#-> sub CPAN::Bundle::clean ;
-sub clean { shift->rematein('clean',@_); }
+set environment variables
-#-> sub CPAN::Bundle::uptodate ;
-sub uptodate {
- my($self) = @_;
- return 0 unless $self->SUPER::uptodate; # we mut have the current Bundle def
- my $c;
- foreach $c ($self->contains) {
- my $obj = CPAN::Shell->expandany($c);
- return 0 unless $obj->uptodate;
- }
- return 1;
-}
+=item
-#-> sub CPAN::Bundle::readme ;
-sub readme {
- my($self) = @_;
- my($file) = $self->cpan_file or $CPAN::Frontend->myprint(qq{
-No File found for bundle } . $self->id . qq{\n}), return;
- $self->debug("self[$self] file[$file]") if $CPAN::DEBUG;
- $CPAN::META->instance('CPAN::Distribution',$file)->readme;
-}
+instantiate an Expect object that reads from the console, waits for
+some regular expressions and enters some answers
-package CPAN::Module;
-use strict;
+=item
-# Accessors
-# sub CPAN::Module::userid
-sub userid {
- my $self = shift;
- my $ro = $self->ro;
- return unless $ro;
- return $ro->{userid} || $ro->{CPAN_USERID};
-}
-# sub CPAN::Module::description
-sub description { shift->ro->{description} }
-
-sub undelay {
- my $self = shift;
- delete $self->{later};
- if ( my $dist = CPAN::Shell->expand("Distribution", $self->cpan_file) ) {
- $dist->undelay;
- }
-}
+temporarily override assorted C<CPAN.pm> configuration variables
-# mark as dirty/clean
-#-> sub CPAN::Module::color_cmd_tmps ;
-sub color_cmd_tmps {
- my($self) = shift;
- my($depth) = shift || 0;
- my($color) = shift || 0;
- my($ancestors) = shift || [];
- # a module needs to recurse to its cpan_file
-
- return if exists $self->{incommandcolor}
- && $self->{incommandcolor}==$color;
- return if $depth>=1 && $self->uptodate;
- if ($depth>=100){
- $CPAN::Frontend->mydie(CPAN::Exception::RecursiveDependency->new($ancestors));
- }
- # warn "color_cmd_tmps $depth $color " . $self->id; # sleep 1;
+=item
- if ( my $dist = CPAN::Shell->expand("Distribution", $self->cpan_file) ) {
- $dist->color_cmd_tmps($depth+1,$color,[@$ancestors, $self->id]);
- }
- if ($color==0) {
- delete $self->{badtestcnt};
- }
- $self->{incommandcolor} = $color;
-}
+specify dependencies the original maintainer forgot
-#-> sub CPAN::Module::as_glimpse ;
-sub as_glimpse {
- my($self) = @_;
- my(@m);
- my $class = ref($self);
- $class =~ s/^CPAN:://;
- my $color_on = "";
- my $color_off = "";
- if (
- $CPAN::Shell::COLOR_REGISTERED
- &&
- $CPAN::META->has_inst("Term::ANSIColor")
- &&
- $self->description
- ) {
- $color_on = Term::ANSIColor::color("green");
- $color_off = Term::ANSIColor::color("reset");
- }
- push @m, sprintf("%-15s %s%-15s%s (%s)\n",
- $class,
- $color_on,
- $self->id,
- $color_off,
- $self->cpan_file);
- join "", @m;
-}
+=item
-#-> sub CPAN::Module::as_string ;
-sub as_string {
- my($self) = @_;
- my(@m);
- CPAN->debug("$self entering as_string") if $CPAN::DEBUG;
- my $class = ref($self);
- $class =~ s/^CPAN:://;
- local($^W) = 0;
- push @m, $class, " id = $self->{ID}\n";
- my $sprintf = " %-12s %s\n";
- push @m, sprintf($sprintf, 'DESCRIPTION', $self->description)
- if $self->description;
- my $sprintf2 = " %-12s %s (%s)\n";
- my($userid);
- $userid = $self->userid;
- if ( $userid ){
- my $author;
- if ($author = CPAN::Shell->expand('Author',$userid)) {
- my $email = "";
- my $m; # old perls
- if ($m = $author->email) {
- $email = " <$m>";
- }
- push @m, sprintf(
- $sprintf2,
- 'CPAN_USERID',
- $userid,
- $author->fullname . $email
- );
- }
- }
- push @m, sprintf($sprintf, 'CPAN_VERSION', $self->cpan_version)
- if $self->cpan_version;
- if (my $cpan_file = $self->cpan_file){
- push @m, sprintf($sprintf, 'CPAN_FILE', $cpan_file);
- if (my $dist = CPAN::Shell->expand("Distribution",$cpan_file)) {
- my $upload_date = $dist->upload_date;
- if ($upload_date) {
- push @m, sprintf($sprintf, 'UPLOAD_DATE', $upload_date);
- }
- }
- }
- my $sprintf3 = " %-12s %1s%1s%1s%1s (%s,%s,%s,%s)\n";
- my(%statd,%stats,%statl,%stati);
- @statd{qw,? i c a b R M S,} = qw,unknown idea
- pre-alpha alpha beta released mature standard,;
- @stats{qw,? m d u n a,} = qw,unknown mailing-list
- developer comp.lang.perl.* none abandoned,;
- @statl{qw,? p c + o h,} = qw,unknown perl C C++ other hybrid,;
- @stati{qw,? f r O h,} = qw,unknown functions
- references+ties object-oriented hybrid,;
- $statd{' '} = 'unknown';
- $stats{' '} = 'unknown';
- $statl{' '} = 'unknown';
- $stati{' '} = 'unknown';
- my $ro = $self->ro;
- push @m, sprintf(
- $sprintf3,
- 'DSLI_STATUS',
- $ro->{statd},
- $ro->{stats},
- $ro->{statl},
- $ro->{stati},
- $statd{$ro->{statd}},
- $stats{$ro->{stats}},
- $statl{$ro->{statl}},
- $stati{$ro->{stati}}
- ) if $ro->{statd};
- my $local_file = $self->inst_file;
- unless ($self->{MANPAGE}) {
- if ($local_file) {
- $self->{MANPAGE} = $self->manpage_headline($local_file);
- } else {
- # If we have already untarred it, we should look there
- my $dist = $CPAN::META->instance('CPAN::Distribution',
- $self->cpan_file);
- # warn "dist[$dist]";
- # mff=manifest file; mfh=manifest handle
- my($mff,$mfh);
- if (
- $dist->{build_dir}
- and
- (-f ($mff = File::Spec->catfile($dist->{build_dir}, "MANIFEST")))
- and
- $mfh = FileHandle->new($mff)
- ) {
- CPAN->debug("mff[$mff]") if $CPAN::DEBUG;
- my $lfre = $self->id; # local file RE
- $lfre =~ s/::/./g;
- $lfre .= "\\.pm\$";
- my($lfl); # local file file
- local $/ = "\n";
- my(@mflines) = <$mfh>;
- for (@mflines) {
- s/^\s+//;
- s/\s.*//s;
- }
- while (length($lfre)>5 and !$lfl) {
- ($lfl) = grep /$lfre/, @mflines;
- CPAN->debug("lfl[$lfl]lfre[$lfre]") if $CPAN::DEBUG;
- $lfre =~ s/.+?\.//;
- }
- $lfl =~ s/\s.*//; # remove comments
- $lfl =~ s/\s+//g; # chomp would maybe be too system-specific
- my $lfl_abs = File::Spec->catfile($dist->{build_dir},$lfl);
- # warn "lfl_abs[$lfl_abs]";
- if (-f $lfl_abs) {
- $self->{MANPAGE} = $self->manpage_headline($lfl_abs);
- }
- }
- }
- }
- my($item);
- for $item (qw/MANPAGE/) {
- push @m, sprintf($sprintf, $item, $self->{$item})
- if exists $self->{$item};
- }
- for $item (qw/CONTAINS/) {
- push @m, sprintf($sprintf, $item, join(" ",@{$self->{$item}}))
- if exists $self->{$item} && @{$self->{$item}};
- }
- push @m, sprintf($sprintf, 'INST_FILE',
- $local_file || "(not installed)");
- push @m, sprintf($sprintf, 'INST_VERSION',
- $self->inst_version) if $local_file;
- join "", @m, "\n";
-}
+disable the installation of an object altogether
-sub manpage_headline {
- my($self,$local_file) = @_;
- my(@local_file) = $local_file;
- $local_file =~ s/\.pm(?!\n)\Z/.pod/;
- push @local_file, $local_file;
- my(@result,$locf);
- for $locf (@local_file) {
- next unless -f $locf;
- my $fh = FileHandle->new($locf)
- or $Carp::Frontend->mydie("Couldn't open $locf: $!");
- my $inpod = 0;
- local $/ = "\n";
- while (<$fh>) {
- $inpod = m/^=(?!head1\s+NAME\s*$)/ ? 0 :
- m/^=head1\s+NAME\s*$/ ? 1 : $inpod;
- next unless $inpod;
- next if /^=/;
- next if /^\s+$/;
- chomp;
- push @result, $_;
- }
- close $fh;
- last if @result;
- }
- join " ", @result;
-}
+=back
-#-> sub CPAN::Module::cpan_file ;
-# Note: also inherited by CPAN::Bundle
-sub cpan_file {
- my $self = shift;
- CPAN->debug(sprintf "id[%s]", $self->id) if $CPAN::DEBUG;
- unless ($self->ro) {
- CPAN::Index->reload;
- }
- my $ro = $self->ro;
- if ($ro && defined $ro->{CPAN_FILE}){
- return $ro->{CPAN_FILE};
- } else {
- my $userid = $self->userid;
- if ( $userid ) {
- if ($CPAN::META->exists("CPAN::Author",$userid)) {
- my $author = $CPAN::META->instance("CPAN::Author",
- $userid);
- my $fullname = $author->fullname;
- my $email = $author->email;
- unless (defined $fullname && defined $email) {
- return sprintf("Contact Author %s",
- $userid,
- );
- }
- return "Contact Author $fullname <$email>";
- } else {
- return "Contact Author $userid (Email address not available)";
- }
- } else {
- return "N/A";
- }
- }
-}
+See the YAML and Data::Dumper files that come with the C<CPAN.pm>
+distribution in the C<distroprefs/> directory for examples.
+
+=head2 Filenames
-#-> sub CPAN::Module::cpan_version ;
-sub cpan_version {
- my $self = shift;
+The YAML files themselves must have the C<.yml> extension; all other
+files are ignored (for two exceptions see I<Fallback Data::Dumper and
+Storable> below). The containing directory can be specified in
+C<CPAN.pm> in the C<prefs_dir> config variable. Try C<o conf init
+prefs_dir> in the CPAN shell to set and activate the distroprefs
+system.
- my $ro = $self->ro;
- unless ($ro) {
- # Can happen with modules that are not on CPAN
- $ro = {};
- }
- $ro->{CPAN_VERSION} = 'undef'
- unless defined $ro->{CPAN_VERSION};
- $ro->{CPAN_VERSION};
-}
+Every YAML file may contain arbitrary documents according to the YAML
+specification, and every document is treated as an entity that
+can specify the treatment of a single distribution.
+
+Filenames can be picked arbitrarily; C<CPAN.pm> always reads
+all files (in alphabetical order) and takes the key C<match> (see
+below in I<Language Specs>) as a hashref containing match criteria
+that determine if the current distribution matches the YAML document
+or not.
-#-> sub CPAN::Module::force ;
-sub force {
- my($self) = @_;
- $self->{'force_update'}++;
-}
+=head2 Fallback Data::Dumper and Storable
-sub notest {
- my($self) = @_;
- # warn "XDEBUG: set notest for Module";
- $self->{'notest'}++;
-}
+If neither your configured C<yaml_module> nor YAML.pm is installed,
+CPAN.pm falls back to using Data::Dumper and Storable and looks for
+files with the extensions C<.dd> or C<.st> in the C<prefs_dir>
+directory. These files are expected to contain one or more hashrefs.
+For Data::Dumper generated files, this is expected to be done with by
+defining C<$VAR1>, C<$VAR2>, etc. The YAML shell would produce these
+with the command
-#-> sub CPAN::Module::rematein ;
-sub rematein {
- my($self,$meth) = @_;
- $CPAN::Frontend->myprint(sprintf("Running %s for module %s\n",
- $meth,
- $self->id));
- my $cpan_file = $self->cpan_file;
- if ($cpan_file eq "N/A" || $cpan_file =~ /^Contact Author/){
- $CPAN::Frontend->mywarn(sprintf qq{
- The module %s isn\'t available on CPAN.
-
- Either the module has not yet been uploaded to CPAN, or it is
- temporary unavailable. Please contact the author to find out
- more about the status. Try 'i %s'.
-},
- $self->id,
- $self->id,
- );
- return;
- }
- my $pack = $CPAN::META->instance('CPAN::Distribution',$cpan_file);
- $pack->called_for($self->id);
- $pack->force($meth) if exists $self->{'force_update'};
- $pack->notest($meth) if exists $self->{'notest'};
- eval {
- $pack->$meth();
- };
- my $err = $@;
- $pack->unforce if $pack->can("unforce") && exists $self->{'force_update'};
- $pack->unnotest if $pack->can("unnotest") && exists $self->{'notest'};
- delete $self->{'force_update'};
- delete $self->{'notest'};
- if ($err) {
- die $err;
- }
-}
+ ysh < somefile.yml > somefile.dd
-#-> sub CPAN::Module::perldoc ;
-sub perldoc { shift->rematein('perldoc') }
-#-> sub CPAN::Module::readme ;
-sub readme { shift->rematein('readme') }
-#-> sub CPAN::Module::look ;
-sub look { shift->rematein('look') }
-#-> sub CPAN::Module::cvs_import ;
-sub cvs_import { shift->rematein('cvs_import') }
-#-> sub CPAN::Module::get ;
-sub get { shift->rematein('get',@_) }
-#-> sub CPAN::Module::make ;
-sub make { shift->rematein('make') }
-#-> sub CPAN::Module::test ;
-sub test {
- my $self = shift;
- $self->{badtestcnt} ||= 0;
- $self->rematein('test',@_);
-}
-#-> sub CPAN::Module::uptodate ;
-sub uptodate {
- my($self) = @_;
- my($latest) = $self->cpan_version;
- $latest ||= 0;
- my($inst_file) = $self->inst_file;
- my($have) = 0;
- if (defined $inst_file) {
- $have = $self->inst_version;
- }
- local($^W)=0;
- if ($inst_file
- &&
- ! CPAN::Version->vgt($latest, $have)
- ) {
- CPAN->debug("returning uptodate. inst_file[$inst_file] ".
- "latest[$latest] have[$have]") if $CPAN::DEBUG;
- return 1;
- }
- return;
-}
-#-> sub CPAN::Module::install ;
-sub install {
- my($self) = @_;
- my($doit) = 0;
- if ($self->uptodate
- &&
- not exists $self->{'force_update'}
- ) {
- $CPAN::Frontend->myprint(sprintf("%s is up to date (%s).\n",
- $self->id,
- $self->inst_version,
- ));
- } else {
- $doit = 1;
- }
- my $ro = $self->ro;
- if ($ro && $ro->{stats} && $ro->{stats} eq "a") {
- $CPAN::Frontend->mywarn(qq{
-\n\n\n ***WARNING***
- The module $self->{ID} has no active maintainer.\n\n\n
-});
- sleep 5;
- }
- $self->rematein('install') if $doit;
-}
-#-> sub CPAN::Module::clean ;
-sub clean { shift->rematein('clean') }
+For Storable files the rule is that they must be constructed such that
+C<Storable::retrieve(file)> returns an array reference and the array
+elements represent one distropref object each. The conversion from
+YAML would look like so:
-#-> sub CPAN::Module::inst_file ;
-sub inst_file {
- my($self) = @_;
- my($dir,@packpath);
- @packpath = split /::/, $self->{ID};
- $packpath[-1] .= ".pm";
- foreach $dir (@INC) {
- my $pmfile = File::Spec->catfile($dir,@packpath);
- if (-f $pmfile){
- return $pmfile;
- }
- }
- return;
-}
+ perl -MYAML=LoadFile -MStorable=nstore -e '
+ @y=LoadFile(shift);
+ nstore(\@y, shift)' somefile.yml somefile.st
-#-> sub CPAN::Module::xs_file ;
-sub xs_file {
- my($self) = @_;
- my($dir,@packpath);
- @packpath = split /::/, $self->{ID};
- push @packpath, $packpath[-1];
- $packpath[-1] .= "." . $Config::Config{'dlext'};
- foreach $dir (@INC) {
- my $xsfile = File::Spec->catfile($dir,'auto',@packpath);
- if (-f $xsfile){
- return $xsfile;
- }
- }
- return;
-}
+In bootstrapping situations it is usually sufficient to translate only
+a few YAML files to Data::Dumper for crucial modules like
+C<YAML::Syck>, C<YAML.pm> and C<Expect.pm>. If you prefer Storable
+over Data::Dumper, remember to pull out a Storable version that writes
+an older format than all the other Storable versions that will need to
+read them.
-#-> sub CPAN::Module::inst_version ;
-sub inst_version {
- my($self) = @_;
- my $parsefile = $self->inst_file or return;
- local($^W) = 0 if $] < 5.00303 && $ExtUtils::MakeMaker::VERSION < 5.38;
- my $have;
-
- # there was a bug in 5.6.0 that let lots of unini warnings out of
- # parse_version. Fixed shortly after 5.6.0 by PMQS. We can remove
- # the following workaround after 5.6.1 is out.
- local($SIG{__WARN__}) = sub { my $w = shift;
- return if $w =~ /uninitialized/i;
- warn $w;
- };
-
- $have = MM->parse_version($parsefile) || "undef";
- $have =~ s/^ //; # since the %vd hack these two lines here are needed
- $have =~ s/ $//; # trailing whitespace happens all the time
-
- # My thoughts about why %vd processing should happen here
-
- # Alt1 maintain it as string with leading v:
- # read index files do nothing
- # compare it use utility for compare
- # print it do nothing
-
- # Alt2 maintain it as what it is
- # read index files convert
- # compare it use utility because there's still a ">" vs "gt" issue
- # print it use CPAN::Version for print
-
- # Seems cleaner to hold it in memory as a string starting with a "v"
-
- # If the author of this module made a mistake and wrote a quoted
- # "v1.13" instead of v1.13, we simply leave it at that with the
- # effect that *we* will treat it like a v-tring while the rest of
- # perl won't. Seems sensible when we consider that any action we
- # could take now would just add complexity.
-
- $have = CPAN::Version->readable($have);
-
- $have =~ s/\s*//g; # stringify to float around floating point issues
- $have; # no stringify needed, \s* above matches always
-}
+=head2 Blueprint
-package CPAN;
-use strict;
+The following example contains all supported keywords and structures
+with the exception of C<eexpect> which can be used instead of
+C<expect>.
-1;
+ ---
+ comment: "Demo"
+ match:
+ module: "Dancing::Queen"
+ distribution: "^CHACHACHA/Dancing-"
+ not_distribution: "\.zip$"
+ perl: "/usr/local/cariba-perl/bin/perl"
+ perlconfig:
+ archname: "freebsd"
+ not_cc: "gcc"
+ env:
+ DANCING_FLOOR: "Shubiduh"
+ disabled: 1
+ cpanconfig:
+ make: gmake
+ pl:
+ args:
+ - "--somearg=specialcase"
-__END__
+ env: {}
-=head1 NAME
+ expect:
+ - "Which is your favorite fruit"
+ - "apple\n"
-CPAN - query, download and build perl modules from CPAN sites
+ make:
+ args:
+ - all
+ - extra-all
-=head1 SYNOPSIS
+ env: {}
-Interactive mode:
+ expect: []
- perl -MCPAN -e shell;
+ commendline: "echo SKIPPING make"
-Batch mode:
+ test:
+ args: []
- use CPAN;
+ env: {}
- autobundle, clean, install, make, recompile, test
+ expect: []
-=head1 STATUS
+ install:
+ args: []
-This module will eventually be replaced by CPANPLUS. CPANPLUS is kind
-of a modern rewrite from ground up with greater extensibility and more
-features but no full compatibility. If you're new to CPAN.pm, you
-probably should investigate if CPANPLUS is the better choice for you.
-If you're already used to CPAN.pm you're welcome to continue using it,
-if you accept that its development is mostly (though not completely)
-stalled.
+ env:
+ WANT_TO_INSTALL: YES
-=head1 DESCRIPTION
+ expect:
+ - "Do you really want to install"
+ - "y\n"
-The CPAN module is designed to automate the make and install of perl
-modules and extensions. It includes some primitive searching capabilities and
-knows how to use Net::FTP or LWP (or lynx or an external ftp client)
-to fetch the raw data from the net.
+ patches:
+ - "ABCDE/Fedcba-3.14-ABCDE-01.patch"
-Modules are fetched from one or more of the mirrored CPAN
-(Comprehensive Perl Archive Network) sites and unpacked in a dedicated
-directory.
+ depends:
+ configure_requires:
+ LWP: 5.8
+ build_requires:
+ Test::Exception: 0.25
+ requires:
+ Spiffy: 0.30
-The CPAN module also supports the concept of named and versioned
-I<bundles> of modules. Bundles simplify the handling of sets of
-related modules. See Bundles below.
-The package contains a session manager and a cache manager. There is
-no status retained between sessions. The session manager keeps track
-of what has been fetched, built and installed in the current
-session. The cache manager keeps track of the disk space occupied by
-the make processes and deletes excess space according to a simple FIFO
-mechanism.
-
-For extended searching capabilities there's a plugin for CPAN available,
-L<C<CPAN::WAIT>|CPAN::WAIT>. C<CPAN::WAIT> is a full-text search engine
-that indexes all documents available in CPAN authors directories. If
-C<CPAN::WAIT> is installed on your system, the interactive shell of
-CPAN.pm will enable the C<wq>, C<wr>, C<wd>, C<wl>, and C<wh> commands
-which send queries to the WAIT server that has been configured for your
-installation.
-
-All other methods provided are accessible in a programmer style and in an
-interactive shell style.
+=head2 Language Specs
-=head2 Interactive Mode
+Every YAML document represents a single hash reference. The valid keys
+in this hash are as follows:
-The interactive mode is entered by running
+=over
- perl -MCPAN -e shell
+=item comment [scalar]
-which puts you into a readline interface. You will have the most fun if
-you install Term::ReadKey and Term::ReadLine to enjoy both history and
-command completion.
+A comment
-Once you are on the command line, type 'h' and the rest should be
-self-explanatory.
+=item cpanconfig [hash]
-The function call C<shell> takes two optional arguments, one is the
-prompt, the second is the default initial command line (the latter
-only works if a real ReadLine interface module is installed).
+Temporarily override assorted C<CPAN.pm> configuration variables.
-The most common uses of the interactive modes are
+Supported are: C<build_requires_install_policy>, C<check_sigs>,
+C<make>, C<make_install_make_command>, C<prefer_installer>,
+C<test_report>. Please report as a bug when you need another one
+supported.
-=over 2
+=item depends [hash] *** EXPERIMENTAL FEATURE ***
-=item Searching for authors, bundles, distribution files and modules
+All three types, namely C<configure_requires>, C<build_requires>, and
+C<requires> are supported in the way specified in the META.yml
+specification. The current implementation I<merges> the specified
+dependencies with those declared by the package maintainer. In a
+future implementation this may be changed to override the original
+declaration.
-There are corresponding one-letter commands C<a>, C<b>, C<d>, and C<m>
-for each of the four categories and another, C<i> for any of the
-mentioned four. Each of the four entities is implemented as a class
-with slightly differing methods for displaying an object.
+=item disabled [boolean]
-Arguments you pass to these commands are either strings exactly matching
-the identification string of an object or regular expressions that are
-then matched case-insensitively against various attributes of the
-objects. The parser recognizes a regular expression only if you
-enclose it between two slashes.
+Specifies that this distribution shall not be processed at all.
-The principle is that the number of found objects influences how an
-item is displayed. If the search finds one item, the result is
-displayed with the rather verbose method C<as_string>, but if we find
-more than one, we display each object with the terse method
-<as_glimpse>.
+=item features [array] *** EXPERIMENTAL FEATURE ***
-=item make, test, install, clean modules or distributions
+Experimental implementation to deal with optional_features from
+META.yml. Still needs coordination with installer software and
+currently works only for META.yml declaring C<dynamic_config=0>. Use
+with caution.
-These commands take any number of arguments and investigate what is
-necessary to perform the action. If the argument is a distribution
-file name (recognized by embedded slashes), it is processed. If it is
-a module, CPAN determines the distribution file in which this module
-is included and processes that, following any dependencies named in
-the module's META.yml or Makefile.PL (this behavior is controlled by
-I<prerequisites_policy>.)
+=item goto [string]
-Any C<make> or C<test> are run unconditionally. An
+The canonical name of a delegate distribution to install
+instead. Useful when a new version, although it tests OK itself,
+breaks something else or a developer release or a fork is already
+uploaded that is better than the last released version.
- install <distribution_file>
+=item install [hash]
-also is run unconditionally. But for
+Processing instructions for the C<make install> or C<./Build install>
+phase of the CPAN mantra. See below under I<Processing Instructions>.
- install <module>
+=item make [hash]
+
+Processing instructions for the C<make> or C<./Build> phase of the
+CPAN mantra. See below under I<Processing Instructions>.
+
+=item match [hash]
+
+A hashref with one or more of the keys C<distribution>, C<modules>,
+C<perl>, C<perlconfig>, and C<env> that specify whether a document is
+targeted at a specific CPAN distribution or installation.
+Keys prefixed with C<not_> negates the corresponding match.
+
+The corresponding values are interpreted as regular expressions. The
+C<distribution> related one will be matched against the canonical
+distribution name, e.g. "AUTHOR/Foo-Bar-3.14.tar.gz".
-CPAN checks if an install is actually needed for it and prints
-I<module up to date> in the case that the distribution file containing
-the module doesn't need to be updated.
+The C<module> related one will be matched against I<all> modules
+contained in the distribution until one module matches.
-CPAN also keeps track of what it has done within the current session
-and doesn't try to build a package a second time regardless if it
-succeeded or not. The C<force> pragma may precede another command
-(currently: C<make>, C<test>, or C<install>) and executes the
-command from scratch.
+The C<perl> related one will be matched against C<$^X> (but with the
+absolute path).
-Example:
+The value associated with C<perlconfig> is itself a hashref that is
+matched against corresponding values in the C<%Config::Config> hash
+living in the C<Config.pm> module.
+Keys prefixed with C<not_> negates the corresponding match.
- cpan> install OpenGL
- OpenGL is up to date.
- cpan> force install OpenGL
- Running make
- OpenGL-0.4/
- OpenGL-0.4/COPYRIGHT
- [...]
+The value associated with C<env> is itself a hashref that is
+matched against corresponding values in the C<%ENV> hash.
+Keys prefixed with C<not_> negates the corresponding match.
-The C<notest> pragma may be set to skip the test part in the build
-process.
+If more than one restriction of C<module>, C<distribution>, etc. is
+specified, the results of the separately computed match values must
+all match. If so, the hashref represented by the
+YAML document is returned as the preference structure for the current
+distribution.
-Example:
+=item patches [array]
- cpan> notest install Tk
+An array of patches on CPAN or on the local disk to be applied in
+order via an external patch program. If the value for the C<-p>
+parameter is C<0> or C<1> is determined by reading the patch
+beforehand. The path to each patch is either an absolute path on the
+local filesystem or relative to a patch directory specified in the
+C<patches_dir> configuration variable or in the format of a canonical
+distroname. For examples please consult the distroprefs/ directory in
+the CPAN.pm distribution (these examples are not installed by
+default).
-A C<clean> command results in a
+Note: if the C<applypatch> program is installed and C<CPAN::Config>
+knows about it B<and> a patch is written by the C<makepatch> program,
+then C<CPAN.pm> lets C<applypatch> apply the patch. Both C<makepatch>
+and C<applypatch> are available from CPAN in the C<JV/makepatch-*>
+distribution.
- make clean
+=item pl [hash]
-being executed within the distribution file's working directory.
+Processing instructions for the C<perl Makefile.PL> or C<perl
+Build.PL> phase of the CPAN mantra. See below under I<Processing
+Instructions>.
-=item get, readme, perldoc, look module or distribution
+=item test [hash]
-C<get> downloads a distribution file without further action. C<readme>
-displays the README file of the associated distribution. C<Look> gets
-and untars (if not yet done) the distribution file, changes to the
-appropriate directory and opens a subshell process in that directory.
-C<perldoc> displays the pod documentation of the module in html or
-plain text format.
+Processing instructions for the C<make test> or C<./Build test> phase
+of the CPAN mantra. See below under I<Processing Instructions>.
-=item ls author
+=back
-=item ls globbing_expresion
+=head2 Processing Instructions
-The first form lists all distribution files in and below an author's
-CPAN directory as they are stored in the CHECKUMS files distrbute on
-CPAN.
+=over
-The second form allows to limit or expand the output with shell
-globbing as in the following examples:
+=item args [array]
- ls JV/make*
- ls GSAR/*make*
- ls */*make*
+Arguments to be added to the command line
-The last example is very slow and outputs extra progress indicators
-that break the alignment of the result.
+=item commandline
-=item Signals
+A full commandline to run via C<system()>.
+During execution, the environment variable PERL is set
+to $^X (but with an absolute path). If C<commandline> is specified,
+C<args> is not used.
-CPAN.pm installs signal handlers for SIGINT and SIGTERM. While you are
-in the cpan-shell it is intended that you can press C<^C> anytime and
-return to the cpan-shell prompt. A SIGTERM will cause the cpan-shell
-to clean up and leave the shell loop. You can emulate the effect of a
-SIGTERM by sending two consecutive SIGINTs, which usually means by
-pressing C<^C> twice.
+=item eexpect [hash]
-CPAN.pm ignores a SIGPIPE. If the user sets inactivity_timeout, a
-SIGALRM is used during the run of the C<perl Makefile.PL> or C<perl
-Build.PL> subprocess.
+Extended C<expect>. This is a hash reference with four allowed keys,
+C<mode>, C<timeout>, C<reuse>, and C<talk>.
-=back
+C<mode> may have the values C<deterministic> for the case where all
+questions come in the order written down and C<anyorder> for the case
+where the questions may come in any order. The default mode is
+C<deterministic>.
-=head2 CPAN::Shell
+C<timeout> denotes a timeout in seconds. Floating-point timeouts are
+OK. With C<mode=deterministic>, the timeout denotes the
+timeout per question; with C<mode=anyorder> it denotes the
+timeout per byte received from the stream or questions.
-The commands that are available in the shell interface are methods in
-the package CPAN::Shell. If you enter the shell command, all your
-input is split by the Text::ParseWords::shellwords() routine which
-acts like most shells do. The first word is being interpreted as the
-method to be called and the rest of the words are treated as arguments
-to this method. Continuation lines are supported if a line ends with a
-literal backslash.
+C<talk> is a reference to an array that contains alternating questions
+and answers. Questions are regular expressions and answers are literal
+strings. The Expect module watches the stream from the
+execution of the external program (C<perl Makefile.PL>, C<perl
+Build.PL>, C<make>, etc.).
-=head2 autobundle
+For C<mode=deterministic>, the CPAN.pm injects the
+corresponding answer as soon as the stream matches the regular expression.
-C<autobundle> writes a bundle file into the
-C<$CPAN::Config-E<gt>{cpan_home}/Bundle> directory. The file contains
-a list of all modules that are both available from CPAN and currently
-installed within @INC. The name of the bundle file is based on the
-current date and a counter.
+For C<mode=anyorder> CPAN.pm answers a question as soon
+as the timeout is reached for the next byte in the input stream. In
+this mode you can use the C<reuse> parameter to decide what will
+happen with a question-answer pair after it has been used. In the
+default case (reuse=0) it is removed from the array, avoiding being
+used again accidentally. If you want to answer the
+question C<Do you really want to do that> several times, then it must
+be included in the array at least as often as you want this answer to
+be given. Setting the parameter C<reuse> to 1 makes this repetition
+unnecessary.
-=head2 recompile
+=item env [hash]
-recompile() is a very special command in that it takes no argument and
-runs the make/test/install cycle with brute force over all installed
-dynamically loadable extensions (aka XS modules) with 'force' in
-effect. The primary purpose of this command is to finish a network
-installation. Imagine, you have a common source tree for two different
-architectures. You decide to do a completely independent fresh
-installation. You start on one architecture with the help of a Bundle
-file produced earlier. CPAN installs the whole Bundle for you, but
-when you try to repeat the job on the second architecture, CPAN
-responds with a C<"Foo up to date"> message for all modules. So you
-invoke CPAN's recompile on the second architecture and you're done.
+Environment variables to be set during the command
-Another popular use for C<recompile> is to act as a rescue in case your
-perl breaks binary compatibility. If one of the modules that CPAN uses
-is in turn depending on binary compatibility (so you cannot run CPAN
-commands), then you should try the CPAN::Nox module for recovery.
+=item expect [array]
-=head2 The four C<CPAN::*> Classes: Author, Bundle, Module, Distribution
+C<< expect: <array> >> is a short notation for
-Although it may be considered internal, the class hierarchy does matter
-for both users and programmer. CPAN.pm deals with above mentioned four
-classes, and all those classes share a set of methods. A classical
-single polymorphism is in effect. A metaclass object registers all
-objects of all kinds and indexes them with a string. The strings
-referencing objects have a separated namespace (well, not completely
-separated):
+eexpect:
+ mode: deterministic
+ timeout: 15
+ talk: <array>
- Namespace Class
+=back
- words containing a "/" (slash) Distribution
- words starting with Bundle:: Bundle
- everything else Module or Author
+=head2 Schema verification with C<Kwalify>
-Modules know their associated Distribution objects. They always refer
-to the most recent official release. Developers may mark their releases
-as unstable development versions (by inserting an underbar into the
-module version number which will also be reflected in the distribution
-name when you run 'make dist'), so the really hottest and newest
-distribution is not always the default. If a module Foo circulates
-on CPAN in both version 1.23 and 1.23_90, CPAN.pm offers a convenient
-way to install version 1.23 by saying
+If you have the C<Kwalify> module installed (which is part of the
+Bundle::CPANxxl), then all your distroprefs files are checked for
+syntactic correctness.
- install Foo
+=head2 Example Distroprefs Files
-This would install the complete distribution file (say
-BAR/Foo-1.23.tar.gz) with all accompanying material. But if you would
-like to install version 1.23_90, you need to know where the
-distribution file resides on CPAN relative to the authors/id/
-directory. If the author is BAR, this might be BAR/Foo-1.23_90.tar.gz;
-so you would have to say
+C<CPAN.pm> comes with a collection of example YAML files. Note that these
+are really just examples and should not be used without care because
+they cannot fit everybody's purpose. After all, the authors of the
+packages that ask questions had a need to ask, so you should watch
+their questions and adjust the examples to your environment and your
+needs. You have been warned:-)
- install BAR/Foo-1.23_90.tar.gz
+=head1 PROGRAMMER'S INTERFACE
-The first example will be driven by an object of the class
-CPAN::Module, the second by an object of class CPAN::Distribution.
+If you do not enter the shell, shell commands are
+available both as methods (C<CPAN::Shell-E<gt>install(...)>) and as
+functions in the calling package (C<install(...)>). Before calling low-level
+commands, it makes sense to initialize components of CPAN you need, e.g.:
-=head2 Programmer's interface
+ CPAN::HandleConfig->load;
+ CPAN::Shell::setup_output;
+ CPAN::Index->reload;
-If you do not enter the shell, the available shell commands are both
-available as methods (C<CPAN::Shell-E<gt>install(...)>) and as
-functions in the calling package (C<install(...)>).
+High-level commands do such initializations automatically.
There's currently only one class that has a stable interface -
CPAN::Shell. All commands that are available in the CPAN shell are
be expanded to the corresponding real objects with the
C<CPAN::Shell-E<gt>expand("Module",@things)> method. Expand returns a
list of CPAN::Module objects according to the C<@things> arguments
-given. In scalar context it only returns the first element of the
+given. In scalar context, it returns only the first element of the
list.
=item expandany(@things)
Like expand, but returns objects of the appropriate type, i.e.
-CPAN::Bundle objects for bundles, CPAN::Module objects for modules and
-CPAN::Distribution objects fro distributions.
+CPAN::Bundle objects for bundles, CPAN::Module objects for modules, and
+CPAN::Distribution objects for distributions. Note: it does not expand
+to CPAN::Author objects.
=item Programming Examples
perl -MCPAN -e 'CPAN::Shell->install(CPAN::Shell->r)'
# install my favorite programs if necessary:
- for $mod (qw(Net::FTP Digest::SHA Data::Dumper)){
- my $obj = CPAN::Shell->expand('Module',$mod);
- $obj->install;
+ for $mod (qw(Net::FTP Digest::SHA Data::Dumper)) {
+ CPAN::Shell->install($mod);
}
# list all modules on my disk that have no VERSION number
- for $mod (CPAN::Shell->expand("Module","/./")){
- next unless $mod->inst_file;
+ for $mod (CPAN::Shell->expand("Module","/./")) {
+ next unless $mod->inst_file;
# MakeMaker convention for undefined $VERSION:
- next unless $mod->inst_version eq "undef";
- print "No VERSION in ", $mod->id, "\n";
+ next unless $mod->inst_version eq "undef";
+ print "No VERSION in ", $mod->id, "\n";
}
# find out which distribution on CPAN contains a module:
print CPAN::Shell->expand("Module","Apache::Constants")->cpan_file
-Or if you want to write a cronjob to watch The CPAN, you could list
+Or if you want to schedule a I<cron> job to watch CPAN, you could list
all modules that need updating. First a quick and dirty way:
perl -e 'use CPAN; CPAN::Shell->r;'
-If you don't want to get any output in the case that all modules are
-up to date, you can parse the output of above command for the regular
-expression //modules are up to date// and decide to mail the output
-only if it doesn't match. Ick?
+If you don't want any output should all modules be
+up to date, parse the output of above command for the regular
+expression C</modules are up to date/> and decide to mail the output
+only if it doesn't match.
-If you prefer to do it more in a programmer style in one single
-process, maybe something like this suits you better:
+If you prefer to do it more in a programmerish style in one single
+process, something like this may better suit you:
# list all modules on my disk that have newer versions on CPAN
- for $mod (CPAN::Shell->expand("Module","/./")){
+ for $mod (CPAN::Shell->expand("Module","/./")) {
next unless $mod->inst_file;
next if $mod->uptodate;
printf "Module %s is installed as %s, could be updated to %s from CPAN\n",
$mod->id, $mod->inst_version, $mod->cpan_version;
}
-If that gives you too much output every day, you maybe only want to
-watch for three modules. You can write
+If that gives too much output every day, you may want to
+watch only for three modules. You can write
- for $mod (CPAN::Shell->expand("Module","/Apache|LWP|CGI/")){
+ for $mod (CPAN::Shell->expand("Module","/Apache|LWP|CGI/")) {
as the first line instead. Or you can combine some of the above
tricks:
=head2 Methods in the other Classes
-The programming interface for the classes CPAN::Module,
-CPAN::Distribution, CPAN::Bundle, and CPAN::Author is still considered
-beta and partially even alpha. In the following paragraphs only those
-methods are documented that have proven useful over a longer time and
-thus are unlikely to change.
-
=over 4
=item CPAN::Author::as_glimpse()
=item CPAN::Bundle::force($method,@args)
-Forces CPAN to perform a task that normally would have failed. Force
-takes as arguments a method name to be called and any number of
-additional arguments that should be passed to the called method. The
-internals of the object get the needed changes so that CPAN.pm does
-not refuse to take the action. The C<force> is passed recursively to
-all contained objects.
+Forces CPAN to perform a task that it normally would have refused to
+do. Force takes as arguments a method name to be called and any number
+of additional arguments that should be passed to the called method.
+The internals of the object get the needed changes so that CPAN.pm
+does not refuse to take the action. The C<force> is passed recursively
+to all contained objects. See also the section above on the C<force>
+and the C<fforce> pragma.
=item CPAN::Bundle::get()
Returns a multi-line description of the distribution
+=item CPAN::Distribution::author
+
+Returns the CPAN::Author object of the maintainer who uploaded this
+distribution
+
+=item CPAN::Distribution::pretty_id()
+
+Returns a string of the form "AUTHORID/TARBALL", where AUTHORID is the
+author's PAUSE ID and TARBALL is the distribution filename.
+
+=item CPAN::Distribution::base_id()
+
+Returns the distribution filename without any archive suffix. E.g
+"Foo-Bar-0.01"
+
=item CPAN::Distribution::clean()
Changes to the directory where the distribution has been unpacked and
=item CPAN::Distribution::containsmods()
Returns a list of IDs of modules contained in a distribution file.
-Only works for distributions listed in the 02packages.details.txt.gz
-file. This typically means that only the most recent version of a
+Works only for distributions listed in the 02packages.details.txt.gz
+file. This typically means that just most recent version of a
distribution is covered.
=item CPAN::Distribution::cvs_import()
=item CPAN::Distribution::force($method,@args)
-Forces CPAN to perform a task that normally would have failed. Force
-takes as arguments a method name to be called and any number of
-additional arguments that should be passed to the called method. The
-internals of the object get the needed changes so that CPAN.pm does
-not refuse to take the action.
+Forces CPAN to perform a task that it normally would have refused to
+do. Force takes as arguments a method name to be called and any number
+of additional arguments that should be passed to the called method.
+The internals of the object get the needed changes so that CPAN.pm
+does not refuse to take the action. See also the section above on the
+C<force> and the C<fforce> pragma.
=item CPAN::Distribution::get()
Changes to the directory where the distribution has been unpacked and
runs the external command C<make install> there. If C<make> has not
-yet been run, it will be run first. A C<make test> will be issued in
-any case and if this fails, the install will be canceled. The
+yet been run, it will be run first. A C<make test> is issued in
+any case and if this fails, the install is cancelled. The
cancellation can be avoided by letting C<force> run the C<install> for
you.
+This install method only has the power to install the distribution if
+there are no dependencies in the way. To install an object along with all
+its dependencies, use CPAN::Shell->install.
+
+Note that install() gives no meaningful return value. See uptodate().
+
+=item CPAN::Distribution::install_tested()
+
+Install all distributions that have tested sucessfully but
+not yet installed. See also C<is_tested>.
+
=item CPAN::Distribution::isa_perl()
Returns 1 if this distribution file seems to be a perl distribution.
distribution has been unpacked and runs the external commands C<perl
Makefile.PL> or C<perl Build.PL> and C<make> there.
+=item CPAN::Distribution::perldoc()
+
+Downloads the pod documentation of the file associated with a
+distribution (in HTML format) and runs it through the external
+command I<lynx> specified in C<$CPAN::Config->{lynx}>. If I<lynx>
+isn't available, it converts it to plain text with the external
+command I<html2text> and runs it through the pager specified
+in C<$CPAN::Config->{pager}>
+
+=item CPAN::Distribution::prefs()
+
+Returns the hash reference from the first matching YAML file that the
+user has deposited in the C<prefs_dir/> directory. The first
+succeeding match wins. The files in the C<prefs_dir/> are processed
+alphabetically, and the canonical distroname (e.g.
+AUTHOR/Foo-Bar-3.14.tar.gz) is matched against the regular expressions
+stored in the $root->{match}{distribution} attribute value.
+Additionally all module names contained in a distribution are matched
+against the regular expressions in the $root->{match}{module} attribute
+value. The two match values are ANDed together. Each of the two
+attributes are optional.
+
=item CPAN::Distribution::prereq_pm()
Returns the hash reference that has been announced by a distribution
-as the C<requires> element of the META.yml or the C<PREREQ_PM> hash in
-the C<Makefile.PL>. Note: works only after an attempt has been made to
-C<make> the distribution. Returns undef otherwise.
+as the C<requires> and C<build_requires> elements. These can be
+declared either by the C<META.yml> (if authoritative) or can be
+deposited after the run of C<Build.PL> in the file C<./_build/prereqs>
+or after the run of C<Makfile.PL> written as the C<PREREQ_PM> hash in
+a comment in the produced C<Makefile>. I<Note>: this method only works
+after an attempt has been made to C<make> the distribution. Returns
+undef otherwise.
=item CPAN::Distribution::readme()
Downloads the README file associated with a distribution and runs it
through the pager specified in C<$CPAN::Config->{pager}>.
-=item CPAN::Distribution::perldoc()
+=item CPAN::Distribution::reports()
-Downloads the pod documentation of the file associated with a
-distribution (in html format) and runs it through the external
-command lynx specified in C<$CPAN::Config->{lynx}>. If lynx
-isn't available, it converts it to plain text with external
-command html2text and runs it through the pager specified
-in C<$CPAN::Config->{pager}>
+Downloads report data for this distribution from www.cpantesters.org
+and displays a subset of them.
+
+=item CPAN::Distribution::read_yaml()
+
+Returns the content of the META.yml of this distro as a hashref. Note:
+works only after an attempt has been made to C<make> the distribution.
+Returns undef otherwise. Also returns undef if the content of META.yml
+is not authoritative. (The rules about what exactly makes the content
+authoritative are still in flux.)
=item CPAN::Distribution::test()
=item CPAN::Module::as_glimpse()
-Returns a one-line description of the module
+Returns a one-line description of the module in four columns: The
+first column contains the word C<Module>, the second column consists
+of one character: an equals sign if this module is already installed
+and uptodate, a less-than sign if this module is installed but can be
+upgraded, and a space if the module is not installed. The third column
+is the name of the module and the fourth column gives maintainer or
+distribution information.
=item CPAN::Module::as_string()
modules listed in The Module List (CPAN/modules/00modlist.long.html
or 00modlist.long.txt.gz)
+=item CPAN::Module::distribution()
+
+Returns the CPAN::Distribution object that contains the current
+version of this module.
+
+=item CPAN::Module::dslip_status()
+
+Returns a hash reference. The keys of the hash are the letters C<D>,
+C<S>, C<L>, C<I>, and <P>, for development status, support level,
+language, interface and public licence respectively. The data for the
+DSLIP status are collected by pause.perl.org when authors register
+their namespaces. The values of the 5 hash elements are one-character
+words whose meaning is described in the table below. There are also 5
+hash elements C<DV>, C<SV>, C<LV>, C<IV>, and <PV> that carry a more
+verbose value of the 5 status variables.
+
+Where the 'DSLIP' characters have the following meanings:
+
+ D - Development Stage (Note: *NO IMPLIED TIMESCALES*):
+ i - Idea, listed to gain consensus or as a placeholder
+ c - under construction but pre-alpha (not yet released)
+ a/b - Alpha/Beta testing
+ R - Released
+ M - Mature (no rigorous definition)
+ S - Standard, supplied with Perl 5
+
+ S - Support Level:
+ m - Mailing-list
+ d - Developer
+ u - Usenet newsgroup comp.lang.perl.modules
+ n - None known, try comp.lang.perl.modules
+ a - abandoned; volunteers welcome to take over maintainance
+
+ L - Language Used:
+ p - Perl-only, no compiler needed, should be platform independent
+ c - C and perl, a C compiler will be needed
+ h - Hybrid, written in perl with optional C code, no compiler needed
+ + - C++ and perl, a C++ compiler will be needed
+ o - perl and another language other than C or C++
+
+ I - Interface Style
+ f - plain Functions, no references used
+ h - hybrid, object and function interfaces available
+ n - no interface at all (huh?)
+ r - some use of unblessed References or ties
+ O - Object oriented using blessed references and/or inheritance
+
+ P - Public License
+ p - Standard-Perl: user may choose between GPL and Artistic
+ g - GPL: GNU General Public License
+ l - LGPL: "GNU Lesser General Public License" (previously known as
+ "GNU Library General Public License")
+ b - BSD: The BSD License
+ a - Artistic license alone
+ 2 - Artistic license 2.0 or later
+ o - open source: appoved by www.opensource.org
+ d - allows distribution without restrictions
+ r - restricted distribtion
+ n - no license at all
+
=item CPAN::Module::force($method,@args)
-Forces CPAN to perform a task that normally would have failed. Force
-takes as arguments a method name to be called and any number of
-additional arguments that should be passed to the called method. The
-internals of the object get the needed changes so that CPAN.pm does
-not refuse to take the action.
+Forces CPAN to perform a task it would normally refuse to
+do. Force takes as arguments a method name to be invoked and any number
+of additional arguments to pass that method.
+The internals of the object get the needed changes so that CPAN.pm
+does not refuse to take the action. See also the section above on the
+C<force> and the C<fforce> pragma.
=item CPAN::Module::get()
=item CPAN::Module::inst_file()
Returns the filename of the module found in @INC. The first file found
-is reported just like perl itself stops searching @INC when it finds a
+is reported, just as perl itself stops searching @INC once it finds a
module.
+=item CPAN::Module::available_file()
+
+Returns the filename of the module found in PERL5LIB or @INC. The
+first file found is reported. The advantage of this method over
+C<inst_file> is that modules that have been tested but not yet
+installed are included because PERL5LIB keeps track of tested modules.
+
=item CPAN::Module::inst_version()
-Returns the version number of the module in readable format.
+Returns the version number of the installed module in readable format.
+
+=item CPAN::Module::available_version()
+
+Returns the version number of the available module in readable format.
=item CPAN::Module::install()
=item CPAN::Module::manpage_headline()
If module is installed, peeks into the module's manpage, reads the
-headline and returns it. Moreover, if the module has been downloaded
+headline, and returns it. Moreover, if the module has been downloaded
within this session, does the equivalent on the downloaded module even
-if it is not installed.
+if it hasn't been installed yet.
+
+=item CPAN::Module::perldoc()
+
+Runs a C<perldoc> on this module.
=item CPAN::Module::readme()
Runs a C<readme> on the distribution associated with this module.
-=item CPAN::Module::perldoc()
+=item CPAN::Module::reports()
-Runs a C<perldoc> on this module.
+Calls the reports() method on the associated distribution object.
=item CPAN::Module::test()
only difference being that I<one special pod section> exists starting with
(verbatim):
- =head1 CONTENTS
+ =head1 CONTENTS
In this pod section each line obeys the format
shell interface does that for you by including all currently installed
modules in a snapshot bundle file.
-=head2 Prerequisites
+=head1 PREREQUISITES
If you have a local mirror of CPAN and can access all files with
-"file:" URLs, then you only need a perl better than perl5.003 to run
+"file:" URLs, then you only need a perl later than perl5.003 to run
this module. Otherwise Net::FTP is strongly recommended. LWP may be
-required for non-UNIX systems or if your nearest CPAN site is
+required for non-UNIX systems, or if your nearest CPAN site is
associated with a URL that is not C<ftp:>.
If you have neither Net::FTP nor LWP, there is a fallback mechanism
implemented for an external ftp command or for an external lynx
command.
+=head1 UTILITIES
+
=head2 Finding packages and VERSION
This module presumes that all packages on CPAN
come as compressed or gzipped tarfiles or as zip files and contain a
C<Makefile.PL> or C<Build.PL> (well, we try to handle a bit more, but
-without much enthusiasm).
+with little enthusiasm).
=back
=head2 Debugging
-The debugging of this module is a bit complex, because we have
-interferences of the software producing the indices on CPAN, of the
-mirroring process on CPAN, of packaging, of configuration, of
-synchronicity, and of bugs within CPAN.pm.
-
-For code debugging in interactive mode you can try "o debug" which
-will list options for debugging the various parts of the code. You
-should know that "o debug" has built-in completion support.
-
-For data debugging there is the C<dump> command which takes the same
-arguments as make/test/install and outputs the object's Data::Dumper
-dump.
-
-=head2 Floppy, Zip, Offline Mode
-
-CPAN.pm works nicely without network too. If you maintain machines
-that are not networked at all, you should consider working with file:
-URLs. Of course, you have to collect your modules somewhere first. So
-you might use CPAN.pm to put together all you need on a networked
-machine. Then copy the $CPAN::Config->{keep_source_where} (but not
-$CPAN::Config->{build_dir}) directory on a floppy. This floppy is kind
-of a personal CPAN. CPAN.pm on the non-networked machines works nicely
-with this floppy. See also below the paragraph about CD-ROM support.
-
-=head1 CONFIGURATION
-
-When the CPAN module is used for the first time, a configuration
-dialog tries to determine a couple of site specific options. The
-result of the dialog is stored in a hash reference C< $CPAN::Config >
-in a file CPAN/Config.pm.
+Debugging this module is more than a bit complex due to interference from
+the software producing the indices on CPAN, the mirroring process on CPAN,
+packaging, configuration, synchronicity, and even (gasp!) due to bugs
+within the CPAN.pm module itself.
-The default values defined in the CPAN/Config.pm file can be
-overridden in a user specific file: CPAN/MyConfig.pm. Such a file is
-best placed in $HOME/.cpan/CPAN/MyConfig.pm, because $HOME/.cpan is
-added to the search path of the CPAN module before the use() or
-require() statements.
+For debugging the code of CPAN.pm itself in interactive mode, some
+debugging aid can be turned on for most packages within
+CPAN.pm with one of
-The configuration dialog can be started any time later again by
-issuing the command C< o conf init > in the CPAN shell.
+=over 2
-Currently the following keys in the hash reference $CPAN::Config are
-defined:
+=item o debug package...
- build_cache size of cache for directories to build modules
- build_dir locally accessible directory to build modules
- index_expire after this many days refetch index files
- cache_metadata use serializer to cache metadata
- cpan_home local directory reserved for this package
- dontload_hash anonymous hash: modules in the keys will not be
- loaded by the CPAN::has_inst() routine
- gzip location of external program gzip
- histfile file to maintain history between sessions
- histsize maximum number of lines to keep in histfile
- inactivity_timeout breaks interactive Makefile.PLs or Build.PLs
- after this many seconds inactivity. Set to 0 to
- never break.
- inhibit_startup_message
- if true, does not print the startup message
- keep_source_where directory in which to keep the source (if we do)
- make location of external make program
- make_arg arguments that should always be passed to 'make'
- make_install_make_command
- the make command for running 'make install', for
- example 'sudo make'
- make_install_arg same as make_arg for 'make install'
- makepl_arg arguments passed to 'perl Makefile.PL'
- mbuild_arg arguments passed to './Build'
- mbuild_install_arg arguments passed to './Build install'
- mbuild_install_build_command
- command to use instead of './Build' when we are
- in the install stage, for example 'sudo ./Build'
- mbuildpl_arg arguments passed to 'perl Build.PL'
- pager location of external program more (or any pager)
- prefer_installer legal values are MB and EUMM: if a module
- comes with both a Makefile.PL and a Build.PL, use
- the former (EUMM) or the latter (MB)
- prerequisites_policy
- what to do if you are missing module prerequisites
- ('follow' automatically, 'ask' me, or 'ignore')
- proxy_user username for accessing an authenticating proxy
- proxy_pass password for accessing an authenticating proxy
- scan_cache controls scanning of cache ('atstart' or 'never')
- tar location of external program tar
- term_is_latin if true internal UTF-8 is translated to ISO-8859-1
- (and nonsense for characters outside latin range)
- unzip location of external program unzip
- urllist arrayref to nearby CPAN sites (or equivalent locations)
- wait_list arrayref to a wait server to try (See CPAN::WAIT)
- ftp_proxy, } the three usual variables for configuring
- http_proxy, } proxy requests. Both as CPAN::Config variables
- no_proxy } and as environment variables configurable.
+sets debug mode for packages.
-You can set and query each of these options interactively in the cpan
-shell with the command set defined within the C<o conf> command:
+=item o debug -package...
-=over 2
+unsets debug mode for packages.
-=item C<o conf E<lt>scalar optionE<gt>>
+=item o debug all
-prints the current value of the I<scalar option>
+turns debugging on for all packages.
-=item C<o conf E<lt>scalar optionE<gt> E<lt>valueE<gt>>
+=item o debug number
-Sets the value of the I<scalar option> to I<value>
+=back
-=item C<o conf E<lt>list optionE<gt>>
+which sets the debugging packages directly. Note that C<o debug 0>
+turns debugging off.
-prints the current value of the I<list option> in MakeMaker's
-neatvalue format.
+What seems a successful strategy is the combination of C<reload
+cpan> and the debugging switches. Add a new debug statement while
+running in the shell and then issue a C<reload cpan> and see the new
+debugging messages immediately without losing the current context.
-=item C<o conf E<lt>list optionE<gt> [shift|pop]>
+C<o debug> without an argument lists the valid package names and the
+current set of packages in debugging mode. C<o debug> has built-in
+completion support.
-shifts or pops the array in the I<list option> variable
+For debugging of CPAN data there is the C<dump> command which takes
+the same arguments as make/test/install and outputs each object's
+Data::Dumper dump. If an argument looks like a perl variable and
+contains one of C<$>, C<@> or C<%>, it is eval()ed and fed to
+Data::Dumper directly.
-=item C<o conf E<lt>list optionE<gt> [unshift|push|splice] E<lt>listE<gt>>
+=head2 Floppy, Zip, Offline Mode
-works like the corresponding perl commands.
+CPAN.pm works nicely without network access, too. If you maintain machines
+that are not networked at all, you should consider working with C<file:>
+URLs. You'll have to collect your modules somewhere first. So
+you might use CPAN.pm to put together all you need on a networked
+machine. Then copy the $CPAN::Config->{keep_source_where} (but not
+$CPAN::Config->{build_dir}) directory on a floppy. This floppy is kind
+of a personal CPAN. CPAN.pm on the non-networked machines works nicely
+with this floppy. See also below the paragraph about CD-ROM support.
-=back
+=head2 Basic Utilities for Programmers
-=head2 Note on urllist parameter's format
+=over 2
-urllist parameters are URLs according to RFC 1738. We do a little
-guessing if your URL is not compliant, but if you have problems with
-file URLs, please try the correct format. Either:
+=item has_inst($module)
- file://localhost/whatever/ftp/pub/CPAN/
+Returns true if the module is installed. Used to load all modules into
+the running CPAN.pm that are considered optional. The config variable
+C<dontload_list> intercepts the C<has_inst()> call such
+that an optional module is not loaded despite being available. For
+example, the following command will prevent C<YAML.pm> from being
+loaded:
-or
+ cpan> o conf dontload_list push YAML
- file:///home/ftp/pub/CPAN/
+See the source for details.
-=head2 urllist parameter has CD-ROM support
+=item has_usable($module)
-The C<urllist> parameter of the configuration table contains a list of
-URLs that are to be used for downloading. If the list contains any
-C<file> URLs, CPAN always tries to get files from there first. This
-feature is disabled for index files. So the recommendation for the
-owner of a CD-ROM with CPAN contents is: include your local, possibly
-outdated CD-ROM as a C<file> URL at the end of urllist, e.g.
+Returns true if the module is installed and in a usable state. Only
+useful for a handful of modules that are used internally. See the
+source for details.
- o conf urllist push file://localhost/CDROM/CPAN
+=item instance($module)
-CPAN.pm will then fetch the index files from one of the CPAN sites
-that come at the beginning of urllist. It will later check for each
-module if there is a local copy of the most recent version.
+The constructor for all the singletons used to represent modules,
+distributions, authors, and bundles. If the object already exists, this
+method returns the object; otherwise, it calls the constructor.
-Another peculiarity of urllist is that the site that we could
-successfully fetch the last file from automatically gets a preference
-token and is tried as the first site for the next request. So if you
-add a new site at runtime it may happen that the previously preferred
-site will be tried another time. This means that if you want to disallow
-a site for the next transfer, it must be explicitly removed from
-urllist.
+=back
=head1 SECURITY
=head2 Cryptographically signed modules
-Since release 1.77 CPAN.pm has been able to verify cryptographically
+Since release 1.77, CPAN.pm has been able to verify cryptographically
signed module distributions using Module::Signature. The CPAN modules
can be signed by their authors, thus giving more security. The simple
unsigned MD5 checksums that were used before by CPAN protect mainly
You will also need to be able to connect over the Internet to the public
keyservers, like pgp.mit.edu, and their port 11731 (the HKP protocol).
+The configuration parameter check_sigs is there to turn signature
+checking on or off.
+
=head1 EXPORT
-Most functions in package CPAN are exported per default. The reason
+Most functions in package CPAN are exported by default. The reason
for this is that the primary use is intended for the cpan shell or for
one-liners.
+=head1 ENVIRONMENT
+
+When the CPAN shell enters a subshell via the look command, it sets
+the environment CPAN_SHELL_LEVEL to 1, or increments that variable if it is
+already set.
+
+When CPAN runs, it sets the environment variable PERL5_CPAN_IS_RUNNING
+to the ID of the running process. It also sets
+PERL5_CPANPLUS_IS_RUNNING to prevent runaway processes which could
+happen with older versions of Module::Install.
+
+When running C<perl Makefile.PL>, the environment variable
+C<PERL5_CPAN_IS_EXECUTING> is set to the full path of the
+C<Makefile.PL> that is being executed. This prevents runaway processes
+with newer versions of Module::Install.
+
+When the config variable ftp_passive is set, all downloads will be run
+with the environment variable FTP_PASSIVE set to this value. This is
+in general a good idea as it influences both Net::FTP and LWP based
+connections. The same effect can be achieved by starting the cpan
+shell with this environment variable set. For Net::FTP alone, one can
+also always set passive mode by running libnetcfg.
+
=head1 POPULATE AN INSTALLATION WITH LOTS OF MODULES
-Populating a freshly installed perl with my favorite modules is pretty
+Populating a freshly installed perl with one's favorite modules is pretty
easy if you maintain a private bundle definition file. To get a useful
blueprint of a bundle definition file, the command autobundle can be used
on the CPAN shell command line. This command writes a bundle definition
-file for all modules that are installed for the currently running perl
-interpreter. It's recommended to run this command only once and from then
+file for all modules installed for the current perl
+interpreter. It's recommended to run this command once only, and from then
on maintain the file manually under a private name, say
Bundle/my_bundle.pm. With a clever bundle file you can then simply say
cpan> install Bundle::my_bundle
-then answer a few questions and then go out for a coffee.
+then answer a few questions and go out for coffee (possibly
+even in a different city).
Maintaining a bundle definition file means keeping track of two
things: dependencies and interactivity. CPAN.pm sometimes fails on
calculating dependencies because not all modules define all MakeMaker
attributes correctly, so a bundle definition file should specify
-prerequisites as early as possible. On the other hand, it's a bit
-annoying that many distributions need some interactive configuring. So
-what I try to accomplish in my private bundle file is to have the
+prerequisites as early as possible. On the other hand, it's
+annoying that so many distributions need some interactive configuring. So
+what you can try to accomplish in your private bundle file is to have the
packages that need to be configured early in the file and the gentle
-ones later, so I can go out after a few minutes and leave CPAN.pm
-untended.
+ones later, so you can go out for cofeee after a few minutes and leave CPAN.pm
+to churn away untended.
=head1 WORKING WITH CPAN.pm BEHIND FIREWALLS
Thanks to Graham Barr for contributing the following paragraphs about
the interaction between perl, and various firewall configurations. For
further information on firewalls, it is recommended to consult the
-documentation that comes with the ncftp program. If you are unable to
-go through the firewall with a simple Perl setup, it is very likely
-that you can configure ncftp so that it works for your firewall.
+documentation that comes with the I<ncftp> program. If you are unable to
+go through the firewall with a simple Perl setup, it is likely
+that you can configure I<ncftp> so that it works through your firewall.
=head2 Three basic types of firewalls
=item http firewall
-This is where the firewall machine runs a web server and to access the
-outside world you must do it via the web server. If you set environment
-variables like http_proxy or ftp_proxy to a values beginning with http://
-or in your web browser you have to set proxy information then you know
-you are running an http firewall.
+This is when the firewall machine runs a web server, and to access the
+outside world, you must do so via that web server. If you set environment
+variables like http_proxy or ftp_proxy to values beginning with http://,
+or in your web browser you've proxy information set, then you know
+you are running behind an http firewall.
To access servers outside these types of firewalls with perl (even for
-ftp) you will need to use LWP.
+ftp), you need LWP.
=item ftp firewall
This where the firewall machine runs an ftp server. This kind of
firewall will only let you access ftp servers outside the firewall.
This is usually done by connecting to the firewall with ftp, then
-entering a username like "user@outside.host.com"
+entering a username like "user@outside.host.com".
-To access servers outside these type of firewalls with perl you
-will need to use Net::FTP.
+To access servers outside these type of firewalls with perl, you
+need Net::FTP.
-=item One way visibility
+=item One-way visibility
-I say one way visibility as these firewalls try to make themselves look
-invisible to the users inside the firewall. An FTP data connection is
-normally created by sending the remote server your IP address and then
-listening for the connection. But the remote server will not be able to
-connect to you because of the firewall. So for these types of firewall
+One-way visibility means these firewalls try to make themselves
+invisible to users inside the firewall. An FTP data connection is
+normally created by sending your IP address to the remote server and then
+listening for the return connection. But the remote server will not be able to
+connect to you because of the firewall. For these types of firewall,
FTP connections need to be done in a passive mode.
There are two that I can think off.
=item SOCKS
-If you are using a SOCKS firewall you will need to compile perl and link
-it with the SOCKS library, this is what is normally called a 'socksified'
+If you are using a SOCKS firewall, you will need to compile perl and link
+it with the SOCKS library. This is what is normally called a 'socksified'
perl. With this executable you will be able to connect to servers outside
-the firewall as if it is not there.
+the firewall as if it were not there.
=item IP Masquerade
-This is the firewall implemented in the Linux kernel, it allows you to
-hide a complete network behind one IP address. With this firewall no
-special compiling is needed as you can access hosts directly.
-
-For accessing ftp servers behind such firewalls you may need to set
-the environment variable C<FTP_PASSIVE> to a true value, e.g.
-
- env FTP_PASSIVE=1 perl -MCPAN -eshell
-
-or
-
- perl -MCPAN -e '$ENV{FTP_PASSIVE} = 1; shell'
+This is when the firewall implemented in the kernel (via NAT, or networking
+address translation), it allows you to hide a complete network behind one
+IP address. With this firewall no special compiling is needed as you can
+access hosts directly.
+For accessing ftp servers behind such firewalls you usually need to
+set the environment variable C<FTP_PASSIVE> or the config variable
+ftp_passive to a true value.
=back
I installed a new version of module X but CPAN keeps saying,
I have the old version installed
-Most probably you B<do> have the old version installed. This can
+Probably you B<do> have the old version installed. This can
happen if a module installs itself into a different directory in the
@INC path than it was previously installed. This is not really a
CPAN.pm problem, you would have the same problem when installing the
I am not root, how can I install a module in a personal directory?
First of all, you will want to use your own configuration, not the one
-that your root user installed. The following command sequence is a
-possible approach:
+that your root user installed. If you do not have permission to write
+in the cpan directory that root has configured, you will be asked if
+you want to create your own config. Answering "yes" will bring you into
+CPAN's configuration stage, using the system config for all defaults except
+things that have to do with CPAN's work directory, saving your choices to
+your MyConfig.pm file.
+
+You can also manually initiate this process with the following command:
+
+ % perl -MCPAN -e 'mkmyconfig'
+
+or by running
- % mkdir -p $HOME/.cpan/CPAN
- % echo '$CPAN::Config={ };' > $HOME/.cpan/CPAN/MyConfig.pm
- % cpan
- [...answer all questions...]
+ mkmyconfig
-You will most probably like something like this:
+from the CPAN shell.
+
+You will most probably also want to configure something like this:
o conf makepl_arg "LIB=~/myperl/lib \
INSTALLMAN1DIR=~/myperl/man/man1 \
- INSTALLMAN3DIR=~/myperl/man/man3"
+ INSTALLMAN3DIR=~/myperl/man/man3 \
+ INSTALLSCRIPT=~/myperl/bin \
+ INSTALLBIN=~/myperl/bin"
+
+and then the equivalent command for Module::Build, which is
+
+ o conf mbuildpl_arg "--lib=~/myperl/lib \
+ --installman1dir=~/myperl/man/man1 \
+ --installman3dir=~/myperl/man/man3 \
+ --installscript=~/myperl/bin \
+ --installbin=~/myperl/bin"
You can make this setting permanent like all C<o conf> settings with
-C<o conf commit>.
+C<o conf commit> or by setting C<auto_commit> beforehand.
You will have to add ~/myperl/man to the MANPATH environment variable
and also tell your perl programs to look into ~/myperl/lib, e.g. by
or setting the PERL5LIB environment variable.
-Another thing you should bear in mind is that the UNINST parameter
-should never be set if you are not root.
+While we're speaking about $ENV{HOME}, it might be worth mentioning,
+that for Windows we use the File::HomeDir module that provides an
+equivalent to the concept of the home directory on Unix.
+
+Another thing you should bear in mind is that the UNINST parameter can
+be dangerous when you are installing into a private area because you
+might accidentally remove modules that other people depend on that are
+not using the private area.
=item 6)
How to get a package, unwrap it, and make a change before building it?
- look Sybase::Sybperl
+Have a look at the C<look> (!) command.
=item 7)
The reason for this is that CPAN does not know the dependencies of all
modules when it starts out. To decide about the additional items to
-install, it just uses data found in the generated Makefile. An
-undetected missing piece breaks the process. But it may well be that
-your Bundle installs some prerequisite later than some depending item
-and thus your second try is able to resolve everything. Please note,
-CPAN.pm does not know the dependency tree in advance and cannot sort
-the queue of things to install in a topologically correct order. It
-resolves perfectly well IFF all modules declare the prerequisites
-correctly with the PREREQ_PM attribute to MakeMaker. For bundles which
-fail and you need to install often, it is recommended to sort the Bundle
-definition file manually. It is planned to improve the metadata
-situation for dependencies on CPAN in general, but this will still
-take some time.
+install, it just uses data found in the META.yml file or the generated
+Makefile. An undetected missing piece breaks the process. But it may
+well be that your Bundle installs some prerequisite later than some
+depending item and thus your second try is able to resolve everything.
+Please note, CPAN.pm does not know the dependency tree in advance and
+cannot sort the queue of things to install in a topologically correct
+order. It resolves perfectly well B<if> all modules declare the
+prerequisites correctly with the PREREQ_PM attribute to MakeMaker or
+the C<requires> stanza of Module::Build. For bundles which fail and
+you need to install often, it is recommended to sort the Bundle
+definition file manually.
=item 8)
-In our intranet we have many modules for internal use. How
+In our intranet, we have many modules for internal use. How
can I integrate these modules with CPAN.pm but without uploading
the modules to CPAN?
=item 9)
-When I run CPAN's shell, I get error msg about line 1 to 4,
-setting meta input/output via the /etc/inputrc file.
+When I run CPAN's shell, I get an error message about things in my
+C</etc/inputrc> (or C<~/.inputrc>) file.
-Some versions of readline are picky about capitalization in the
-/etc/inputrc file and specifically RedHat 6.2 comes with a
-/etc/inputrc that contains the word C<on> in lowercase. Change the
-occurrences of C<on> to C<On> and the bug should disappear.
+These are readline issues and can only be fixed by studying readline
+configuration on your architecture and adjusting the referenced file
+accordingly. Please make a backup of the C</etc/inputrc> or C<~/.inputrc>
+and edit them. Quite often harmless changes like uppercasing or
+lowercasing some arguments solves the problem.
=item 10)
term_is_latin to a true value in your config file. One way of doing so
would be
- cpan> ! $CPAN::Config->{term_is_latin}=1
+ cpan> o conf term_is_latin 1
-Extended support for converters will be made available as soon as perl
-becomes stable with regard to charset issues.
+If other charset support is needed, please file a bugreport against
+CPAN.pm at rt.cpan.org and describe your needs. Maybe we can extend
+the support or maybe UTF-8 terminals become widely available.
+
+Note: this config variable is deprecated and will be removed in a
+future version of CPAN.pm. It will be replaced with the conventions
+around the family of $LANG and $LC_* environment variables.
=item 11)
force install Foo::Bar
-This does a bit more than really needed because it untars the
-distribution again and runs make and test and only then install.
+Or you can use
-Or, if you find this is too fast and you would prefer to do smaller
-steps, say
+ look Foo::Bar
- force get Foo::Bar
+and then C<make install> directly in the subshell.
-first and then continue as always. C<Force get> I<forgets> previous
-error conditions.
+=item 12)
-Or you can use
+How do I install a "DEVELOPER RELEASE" of a module?
- look Foo::Bar
+By default, CPAN will install the latest non-developer release of a
+module. If you want to install a dev release, you have to specify the
+partial path starting with the author id to the tarball you wish to
+install, like so:
+
+ cpan> install KWILLIAMS/Module-Build-0.27_07.tar.gz
+
+Note that you can use the C<ls> command to get this path listed.
+
+=item 13)
-and then 'make install' directly in the subshell.
+How do I install a module and all its dependencies from the commandline,
+without being prompted for anything, despite my CPAN configuration
+(or lack thereof)?
-Or you leave the CPAN shell and start it again.
+CPAN uses ExtUtils::MakeMaker's prompt() function to ask its questions, so
+if you set the PERL_MM_USE_DEFAULT environment variable, you shouldn't be
+asked any questions at all (assuming the modules you are installing are
+nice about obeying that variable as well):
-For the really curious, by accessing internals directly, you I<could>
+ % PERL_MM_USE_DEFAULT=1 perl -MCPAN -e 'install My::Module'
- ! delete CPAN::Shell->expand("Distribution", \
- CPAN::Shell->expand("Module","Foo::Bar") \
- ->cpan_file)->{install}
+=item 14)
-but this is neither guaranteed to work in the future nor is it a
-decent command.
+How do I create a Module::Build based Build.PL derived from an
+ExtUtils::MakeMaker focused Makefile.PL?
+
+http://search.cpan.org/search?query=Module::Build::Convert
+
+http://www.refcnt.org/papers/module-build-convert
+
+=item 15)
+
+I'm frequently irritated with the CPAN shell's inability to help me
+select a good mirror.
+
+The urllist config parameter is yours. You can add and remove sites at
+will. You should find out which sites have the best uptodateness,
+bandwidth, reliability, etc. and are topologically close to you. Some
+people prefer fast downloads, others uptodateness, others reliability.
+You decide which to try in which order.
+
+Henk P. Penning maintains a site that collects data about CPAN sites:
+
+ http://www.cs.uu.nl/people/henkp/mirmon/cpan.html
+
+Also, feel free to play with experimental features. Run
+
+ o conf init randomize_urllist ftpstats_period ftpstats_size
+
+and choose your favorite parameters. After a few downloads running the
+C<hosts> command will probably assist you in choosing the best mirror
+sites.
+
+=item 16)
+
+Why do I get asked the same questions every time I start the shell?
+
+You can make your configuration changes permanent by calling the
+command C<o conf commit>. Alternatively set the C<auto_commit>
+variable to true by running C<o conf init auto_commit> and answering
+the following question with yes.
+
+=item 17)
+
+Older versions of CPAN.pm had the original root directory of all
+tarballs in the build directory. Now there are always random
+characters appended to these directory names. Why was this done?
+
+The random characters are provided by File::Temp and ensure that each
+module's individual build directory is unique. This makes running
+CPAN.pm in concurrent processes simultaneously safe.
+
+=item 18)
+
+Speaking of the build directory. Do I have to clean it up myself?
+
+You have the choice to set the config variable C<scan_cache> to
+C<never>. Then you must clean it up yourself. The other possible
+value, C<atstart> only cleans up the build directory when you start
+the CPAN shell. If you never start up the CPAN shell, you probably
+also have to clean up the build directory yourself.
=back
+=head1 COMPATIBILITY
+
+=head2 OLD PERL VERSIONS
+
+CPAN.pm is regularly tested to run under 5.004, 5.005, and assorted
+newer versions. It is getting more and more difficult to get the
+minimal prerequisites working on older perls. It is close to
+impossible to get the whole Bundle::CPAN working there. If you're in
+the position to have only these old versions, be advised that CPAN is
+designed to work fine without the Bundle::CPAN installed.
+
+To get things going, note that GBARR/Scalar-List-Utils-1.18.tar.gz is
+compatible with ancient perls and that File::Temp is listed as a
+prerequisite but CPAN has reasonable workarounds if it is missing.
+
+=head2 CPANPLUS
+
+This module and its competitor, the CPANPLUS module, are both much
+cooler than the other. CPAN.pm is older. CPANPLUS was designed to be
+more modular, but it was never intended to be compatible with CPAN.pm.
+
+=head1 SECURITY ADVICE
+
+This software enables you to upgrade software on your computer and so
+is inherently dangerous because the newly installed software may
+contain bugs and may alter the way your computer works or even make it
+unusable. Please consider backing up your data before every upgrade.
+
=head1 BUGS
-If a Makefile.PL requires special customization of libraries, prompts
-the user for special input, etc. then you may find CPAN is not able to
-build the distribution. In that case it is recommended to attempt the
-traditional method of building a Perl module package from a shell, for
-example by using the 'look' command to open a subshell in the
-distribution's own directory.
+Please report bugs via L<http://rt.cpan.org/>
+
+Before submitting a bug, please make sure that the traditional method
+of building a Perl module package from a shell by following the
+installation instructions of that package still works in your
+environment.
=head1 AUTHOR
Andreas Koenig C<< <andk@cpan.org> >>
+=head1 LICENSE
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<http://www.perl.com/perl/misc/Artistic.html>
+
=head1 TRANSLATIONS
Kawai,Takanori provides a Japanese translation of this manpage at
-http://member.nifty.ne.jp/hippo2000/perltips/CPAN.htm
+L<http://homepage3.nifty.com/hippo2000/perltips/CPAN.htm>
=head1 SEE ALSO
-cpan(1), CPAN::Nox(3pm), CPAN::Version(3pm)
+L<cpan>, L<CPAN::Nox>, L<CPAN::Version>
=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# End:
projects / p5sagit/p5-mst-13.2.git / blobdiff