#!/usr/bin/env perl

#

# You want to install cpanminus? Run the following command and it will

# install itself for you. You might want to run it as a root with sudo

# if you want to install to places like /usr/local/bin.

#

#   % curl -L http://cpanmin.us | perl - --self-upgrade

#

# If you don't have curl but wget, replace `curl -L` with `wget -O -`.

#

# For more details about this program, visit http://search.cpan.org/dist/App-cpanminus

#

# DO NOT EDIT -- this is an auto generated file

# This chunk of stuff was generated by App::FatPacker. To find the original

# file's code, look for the end of this BEGIN block or the string 'FATPACK'

BEGIN {

my %fatpacked;

$fatpacked{"App/cpanminus.pm"} = <<'APP_CPANMINUS';

  package App::cpanminus;

  our $VERSION = "1.6005";

  =head1 NAME

  App::cpanminus - get, unpack, build and install modules from CPAN

  =head1 SYNOPSIS

      cpanm Module

  Run C<cpanm -h> or C<perldoc cpanm> for more options.

  =head1 DESCRIPTION

  cpanminus is a script to get, unpack, build and install modules from

  CPAN and does nothing else.

  It's dependency free (can bootstrap itself), requires zero

  configuration, and stands alone. When running, it requires only 10MB

  of RAM.

  =head1 INSTALLATION

  There are several ways to install cpanminus to your system.

  =head2 Package management system

  There are Debian packages, RPMs, FreeBSD ports, and packages for other

  operation systems available. If you want to use the package management system,

  search for cpanminus and use the appropriate command to install. This makes it

  easy to install C<cpanm> to your system without thinking about where to

  install, and later upgrade.

  =head2 Installing to system perl

  You can also use the latest cpanminus to install cpanminus itself:

      curl -L http://cpanmin.us | perl - --sudo App::cpanminus

  This will install C<cpanm> to your bin directory like

  C</usr/local/bin> (unless you configured C<INSTALL_BASE> with

  L<local::lib>), so you probably need the C<--sudo> option.

  =head2 Installing to local perl (perlbrew)

  If you have perl in your home directory, which is the case if you use

  tools like L<perlbrew>, you don't need the C<--sudo> option, since

  you're most likely to have a write permission to the perl's library

  path. You can just do:

      curl -L http://cpanmin.us | perl - App::cpanminus

  to install the C<cpanm> executable to the perl's bin path, like

  C<~/perl5/perlbrew/bin/cpanm>.

  =head2 Downloading the standalone executable

  You can also copy the standalone executable to whatever location you'd like.

      cd ~/bin

      curl -LO http://xrl.us/cpanm

      chmod +x cpanm

      # edit shebang if you don't have /usr/bin/env

  This just works, but be sure to grab the new version manually when you

  upgrade because C<--self-upgrade> might not work for this.

  =head1 DEPENDENCIES

  perl 5.8 or later.

  =over 4

  =item *

  'tar' executable (bsdtar or GNU tar version 1.22 are rcommended) or Archive::Tar to unpack files.

  =item *

  C compiler, if you want to build XS modules.

  =item *

  make

  =item *

  Module::Build (core in 5.10)

  =back

  =head1 QUESTIONS

  =head2 Another CPAN installer?

  OK, the first motivation was this: the CPAN shell runs out of memory (or swaps

  heavily and gets really slow) on Slicehost/linode's most affordable plan with

  only 256MB RAM. Should I pay more to install perl modules from CPAN? I don't

  think so.

  =head2 But why a new client?

  First of all, let me be clear that CPAN and CPANPLUS are great tools

  I've used for I<literally> years (you know how many modules I have on

  CPAN, right?). I really respect their efforts of maintaining the most

  important tools in the CPAN toolchain ecosystem.

  However, for less experienced users (mostly from outside the Perl community),

  or even really experienced Perl developers who know how to shoot themselves in

  their feet, setting up the CPAN toolchain often feels like yak shaving,

  especially when all they want to do is just install some modules and start

  writing code.

  =head2 Zero-conf? How does this module get/parse/update the CPAN index?

  It queries the CPAN Meta DB site at L<http://cpanmetadb.plackperl.org/>.

  The site is updated at least every hour to reflect the latest changes

  from fast syncing mirrors. The script then also falls back to query the

  module at L<http://metacpan.org/> using its wonderful API.

  Fetched files are unpacked in C<~/.cpanm> and automatically cleaned up

  periodically.  You can configure the location of this with the

  C<PERL_CPANM_HOME> environment variable.

  =head2 Where does this install modules to? Do I need root access?

  It installs to wherever ExtUtils::MakeMaker and Module::Build are

  configured to (via C<PERL_MM_OPT> and C<PERL_MB_OPT>). So if you're

  using local::lib, then it installs to your local perl5

  directory. Otherwise it installs to the site_perl directory that

  belongs to your perl.

  cpanminus at a boot time checks whether you have configured

  local::lib, or have the permission to install modules to the site_perl

  directory.  If neither, it automatically sets up local::lib compatible

  installation path in a C<perl5> directory under your home

  directory. To avoid this, run the script as the root user, with

  C<--sudo> option or with C<--local-lib> option.

  =head2 cpanminus can't install the module XYZ. Is it a bug?

  It is more likely a problem with the distribution itself. cpanminus

  doesn't support or is known to have issues with distributions like as

  follows:

  =over 4

  =item *

  Tests that require input from STDIN.

  =item *

  Tests that might fail when C<AUTOMATED_TESTING> is enabled.

  =item *

  Modules that have invalid numeric values as VERSION (such as C<1.1a>)

  =back

  These failures can be reported back to the author of the module so

  that they can fix it accordingly, rather than me.

  =head2 Does cpanm support the feature XYZ of L<CPAN> and L<CPANPLUS>?

  Most likely not. Here are the things that cpanm doesn't do by

  itself. And it's a feature - you got that from the name I<minus>,

  right?

  If you need these features, use L<CPAN>, L<CPANPLUS> or the standalone

  tools that are mentioned.

  =over 4

  =item *

  Bundle:: module dependencies

  =item *

  CPAN testers reporting

  =item *

  Building RPM packages from CPAN modules

  =item *

  Listing the outdated modules that needs upgrading. See L<App::cpanoutdated>

  =item *

  Uninstalling modules. See L<pm-uninstall>.

  =item *

  Showing the changes of the modules you're about to upgrade. See L<cpan-listchanges>

  =item *

  Patching CPAN modules with distroprefs.

  =back

  See L<cpanm> or C<cpanm -h> to see what cpanminus I<can> do :)

  =head1 COPYRIGHT

  Copyright 2010- Tatsuhiko Miyagawa

  The standalone executable contains the following modules embedded.

  =over 4

  =item L<CPAN::DistnameInfo> Copyright 2003 Graham Barr

  =item L<Parse::CPAN::Meta> Copyright 2006-2009 Adam Kennedy

  =item L<local::lib> Copyright 2007-2009 Matt S Trout

  =item L<HTTP::Tiny> Copyright 2011 Christian Hansen

  =item L<Module::Metadata> Copyright 2001-2006 Ken Williams. 2010 Matt S Trout

  =item L<version> Copyright 2004-2010 John Peacock

  =item L<JSON::PP> Copyright 2007−2011 by Makamaka Hannyaharamitu

  =item L<CPAN::Meta>, L<CPAN::Meta::Requirements> Copyright (c) 2010 by David Golden and Ricardo Signes

  =item L<CPAN::Meta::YAML> Copyright 2010 Adam Kennedy

  =item L<File::pushd> Copyright 2012 David Golden

  =back

  =head1 LICENSE

  Same as Perl.

  =head1 CREDITS

  =head2 CONTRIBUTORS

  Patches and code improvements were contributed by:

  Goro Fuji, Kazuhiro Osawa, Tokuhiro Matsuno, Kenichi Ishigaki, Ian

  Wells, Pedro Melo, Masayoshi Sekimura, Matt S Trout (mst), squeeky,

  horus and Ingy dot Net.

  =head2 ACKNOWLEDGEMENTS

  Bug reports, suggestions and feedbacks were sent by, or general

  acknowledgement goes to:

  Jesse Vincent, David Golden, Andreas Koenig, Jos Boumans, Chris

  Williams, Adam Kennedy, Audrey Tang, J. Shirley, Chris Prather, Jesse

  Luehrs, Marcus Ramberg, Shawn M Moore, chocolateboy, Chirs Nehren,

  Jonathan Rockway, Leon Brocard, Simon Elliott, Ricardo Signes, AEvar

  Arnfjord Bjarmason, Eric Wilhelm, Florian Ragwitz and xaicron.

  =head1 COMMUNITY

  =over 4

  =item L<http://github.com/miyagawa/cpanminus> - source code repository, issue tracker

  =item L<irc://irc.perl.org/#toolchain> - discussions about Perl toolchain. I'm there.

  =back

  =head1 NO WARRANTY

  This software is provided "as-is," without any express or implied

  warranty. In no event shall the author be held liable for any damages

  arising from the use of the software.

  =head1 SEE ALSO

  L<CPAN> L<CPANPLUS> L<pip>

  =cut

  1;

APP_CPANMINUS

$fatpacked{"App/cpanminus/script.pm"} = <<'APP_CPANMINUS_SCRIPT';

  package App::cpanminus::script;

  use strict;

  use Config;

  use Cwd ();

  use App::cpanminus;

  use File::Basename ();

  use File::Find ();

  use File::Path ();

  use File::Spec ();

  use File::Copy ();

  use File::Temp ();

  use Getopt::Long ();

  use Parse::CPAN::Meta;

  use Symbol ();

  use constant WIN32 => $^O eq 'MSWin32';

  use constant SUNOS => $^O eq 'solaris';

  our $VERSION = $App::cpanminus::VERSION;

  if ($INC{"App/FatPacker/Trace.pm"}) {

      require JSON::PP;

      require CPAN::Meta::YAML;

      require CPAN::Meta::Prereqs;

      require version::vpp;

      require File::pushd;

  }

  my $quote = WIN32 ? q/"/ : q/'/;

  sub agent {

      my $self = shift;

      "cpanminus/$VERSION perl/$]";

  }

  sub determine_home {

      my $class = shift;

      my $homedir = $ENV{HOME}

        || eval { require File::HomeDir; File::HomeDir->my_home }

        || join('', @ENV{qw(HOMEDRIVE HOMEPATH)}); # Win32

      if (WIN32) {

          require Win32; # no fatpack

          $homedir = Win32::GetShortPathName($homedir);

      }

      return "$homedir/.cpanm";

  }

  sub new {

      my $class = shift;

      bless {

          home => $class->determine_home,

          cmd  => 'install',

          seen => {},

          notest => undef,

          test_only => undef,

          installdeps => undef,

          force => undef,

          sudo => undef,

          make  => undef,

          verbose => undef,

          quiet => undef,

          interactive => undef,

          log => undef,

          mirrors => [],

          mirror_only => undef,

          mirror_index => undef,

          perl => $^X,

          argv => [],

          local_lib => undef,

          self_contained => undef,

          prompt_timeout => 0,

          prompt => undef,

          configure_timeout => 60,

          try_lwp => 1,

          try_wget => 1,

          try_curl => 1,

          uninstall_shadows => ($] < 5.012),

          skip_installed => 1,

          skip_satisfied => 0,

          auto_cleanup => 7, # days

          pod2man => 1,

          installed_dists => 0,

          showdeps => 0,

          scandeps => 0,

          scandeps_tree => [],

          format   => 'tree',

          save_dists => undef,

          skip_configure => 0,

          verify => 0,

          @_,

      }, $class;

  }

  sub env {

      my($self, $key) = @_;

      $ENV{"PERL_CPANM_" . $key};

  }

  sub parse_options {

      my $self = shift;

      local @ARGV = @{$self->{argv}};

      push @ARGV, split /\s+/, $self->env('OPT');

      push @ARGV, @_;

      Getopt::Long::Configure("bundling");

      Getopt::Long::GetOptions(

          'f|force'   => sub { $self->{skip_installed} = 0; $self->{force} = 1 },

          'n|notest!' => \$self->{notest},

          'test-only' => sub { $self->{notest} = 0; $self->{skip_installed} = 0; $self->{test_only} = 1 },

          'S|sudo!'   => \$self->{sudo},

          'v|verbose' => sub { $self->{verbose} = $self->{interactive} = 1 },

          'verify!'   => \$self->{verify},

          'q|quiet!'  => \$self->{quiet},

          'h|help'    => sub { $self->{action} = 'show_help' },

          'V|version' => sub { $self->{action} = 'show_version' },

          'perl=s'    => \$self->{perl},

          'l|local-lib=s' => sub { $self->{local_lib} = $self->maybe_abs($_[1]) },

          'L|local-lib-contained=s' => sub {

              $self->{local_lib} = $self->maybe_abs($_[1]);

              $self->{self_contained} = 1;

              $self->{pod2man} = undef;

          },

          'mirror=s@' => $self->{mirrors},

          'mirror-only!' => \$self->{mirror_only},

          'mirror-index=s'  => \$self->{mirror_index},

          'cascade-search!' => \$self->{cascade_search},

          'prompt!'   => \$self->{prompt},

          'installdeps' => \$self->{installdeps},

          'skip-installed!' => \$self->{skip_installed},

          'skip-satisfied!' => \$self->{skip_satisfied},

          'reinstall'    => sub { $self->{skip_installed} = 0 },

          'interactive!' => \$self->{interactive},

          'i|install' => sub { $self->{cmd} = 'install' },

          'info'      => sub { $self->{cmd} = 'info' },

          'look'      => sub { $self->{cmd} = 'look'; $self->{skip_installed} = 0 },

          'self-upgrade' => sub { $self->check_upgrade; $self->{cmd} = 'install'; $self->{skip_installed} = 1; push @ARGV, 'App::cpanminus' },

          'uninst-shadows!'  => \$self->{uninstall_shadows},

          'lwp!'    => \$self->{try_lwp},

          'wget!'   => \$self->{try_wget},

          'curl!'   => \$self->{try_curl},

          'auto-cleanup=s' => \$self->{auto_cleanup},

          'man-pages!' => \$self->{pod2man},

          'scandeps'   => \$self->{scandeps},

          'showdeps'   => sub { $self->{showdeps} = 1; $self->{skip_installed} = 0 },

          'format=s'   => \$self->{format},

          'save-dists=s' => sub {

              $self->{save_dists} = $self->maybe_abs($_[1]);

          },

          'skip-configure!' => \$self->{skip_configure},

          'dev!'       => \$self->{dev_release},

          'metacpan!'  => \$self->{metacpan},

      );

      if (!@ARGV && $0 ne '-' && !-t STDIN){ # e.g. # cpanm < author/requires.cpanm

          push @ARGV, $self->load_argv_from_fh(\*STDIN);

          $self->{load_from_stdin} = 1;

      }

      $self->{argv} = \@ARGV;

  }

  sub check_upgrade {

      if ($0 !~ /^$Config{installsitebin}/) {

          if ($0 =~ m!perlbrew/bin!) {

              warn <<WARN;

  It appears your cpanm executable was installed via `perlbrew install-cpanm`.

  cpanm --self-upgrade won't upgrade the version of cpanm you're running.

  Run the following command to get it upgraded.

    perlbrew install-cpanm

  WARN

          } else {

              warn <<WARN;

  You are running cpanm from the path where your current perl won't install executables to.

  Because of that, cpanm --self-upgrade won't upgrade the version of cpanm you're running.

    cpanm path   : $0

    Install path : $Config{installsitebin}

  It means you either installed cpanm globally with system perl, or use distro packages such

  as rpm or apt-get, and you have to use them again to upgrade cpanm.

  WARN

          }

      }

  }

  sub check_libs {

      my $self = shift;

      return if $self->{_checked}++;

      $self->bootstrap_local_lib;

      if (@{$self->{bootstrap_deps} || []}) {

          local $self->{notest} = 1; # test failure in bootstrap should be tolerated

          local $self->{scandeps} = 0;

          $self->install_deps(Cwd::cwd, 0, @{$self->{bootstrap_deps}});

      }

  }

  sub setup_verify {

      my $self = shift;

      my $has_modules = eval { require Module::Signature; require Digest::SHA; 1 };

      $self->{cpansign} = $self->which('cpansign');

      unless ($has_modules && $self->{cpansign}) {

          warn "WARNING: Module::Signature and Digest::SHA is required for distribution verifications.\n";

          $self->{verify} = 0;

      }

  }

  sub parse_module_args {

      my($self, $module) = @_;

      # Plack@1.2 -> Plack~"==1.2"

      # BUT don't expand @ in git URLs

      $module =~ s/^([A-Za-z0-9_:]+)@([v\d\._]+)$/$1~== $2/;

      # Plack~1.20, DBI~"> 1.0, <= 2.0"

      if ($module =~ /\~[v\d\._,\!<>= ]+$/) {

          return split /\~/, $module, 2;

      } else {

          return $module, undef;

      }

  }

  sub doit {

      my $self = shift;

      $self->setup_home;

      $self->init_tools;

      $self->setup_verify if $self->{verify};

      if (my $action = $self->{action}) {

          $self->$action() and return 1;

      }

      $self->show_help(1)

          unless @{$self->{argv}} or $self->{load_from_stdin};

      $self->configure_mirrors;

      my $cwd = Cwd::cwd;

      my @fail;

      for my $module (@{$self->{argv}}) {

          if ($module =~ s/\.pm$//i) {

              my ($volume, $dirs, $file) = File::Spec->splitpath($module);

              $module = join '::', grep { $_ } File::Spec->splitdir($dirs), $file;

          }

          ($module, my $version) = $self->parse_module_args($module);

          if ($self->{skip_satisfied}) {

              $self->check_libs;

              my($ok, $local) = $self->check_module($module, $version || 0);

              if ($ok) {

                  $self->diag("You have $module ($local)\n", 1);

                  next;

              }

          }

          $self->chdir($cwd);

          $self->install_module($module, 0, $version)

              or push @fail, $module;

      }

      if ($self->{base} && $self->{auto_cleanup}) {

          $self->cleanup_workdirs;

      }

      if ($self->{installed_dists}) {

          my $dists = $self->{installed_dists} > 1 ? "distributions" : "distribution";

          $self->diag("$self->{installed_dists} $dists installed\n", 1);

      }

      if ($self->{scandeps}) {

          $self->dump_scandeps();

      }

      # Workaround for older File::Temp's

      # where creating a tempdir with an implicit $PWD

      # causes tempdir non-cleanup if $PWD changes

      # as paths are stored internally without being resolved

      # absolutely.

      # https://rt.cpan.org/Public/Bug/Display.html?id=44924

      $self->chdir($cwd);

      return !@fail;

  }

  sub setup_home {

      my $self = shift;

      $self->{home} = $self->env('HOME') if $self->env('HOME');

      unless (_writable($self->{home})) {

          die "Can't write to cpanm home '$self->{home}': You should fix it with chown/chmod first.\n";

      }

      $self->{base} = "$self->{home}/work/" . time . ".$$";

      File::Path::mkpath([ $self->{base} ], 0, 0777);

      my $link = "$self->{home}/latest-build";

      eval { unlink $link; symlink $self->{base}, $link };

      $self->{log} = File::Spec->catfile($self->{home}, "build.log"); # because we use shell redirect

      {

          my $log = $self->{log}; my $base = $self->{base};

          $self->{at_exit} = sub {

              my $self = shift;

              File::Copy::copy($self->{log}, "$self->{base}/build.log");

          };

      }

      { open my $out, ">$self->{log}" or die "$self->{log}: $!" }

      $self->chat("cpanm (App::cpanminus) $VERSION on perl $] built for $Config{archname}\n" .

                  "Work directory is $self->{base}\n");

  }

  sub fetch_meta_sco {

      my($self, $dist) = @_;

      return if $self->{mirror_only};

      my $meta_yml = $self->get("http://search.cpan.org/meta/$dist->{distvname}/META.yml");

      return $self->parse_meta_string($meta_yml);

  }

  sub package_index_for {

      my ($self, $mirror) = @_;

      return $self->source_for($mirror) . "/02packages.details.txt";

  }

  sub generate_mirror_index {

      my ($self, $mirror) = @_;

      my $file = $self->package_index_for($mirror);

      my $gz_file = $file . '.gz';

      my $index_mtime = (stat $gz_file)[9];

      unless (-e $file && (stat $file)[9] >= $index_mtime) {

          $self->chat("Uncompressing index file...\n");

          if (eval {require Compress::Zlib}) {

              my $gz = Compress::Zlib::gzopen($gz_file, "rb")

                  or do { $self->diag_fail("$Compress::Zlib::gzerrno opening compressed index"); return};

              open my $fh, '>', $file

                  or do { $self->diag_fail("$! opening uncompressed index for write"); return };

              my $buffer;

              while (my $status = $gz->gzread($buffer)) {

                  if ($status < 0) {

                      $self->diag_fail($gz->gzerror . " reading compressed index");

                      return;

                  }

                  print $fh $buffer;

              }

          } else {

              if (system("gunzip -c $gz_file > $file")) {

                  $self->diag_fail("Cannot uncompress -- please install gunzip or Compress::Zlib");

                  return;

              }

          }

          utime $index_mtime, $index_mtime, $file;

      }

      return 1;

  }

  sub search_mirror_index {

      my ($self, $mirror, $module, $version) = @_;

      $self->search_mirror_index_file($self->package_index_for($mirror), $module, $version);

  }

  sub search_mirror_index_file {

      my($self, $file, $module, $version) = @_;

      open my $fh, '<', $file or return;

      my $found;

      while (<$fh>) {

          if (m!^\Q$module\E\s+([\w\.]+)\s+(\S*)!m) {

              $found = $self->cpan_module($module, $2, $1);

              last;

          }

      }

      return $found unless $self->{cascade_search};

      if ($found) {

          if ($self->satisfy_version($module, $found->{module_version}, $version)) {

              return $found;

          } else {

              $self->chat("Found $module $found->{module_version} which doesn't satisfy $version.\n");

          }

      }

      return;

  }

  sub with_version_range {

      my($self, $version) = @_;

      defined($version) && $version =~ /[<>=]/;

  }

  sub encode_json {

      my($self, $data) = @_;

      require JSON::PP;

      my $json = JSON::PP::encode_json($data);

      $json =~ s/([^a-zA-Z0-9_\-.])/uc sprintf("%%%02x",ord($1))/eg;

      $json;

  }

  # TODO extract this as a module?

  sub version_to_query {

      my($self, $module, $version) = @_;

      require CPAN::Meta::Requirements;

      my $requirements = CPAN::Meta::Requirements->new;

      $requirements->add_string_requirement($module, $version || '0');

      my $req = $requirements->requirements_for_module($module);

      if ($req =~ s/^==\s*//) {

          return {

              term => { 'module.version' => $req },

          };

      } elsif ($req !~ /\s/) {

          return {

              range => { 'module.version_numified' => { 'gte' => $self->numify_ver($req) } },

          };

      } else {

          my %ops = qw(< lt <= lte > gt >= gte);

          my(%range, @exclusion);

          my @requirements = split /,\s*/, $req;

          for my $r (@requirements) {

              if ($r =~ s/^([<>]=?)\s*//) {

                  $range{$ops{$1}} = $self->numify_ver($r);

              } elsif ($r =~ s/\!=\s*//) {

                  push @exclusion, $self->numify_ver($r);

              }

          }

          my @filters= (

              { range => { 'module.version_numified' => \%range } },

          );

          if (@exclusion) {

              push @filters, {

                  not => { or => [ map { +{ term => { 'module.version_numified' => $self->numify_ver($_) } } } @exclusion ] },

              };

          }

          return @filters;

      }

  }

  sub numify_ver {

      my($self, $ver) = @_;

      version->new($ver)->numify;

  }

  sub maturity_filter {

      my($self, $module, $version) = @_;

      my @filters;

      # TODO: dev release should be enabled per dist

      if (!$self->with_version_range($version) or $self->{dev_release}) {

          # backpan'ed dev release are considered "cancelled"

          push @filters, { not => { term => { status => 'backpan' } } };

      }

      unless ($self->{dev_release} or $version =~ /==/) {

          push @filters, { term => { maturity => 'released' } };

      }

      return @filters;

  }

  sub search_metacpan {

      my($self, $module, $version) = @_;

      require JSON::PP;

      $self->chat("Searching $module ($version) on metacpan ...\n");

      my $metacpan_uri = 'http://api.metacpan.org/v0';

      my @filter = $self->maturity_filter($module, $version);

      my $query = { filtered => {

          (@filter ? (filter => { and => \@filter }) : ()),

          query => { nested => {

              score_mode => 'max',

              path => 'module',

              query => { custom_score => {

                  metacpan_script => "score_version_numified",

                  query => { constant_score => {

                      filter => { and => [

                          { term => { 'module.authorized' => JSON::PP::true() } },

                          { term => { 'module.indexed' => JSON::PP::true() } },

                          { term => { 'module.name' => $module } },

                          $self->version_to_query($module, $version),

                      ] }

                  } },

              } },

          } },

      } };

      my $module_uri = "$metacpan_uri/file/_search?source=";

      $module_uri .= $self->encode_json({

          query => $query,

          fields => [ 'release', 'module' ],

      });

      my($release, $module_version);

      my $module_json = $self->get($module_uri);

      my $module_meta = eval { JSON::PP::decode_json($module_json) };

      my $match = $module_meta ? $module_meta->{hits}{hits}[0]{fields} : undef;

      if ($match) {

          $release = $match->{release};

          my $module_matched = (grep { $_->{name} eq $module } @{$match->{module}})[0];

          $module_version = $module_matched->{version};

      }

      unless ($release) {

          $self->chat("! Could not find a release matching $module ($version) on MetaCPAN.\n");

          return;

      }

      my $dist_uri = "$metacpan_uri/release/_search?source=";

      $dist_uri .= $self->encode_json({

          filter => {

              term => { 'release.name' => $release },

          },

          fields => [ 'download_url', 'stat', 'status' ],

      });

      my $dist_json = $self->get($dist_uri);

      my $dist_meta = eval { JSON::PP::decode_json($dist_json) };

      if ($dist_meta) {

          $dist_meta = $dist_meta->{hits}{hits}[0]{fields};

      }

      if ($dist_meta && $dist_meta->{download_url}) {

          (my $distfile = $dist_meta->{download_url}) =~ s!.+/authors/id/!!;

          local $self->{mirrors} = $self->{mirrors};

          if ($dist_meta->{status} eq 'backpan') {

              $self->{mirrors} = [ 'http://backpan.perl.org' ];

          } elsif ($dist_meta->{stat}{mtime} > time()-24*60*60) {

              $self->{mirrors} = [ 'http://cpan.metacpan.org' ];

          }

          return $self->cpan_module($module, $distfile, $module_version);

      }

      $self->diag_fail("Finding $module on metacpan failed.");

      return;

  }

  sub search_database {

      my($self, $module, $version) = @_;

      my $found;

      my $range = ($self->with_version_range($version) || $self->{dev_release});

      if ($range or $self->{metacpan}) {

          $found = $self->search_metacpan($module, $version)   and return $found;

          $found = $self->search_cpanmetadb($module, $version) and return $found;

      } else {

          $found = $self->search_cpanmetadb($module, $version) and return $found;

          $found = $self->search_metacpan($module, $version)   and return $found;

      }

  }

  sub search_cpanmetadb {

      my($self, $module, $version) = @_;

      $self->chat("Searching $module on cpanmetadb ...\n");

      my $uri  = "http://cpanmetadb.plackperl.org/v1.0/package/$module";

      my $yaml = $self->get($uri);

      my $meta = $self->parse_meta_string($yaml);

      if ($meta && $meta->{distfile}) {

          return $self->cpan_module($module, $meta->{distfile}, $meta->{version});

      }

      $self->diag_fail("Finding $module on cpanmetadb failed.");

      return;

  }

  sub search_module {

      my($self, $module, $version) = @_;

      if ($self->{mirror_index}) {

          $self->chat("Searching $module on mirror index $self->{mirror_index} ...\n");

          my $pkg = $self->search_mirror_index_file($self->{mirror_index}, $module, $version);

          return $pkg if $pkg;

          unless ($self->{cascade_search}) {

             $self->diag_fail("Finding $module ($version) on mirror index $self->{mirror_index} failed.");

             return;

          }

      }

      unless ($self->{mirror_only}) {

          my $found = $self->search_database($module, $version);

          return $found if $found;

      }

      MIRROR: for my $mirror (@{ $self->{mirrors} }) {

          $self->chat("Searching $module on mirror $mirror ...\n");

          my $name = '02packages.details.txt.gz';

          my $uri  = "$mirror/modules/$name";

          my $gz_file = $self->package_index_for($mirror) . '.gz';

          unless ($self->{pkgs}{$uri}) {

              $self->chat("Downloading index file $uri ...\n");

              $self->mirror($uri, $gz_file);

              $self->generate_mirror_index($mirror) or next MIRROR;

              $self->{pkgs}{$uri} = "!!retrieved!!";

          }

          my $pkg = $self->search_mirror_index($mirror, $module, $version);

          return $pkg if $pkg;

          $self->diag_fail("Finding $module ($version) on mirror $mirror failed.");

      }

      return;

  }

  sub source_for {

      my($self, $mirror) = @_;

      $mirror =~ s/[^\w\.\-]+/%/g;

      my $dir = "$self->{home}/sources/$mirror";

      File::Path::mkpath([ $dir ], 0, 0777);

      return $dir;

  }

  sub load_argv_from_fh {

      my($self, $fh) = @_;

      my @argv;

      while(defined(my $line = <$fh>)){

          chomp $line;

          $line =~ s/#.+$//; # comment

          $line =~ s/^\s+//; # trim spaces

          $line =~ s/\s+$//; # trim spaces

          push @argv, split ' ', $line if $line;

      }

      return @argv;

  }

  sub show_version {

      print "cpanm (App::cpanminus) version $VERSION\n";

      return 1;

  }

  sub show_help {

      my $self = shift;

      if ($_[0]) {

          die <<USAGE;

  Usage: cpanm [options] Module [...]

  Try `cpanm --help` or `man cpanm` for more options.

  USAGE

      }

      print <<HELP;

  Usage: cpanm [options] Module [...]

  Options:

    -v,--verbose              Turns on chatty output

    -q,--quiet                Turns off the most output

    --interactive             Turns on interactive configure (required for Task:: modules)

    -f,--force                force install

    -n,--notest               Do not run unit tests

    --test-only               Run tests only, do not install

    -S,--sudo                 sudo to run install commands

    --installdeps             Only install dependencies

    --showdeps                Only display direct dependencies

    --reinstall               Reinstall the distribution even if you already have the latest version installed

    --mirror                  Specify the base URL for the mirror (e.g. http://cpan.cpantesters.org/)

    --mirror-only             Use the mirror's index file instead of the CPAN Meta DB

    --prompt                  Prompt when configure/build/test fails

    -l,--local-lib            Specify the install base to install modules

    -L,--local-lib-contained  Specify the install base to install all non-core modules

    --auto-cleanup            Number of days that cpanm's work directories expire in. Defaults to 7

  Commands:

    --self-upgrade            upgrades itself

    --info                    Displays distribution info on CPAN

    --look                    Opens the distribution with your SHELL

    -V,--version              Displays software version

  Examples:

    cpanm Test::More                                          # install Test::More

    cpanm MIYAGAWA/Plack-0.99_05.tar.gz                       # full distribution path

    cpanm http://example.org/LDS/CGI.pm-3.20.tar.gz           # install from URL

    cpanm ~/dists/MyCompany-Enterprise-1.00.tar.gz            # install from a local file

    cpanm --interactive Task::Kensho                          # Configure interactively

    cpanm .                                                   # install from local directory

    cpanm --installdeps .                                     # install all the deps for the current directory

    cpanm -L extlib Plack                                     # install Plack and all non-core deps into extlib

    cpanm --mirror http://cpan.cpantesters.org/ DBI           # use the fast-syncing mirror

  You can also specify the default options in PERL_CPANM_OPT environment variable in the shell rc:

    export PERL_CPANM_OPT="--prompt --reinstall -l ~/perl --mirror http://cpan.cpantesters.org"

  Type `man cpanm` or `perldoc cpanm` for the more detailed explanation of the options.

  HELP

      return 1;

  }

  sub _writable {

      my $dir = shift;

      my @dir = File::Spec->splitdir($dir);

      while (@dir) {

          $dir = File::Spec->catdir(@dir);

          if (-e $dir) {

              return -w _;

          }

          pop @dir;

      }

      return;

  }

  sub maybe_abs {

      my($self, $lib) = @_;

      if ($lib eq '_' or $lib =~ /^~/ or File::Spec->file_name_is_absolute($lib)) {

          return $lib;

      } else {

          return File::Spec->canonpath(File::Spec->catdir(Cwd::cwd(), $lib));

      }

  }

  sub bootstrap_local_lib {

      my $self = shift;

      # If -l is specified, use that.

      if ($self->{local_lib}) {

          return $self->setup_local_lib($self->{local_lib});

      }

      # root, locally-installed perl or --sudo: don't care about install_base

      return if $self->{sudo} or (_writable($Config{installsitelib}) and _writable($Config{installsitebin}));

      # local::lib is configured in the shell -- yay

      if ($ENV{PERL_MM_OPT} and ($ENV{MODULEBUILDRC} or $ENV{PERL_MB_OPT})) {

          $self->bootstrap_local_lib_deps;

          return;

      }

      $self->setup_local_lib;

      $self->diag(<<DIAG);

  !

  ! Can't write to $Config{installsitelib} and $Config{installsitebin}: Installing modules to $ENV{HOME}/perl5

  ! To turn off this warning, you have to do one of the following:

  !   - run me as a root or with --sudo option (to install to $Config{installsitelib} and $Config{installsitebin})

  !   - Configure local::lib your existing local::lib in this shell to set PERL_MM_OPT etc.

  !   - Install local::lib by running the following commands

  !

  !         cpanm --local-lib=~/perl5 local::lib && eval \$(perl -I ~/perl5/lib/perl5/ -Mlocal::lib)

  !

  DIAG

      sleep 2;

  }

  sub _core_only_inc {

      my($self, $base) = @_;

      require local::lib;

      (

          local::lib->resolve_path(local::lib->install_base_perl_path($base)),

          local::lib->resolve_path(local::lib->install_base_arch_path($base)),

          @Config{qw(privlibexp archlibexp)},

      );

  }

  sub _diff {

      my($self, $old, $new) = @_;

      my @diff;

      my %old = map { $_ => 1 } @$old;

      for my $n (@$new) {

          push @diff, $n unless exists $old{$n};

      }

      @diff;

  }

  sub _setup_local_lib_env {

      my($self, $base) = @_;

      local $SIG{__WARN__} = sub { }; # catch 'Attempting to write ...'

      local::lib->setup_env_hash_for($base);

  }

  sub setup_local_lib {

      my($self, $base) = @_;

      $base = undef if $base eq '_';

      require local::lib;

      {

          local $0 = 'cpanm'; # so curl/wget | perl works

          $base ||= "~/perl5";

          if ($self->{self_contained}) {

              my @inc = $self->_core_only_inc($base);

              $self->{search_inc} = [ @inc ];

          } else {

              $self->{search_inc} = [

                  local::lib->resolve_path(local::lib->install_base_arch_path($base)),

                  local::lib->resolve_path(local::lib->install_base_perl_path($base)),

                  @INC,

              ];

          }

          $self->_setup_local_lib_env($base);

      }

      $self->bootstrap_local_lib_deps;

  }

  sub bootstrap_local_lib_deps {

      my $self = shift;

      push @{$self->{bootstrap_deps}},

          'ExtUtils::MakeMaker' => 6.31,

          'ExtUtils::Install'   => 1.46;

  }

  sub prompt_bool {

      my($self, $mess, $def) = @_;

      my $val = $self->prompt($mess, $def);

      return lc $val eq 'y';

  }

  sub prompt {

      my($self, $mess, $def) = @_;

      my $isa_tty = -t STDIN && (-t STDOUT || !(-f STDOUT || -c STDOUT)) ;

      my $dispdef = defined $def ? "[$def] " : " ";

      $def = defined $def ? $def : "";

      if (!$self->{prompt} || (!$isa_tty && eof STDIN)) {

          return $def;

      }

      local $|=1;

      local $\;

      my $ans;

      eval {

          local $SIG{ALRM} = sub { undef $ans; die "alarm\n" };

          print STDOUT "$mess $dispdef";

          alarm $self->{prompt_timeout} if $self->{prompt_timeout};

          $ans = <STDIN>;

          alarm 0;

      };

      if ( defined $ans ) {

          chomp $ans;

      } else { # user hit ctrl-D or alarm timeout

          print STDOUT "\n";

      }

      return (!defined $ans || $ans eq '') ? $def : $ans;

  }

  sub diag_ok {

      my($self, $msg) = @_;

      chomp $msg;

      $msg ||= "OK";

      if ($self->{in_progress}) {

          $self->_diag("$msg\n");

          $self->{in_progress} = 0;

      }

      $self->log("-> $msg\n");

  }

  sub diag_fail {

      my($self, $msg, $always) = @_;

      chomp $msg;

      if ($self->{in_progress}) {

          $self->_diag("FAIL\n");

          $self->{in_progress} = 0;

      }

      if ($msg) {

          $self->_diag("! $msg\n", $always);

          $self->log("-> FAIL $msg\n");

      }

  }

  sub diag_progress {

      my($self, $msg) = @_;

      chomp $msg;

      $self->{in_progress} = 1;

      $self->_diag("$msg ... ");

      $self->log("$msg\n");

  }

  sub _diag {

      my($self, $msg, $always) = @_;

      print STDERR $msg if $always or $self->{verbose} or !$self->{quiet};

  }

  sub diag {

      my($self, $msg, $always) = @_;

      $self->_diag($msg, $always);

      $self->log($msg);

  }

  sub chat {

      my $self = shift;

      print STDERR @_ if $self->{verbose};

      $self->log(@_);

  }

  sub log {

      my $self = shift;

      open my $out, ">>$self->{log}";

      print $out @_;

  }

  sub run {

      my($self, $cmd) = @_;

      if (WIN32 && ref $cmd eq 'ARRAY') {

          $cmd = join q{ }, map { $self->shell_quote($_) } @$cmd;

      }

      if (ref $cmd eq 'ARRAY') {

          my $pid = fork;

          if ($pid) {

              waitpid $pid, 0;

              return !$?;

          } else {

              $self->run_exec($cmd);

          }

      } else {

          unless ($self->{verbose}) {

              $cmd .= " >> " . $self->shell_quote($self->{log}) . " 2>&1";

          }

          !system $cmd;

      }

  }

  sub run_exec {

      my($self, $cmd) = @_;

      if (ref $cmd eq 'ARRAY') {

          unless ($self->{verbose}) {

              open my $logfh, ">>", $self->{log};

              open STDERR, '>&', $logfh;

              open STDOUT, '>&', $logfh;

              close $logfh;

          }

          exec @$cmd;

      } else {

          unless ($self->{verbose}) {

              $cmd .= " >> " . $self->shell_quote($self->{log}) . " 2>&1";

          }

          exec $cmd;

      }

  }

  sub run_timeout {

      my($self, $cmd, $timeout) = @_;

      return $self->run($cmd) if WIN32 || $self->{verbose} || !$timeout;

      my $pid = fork;

      if ($pid) {

          eval {

              local $SIG{ALRM} = sub { die "alarm\n" };

              alarm $timeout;

              waitpid $pid, 0;

              alarm 0;

          };

          if ($@ && $@ eq "alarm\n") {

              $self->diag_fail("Timed out (> ${timeout}s). Use --verbose to retry.");

              local $SIG{TERM} = 'IGNORE';

              kill TERM => 0;

              waitpid $pid, 0;

              return;

          }

          return !$?;

      } elsif ($pid == 0) {

          $self->run_exec($cmd);

      } else {

          $self->chat("! fork failed: falling back to system()\n");

          $self->run($cmd);

      }

  }

  sub configure {

      my($self, $cmd) = @_;

      # trick AutoInstall

      local $ENV{PERL5_CPAN_IS_RUNNING} = local $ENV{PERL5_CPANPLUS_IS_RUNNING} = $$;

      # e.g. skip CPAN configuration on local::lib

      local $ENV{PERL5_CPANM_IS_RUNNING} = $$;

      my $use_default = !$self->{interactive};

      local $ENV{PERL_MM_USE_DEFAULT} = $use_default;

      # skip man page generation

      local $ENV{PERL_MM_OPT} = $ENV{PERL_MM_OPT};

      unless ($self->{pod2man}) {

          $ENV{PERL_MM_OPT} .= " INSTALLMAN1DIR=none INSTALLMAN3DIR=none";

      }

      local $self->{verbose} = $self->{verbose} || $self->{interactive};

      $self->run_timeout($cmd, $self->{configure_timeout});

  }

  sub build {

      my($self, $cmd, $distname) = @_;

      return 1 if $self->run_timeout($cmd, $self->{build_timeout});

      while (1) {

          my $ans = lc $self->prompt("Building $distname failed.\nYou can s)kip, r)etry, e)xamine build log, or l)ook ?", "s");

          return                               if $ans eq 's';

          return $self->build($cmd, $distname) if $ans eq 'r';

          $self->show_build_log                if $ans eq 'e';

          $self->look                          if $ans eq 'l';

      }

  }

  sub test {

      my($self, $cmd, $distname) = @_;

      return 1 if $self->{notest};

      # https://rt.cpan.org/Ticket/Display.html?id=48965#txn-1013385

      local $ENV{PERL_MM_USE_DEFAULT} = 1;

      return 1 if $self->run_timeout($cmd, $self->{test_timeout});

      if ($self->{force}) {

          $self->diag_fail("Testing $distname failed but installing it anyway.");

          return 1;

      } else {

          $self->diag_fail;

          while (1) {

              my $ans = lc $self->prompt("Testing $distname failed.\nYou can s)kip, r)etry, f)orce install, e)xamine build log, or l)ook ?", "s");

              return                              if $ans eq 's';

              return $self->test($cmd, $distname) if $ans eq 'r';

              return 1                            if $ans eq 'f';

              $self->show_build_log               if $ans eq 'e';

              $self->look                         if $ans eq 'l';

          }

      }

  }

  sub install {

      my($self, $cmd, $uninst_opts, $depth) = @_;

      if ($depth == 0 && $self->{test_only}) {

          return 1;

      }

      if ($self->{sudo}) {

          unshift @$cmd, "sudo";

      }

      if ($self->{uninstall_shadows} && !$ENV{PERL_MM_OPT}) {

          push @$cmd, @$uninst_opts;

      }

      $self->run($cmd);

  }

  sub look {

      my $self = shift;

      my $shell = $ENV{SHELL};

      $shell  ||= $ENV{COMSPEC} if WIN32;

      if ($shell) {

          my $cwd = Cwd::cwd;

          $self->diag("Entering $cwd with $shell\n");

          system $shell;

      } else {

          $self->diag_fail("You don't seem to have a SHELL :/");

      }

  }

  sub show_build_log {

      my $self = shift;

      my @pagers = (

          $ENV{PAGER},

          (WIN32 ? () : ('less')),

          'more'

      );

      my $pager;

      while (@pagers) {

          $pager = shift @pagers;

          next unless $pager;

          $pager = $self->which($pager);

          next unless $pager;

          last;

      }

      if ($pager) {

          # win32 'more' doesn't allow "more build.log", the < is required

          system("$pager < $self->{log}");

      }

      else {

          $self->diag_fail("You don't seem to have a PAGER :/");

      }

  }

  sub chdir {

      my $self = shift;

      Cwd::chdir(File::Spec->canonpath($_[0])) or die "$_[0]: $!";

  }

  sub configure_mirrors {

      my $self = shift;

      unless (@{$self->{mirrors}}) {

          $self->{mirrors} = [ 'http://www.cpan.org' ];

      }

      for (@{$self->{mirrors}}) {

          s!^/!file:///!;

          s!/$!!;

      }

  }

  sub self_upgrade {

      my $self = shift;

      $self->{argv} = [ 'App::cpanminus' ];

      return; # continue

  }

  sub install_module {

      my($self, $module, $depth, $version) = @_;

      if ($self->{seen}{$module}++) {

          $self->chat("Already tried $module. Skipping.\n");

          return 1;

      }

      my $dist = $self->resolve_name($module, $version);

      unless ($dist) {

          $self->diag_fail("Couldn't find module or a distribution $module ($version)", 1);

          return;

      }

      if ($dist->{distvname} && $self->{seen}{$dist->{distvname}}++) {

          $self->chat("Already tried $dist->{distvname}. Skipping.\n");

          return 1;

      }

      if ($self->{cmd} eq 'info') {

          print $self->format_dist($dist), "\n";

          return 1;

      }

      $self->check_libs;

      $self->setup_module_build_patch unless $self->{pod2man};

      if ($dist->{module}) {

          unless ($self->with_version_range($version)) {

              my($ok, $local) = $self->check_module($dist->{module}, $dist->{module_version} || 0);

              if ($self->{skip_installed} && $ok) {

                  $self->diag("$dist->{module} is up to date. ($local)\n", 1);

                  return 1;

              }

          }

          unless ($self->satisfy_version($dist->{module}, $dist->{module_version}, $version)) {

              $self->diag("Found $dist->{module} $dist->{module_version} which doesn't satisfy $version.\n");

              return;

          }

      }

      if ($dist->{dist} eq 'perl'){

          $self->diag("skipping $dist->{pathname}\n");

          return 1;

      }

      $self->diag("--> Working on $module\n");

      $dist->{dir} ||= $self->fetch_module($dist);

      unless ($dist->{dir}) {

          $self->diag_fail("Failed to fetch distribution $dist->{distvname}", 1);

          return;

      }

      $self->chat("Entering $dist->{dir}\n");

      $self->chdir($self->{base});

      $self->chdir($dist->{dir});

      if ($self->{cmd} eq 'look') {

          $self->look;

          return 1;

      }

      return $self->build_stuff($module, $dist, $depth);

  }

  sub format_dist {

      my($self, $dist) = @_;

      # TODO support --dist-format?

      return "$dist->{cpanid}/$dist->{filename}";

  }

  sub fetch_module {

      my($self, $dist) = @_;

      $self->chdir($self->{base});

      for my $uri (@{$dist->{uris}}) {

          $self->diag_progress("Fetching $uri");

          # Ugh, $dist->{filename} can contain sub directory

          my $filename = $dist->{filename} || $uri;

          my $name = File::Basename::basename($filename);

          my $cancelled;

          my $fetch = sub {

              my $file;

              eval {

                  local $SIG{INT} = sub { $cancelled = 1; die "SIGINT\n" };

                  $self->mirror($uri, $name);

                  $file = $name if -e $name;

              };

              $self->chat("$@") if $@ && $@ ne "SIGINT\n";

              return $file;

          };

          my($try, $file);

          while ($try++ < 3) {

              $file = $fetch->();

              last if $cancelled or $file;

              $self->diag_fail("Download $uri failed. Retrying ... ");

          }

          if ($cancelled) {

              $self->diag_fail("Download cancelled.");

              return;

          }

          unless ($file) {

              $self->diag_fail("Failed to download $uri");

              next;

          }

          $self->diag_ok;

          $dist->{local_path} = File::Spec->rel2abs($name);

          my $dir = $self->unpack($file, $uri, $dist);

          next unless $dir; # unpack failed

          if (my $save = $self->{save_dists}) {

              my $path = "$save/authors/id/$dist->{pathname}";

              $self->chat("Copying $name to $path\n");

              File::Path::mkpath([ File::Basename::dirname($path) ], 0, 0777);

              File::Copy::copy($file, $path) or warn $!;

          }

          return $dist, $dir;