Move CPANPLUS::Dist::Build from ext/ to cpan/

11 files changed, 1480 insertions, 0 deletions

diff --git a/cpan/CPANPLUS-Dist-Build/lib/CPANPLUS/Dist/Build.pm b/cpan/CPANPLUS-Dist-Build/lib/CPANPLUS/Dist/Build.pm
new file mode 100644
index 0000000000..a42e10ac3e
--- /dev/null
+++ b/cpan/CPANPLUS-Dist-Build/lib/CPANPLUS/Dist/Build.pm
@@ -0,0 +1,826 @@
+package CPANPLUS::Dist::Build;
+
+use strict;
+use warnings;
+use vars    qw[@ISA $STATUS $VERSION];
+@ISA =      qw[CPANPLUS::Dist];
+
+use CPANPLUS::Internals::Constants;
+
+### these constants were exported by CPANPLUS::Internals::Constants
+### in previous versions.. they do the same though. If we want to have
+### a normal 'use' here, up the dependency to CPANPLUS 0.056 or higher
+BEGIN { 
+    require CPANPLUS::Dist::Build::Constants;
+    CPANPLUS::Dist::Build::Constants->import()
+        if not __PACKAGE__->can('BUILD') && __PACKAGE__->can('BUILD_DIR');
+}
+
+use CPANPLUS::Error;
+
+use Config;
+use FileHandle;
+use Cwd;
+use version;
+
+use IPC::Cmd                    qw[run];
+use Params::Check               qw[check];
+use Module::Load::Conditional   qw[can_load check_install];
+use Locale::Maketext::Simple    Class => 'CPANPLUS', Style => 'gettext';
+
+local $Params::Check::VERBOSE = 1;
+
+$VERSION = '0.40';
+
+=pod
+
+=head1 NAME
+
+CPANPLUS::Dist::Build - CPANPLUS plugin to install packages that use Build.PL
+
+=head1 SYNOPSIS
+
+    my $build = CPANPLUS::Dist->new(
+                                format  => 'CPANPLUS::Dist::Build',
+                                module  => $modobj,
+                            );
+                            
+    $build->prepare;    # runs Build.PL                            
+    $build->create;     # runs build && build test
+    $build->install;    # runs build install
+
+
+=head1 DESCRIPTION
+
+C<CPANPLUS::Dist::Build> is a distribution class for C<Module::Build>
+related modules.
+Using this package, you can create, install and uninstall perl
+modules. It inherits from C<CPANPLUS::Dist>.
+
+Normal users won't have to worry about the interface to this module,
+as it functions transparently as a plug-in to C<CPANPLUS> and will 
+just C<Do The Right Thing> when it's loaded.
+
+=head1 ACCESSORS
+
+=over 4
+
+=item C<parent()>
+
+Returns the C<CPANPLUS::Module> object that parented this object.
+
+=item C<status()>
+
+Returns the C<Object::Accessor> object that keeps the status for
+this module.
+
+=back
+
+=head1 STATUS ACCESSORS
+
+All accessors can be accessed as follows:
+    $build->status->ACCESSOR
+
+=over 4
+
+=item C<build_pl ()>
+
+Location of the Build file.
+Set to 0 explicitly if something went wrong.
+
+=item C<build ()>
+
+BOOL indicating if the C<Build> command was successful.
+
+=item C<test ()>
+
+BOOL indicating if the C<Build test> command was successful.
+
+=item C<prepared ()>
+
+BOOL indicating if the C<prepare> call exited succesfully
+This gets set after C<perl Build.PL>
+
+=item C<distdir ()>
+
+Full path to the directory in which the C<prepare> call took place,
+set after a call to C<prepare>. 
+
+=item C<created ()>
+
+BOOL indicating if the C<create> call exited succesfully. This gets
+set after C<Build> and C<Build test>.
+
+=item C<installed ()>
+
+BOOL indicating if the module was installed. This gets set after
+C<Build install> exits successfully.
+
+=item uninstalled ()
+
+BOOL indicating if the module was uninstalled properly.
+
+=item C<_create_args ()>
+
+Storage of the arguments passed to C<create> for this object. Used
+for recursive calls when satisfying prerequisites.
+
+=item C<_install_args ()>
+
+Storage of the arguments passed to C<install> for this object. Used
+for recursive calls when satisfying prerequisites.
+
+=back
+
+=cut
+
+=head1 METHODS
+
+=head2 $bool = CPANPLUS::Dist::Build->format_available();
+
+Returns a boolean indicating whether or not you can use this package
+to create and install modules in your environment.
+
+=cut
+
+### check if the format is available ###
+sub format_available {
+    my $mod = "Module::Build";
+    unless( can_load( modules => { $mod => '0.2611' } ) ) {
+        error( loc( "You do not have '%1' -- '%2' not available",
+                    $mod, __PACKAGE__ ) );
+        return;
+    }
+
+    return 1;
+}
+
+
+=head2 $bool = $dist->init();
+
+Sets up the C<CPANPLUS::Dist::Build> object for use.
+Effectively creates all the needed status accessors.
+
+Called automatically whenever you create a new C<CPANPLUS::Dist> object.
+
+=cut
+
+sub init {
+    my $dist    = shift;
+    my $status  = $dist->status;
+
+    $status->mk_accessors(qw[build_pl build test created installed uninstalled
+                             _create_args _install_args _prepare_args
+                             _mb_object _buildflags
+                            ]);
+
+    ### just in case 'format_available' didn't get called
+    require Module::Build;
+
+    return 1;
+}
+
+=pod
+
+=head2 $bool = $dist->prepare([perl => '/path/to/perl', buildflags => 'EXTRA=FLAGS', force => BOOL, verbose => BOOL])
+
+C<prepare> prepares a distribution, running C<Build.PL> 
+and establishing any prerequisites this
+distribution has.
+
+The variable C<PERL5_CPANPLUS_IS_EXECUTING> will be set to the full path 
+of the C<Build.PL> that is being executed. This enables any code inside
+the C<Build.PL> to know that it is being installed via CPANPLUS.
+
+After a succcesfull C<prepare> you may call C<create> to create the
+distribution, followed by C<install> to actually install it.
+
+Returns true on success and false on failure.
+
+=cut
+
+sub prepare {
+    ### just in case you already did a create call for this module object
+    ### just via a different dist object
+    my $dist = shift;
+    my $self = $dist->parent;
+
+    ### we're also the cpan_dist, since we don't need to have anything
+    ### prepared from another installer
+    $dist    = $self->status->dist_cpan if      $self->status->dist_cpan;
+    $self->status->dist_cpan( $dist )   unless  $self->status->dist_cpan;
+
+    my $cb   = $self->parent;
+    my $conf = $cb->configure_object;
+    my %hash = @_;
+
+    my $dir;
+    unless( $dir = $self->status->extract ) {
+        error( loc( "No dir found to operate on!" ) );
+        return;
+    }
+
+    my $args;
+    my( $force, $verbose, $buildflags, $perl, $prereq_target, $prereq_format,
+        $prereq_build );
+    {   local $Params::Check::ALLOW_UNKNOWN = 1;
+        my $tmpl = {
+            force           => {    default => $conf->get_conf('force'),
+                                    store   => \$force },
+            verbose         => {    default => $conf->get_conf('verbose'),
+                                    store   => \$verbose },
+            perl            => {    default => $^X, store => \$perl },
+            buildflags      => {    default => $conf->get_conf('buildflags'),
+                                    store   => \$buildflags },
+            prereq_target   => {    default => '', store => \$prereq_target }, 
+            prereq_format   => {    default => '',
+                                    store   => \$prereq_format },   
+            prereq_build    => {    default => 0, store => \$prereq_build },
+        };
+
+        $args = check( $tmpl, \%hash ) or return;
+    }
+
+    return 1 if $dist->status->prepared && !$force;
+
+    $dist->status->_prepare_args( $args );
+
+    ### chdir to work directory ###
+    my $orig = cwd();
+    unless( $cb->_chdir( dir => $dir ) ) {
+        error( loc( "Could not chdir to build directory '%1'", $dir ) );
+        return;
+    }
+
+    ### by now we've loaded module::build, and we're using the API, so
+    ### it's safe to remove CPANPLUS::inc from our inc path, especially
+    ### because it can trip up tests run under taint (just like EU::MM).
+    ### turn off our PERL5OPT so no modules from CPANPLUS::inc get
+    ### included in make test -- it should build without.
+    ### also, modules that run in taint mode break if we leave
+    ### our code ref in perl5opt
+    ### XXX we've removed the ENV settings from cp::inc, so only need
+    ### to reset the @INC
+    #local $ENV{PERL5OPT} = CPANPLUS::inc->original_perl5opt;
+    #local $ENV{PERL5LIB} = CPANPLUS::inc->original_perl5lib;
+    #local @INC           = CPANPLUS::inc->original_inc;
+
+    ### this will generate warnings under anything lower than M::B 0.2606
+    my @buildflags = $dist->_buildflags_as_list( $buildflags );
+    $dist->status->_buildflags( $buildflags );
+
+    my $fail;
+    RUN: {
+        # 0.85_01
+        ### we resolve 'configure requires' here, so we can run the 'perl
+        ### Makefile.PL' command
+        ### XXX for tests: mock f_c_r to something that *can* resolve and
+        ### something that *doesnt* resolve. Check the error log for ok
+        ### on this step or failure
+        ### XXX make a seperate tarball to test for this scenario: simply
+        ### containing a makefile.pl/build.pl for test purposes?
+        my $safe_ver = version->new('0.85_01');
+        if ( version->new($CPANPLUS::Internals::VERSION) >= $safe_ver )
+        {   my $configure_requires = $dist->find_configure_requires;     
+            my $ok = $dist->_resolve_prereqs(
+                            format          => $prereq_format,
+                            verbose         => $verbose,
+                            prereqs         => $configure_requires,
+                            target          => $prereq_target,
+                            force           => $force,
+                            prereq_build    => $prereq_build,
+                    );    
+    
+            unless( $ok ) {
+           
+                #### use $dist->flush to reset the cache ###
+                error( loc( "Unable to satisfy '%1' for '%2' " .
+                            "-- aborting install", 
+                            'configure_requires', $self->module ) );    
+                $dist->status->prepared(0);
+                $fail++; 
+                last RUN;
+            } 
+            ### end of prereq resolving ###
+        }
+
+        # Wrap the exception that may be thrown here (should likely be
+        # done at a much higher level).
+        my $prep_output;
+
+        my $env = ENV_CPANPLUS_IS_EXECUTING;
+        local $ENV{$env} = BUILD_PL->( $dir );
+        my $run_perl    = $conf->get_program('perlwrapper');
+        my $cmd = [$perl, $run_perl, BUILD_PL->($dir), @buildflags];
+
+        unless ( scalar run(    command => $cmd,
+                                buffer  => \$prep_output,
+                                verbose => $verbose ) 
+        ) {
+            error( loc( "Build.PL failed: %1", $prep_output ) );
+            $fail++; last RUN;
+        }
+
+        msg( $prep_output, 0 );
+
+        my $prereqs = $self->status->prereqs;
+
+        $prereqs ||= $dist->_find_prereqs( verbose => $verbose, 
+                                           dir => $dir, 
+                                           perl => $perl,
+                                           buildflags => $buildflags );
+
+    }
+    
+    ### send out test report? ###
+    if( $fail and $conf->get_conf('cpantest') ) {
+           $cb->_send_report( 
+            module  => $self,
+            failed  => $fail,
+            buffer  => CPANPLUS::Error->stack_as_string,
+            verbose => $verbose,
+            force   => $force,
+        ) or error(loc("Failed to send test report for '%1'",
+                    $self->module ) );
+    }
+
+    unless( $cb->_chdir( dir => $orig ) ) {
+        error( loc( "Could not chdir back to start dir '%1'", $orig ) );
+    }
+
+    ### save where we wrote this stuff -- same as extract dir in normal
+    ### installer circumstances
+    $dist->status->distdir( $self->status->extract );
+
+    return $dist->status->prepared( $fail ? 0 : 1 );
+}
+
+sub _find_prereqs {
+    my $dist = shift;
+    my $self = $dist->parent;
+    my $cb   = $self->parent;
+    my $conf = $cb->configure_object;
+    my %hash = @_;
+
+    my ($verbose, $dir, $buildflags, $perl);
+    my $tmpl = {
+        verbose => { default => $conf->get_conf('verbose'), store => \$verbose },
+        dir     => { default => $self->status->extract, store => \$dir },
+        perl    => { default => $^X, store => \$perl },
+        buildflags => { default => $conf->get_conf('buildflags'),
+                        store   => \$buildflags },
+    };
+    
+    my $args = check( $tmpl, \%hash ) or return;
+
+    my $prereqs = {};
+
+    my $safe_ver = version->new('0.31_03');
+
+    my $content;
+
+    if ( version->new( $Module::Build::VERSION ) >= $safe_ver and IPC::Cmd->can_capture_buffer ) {
+        my @buildflags = $dist->_buildflags_as_list( $buildflags );
+
+        # Use the new Build action 'prereq_data'
+        my $run_perl    = $conf->get_program('perlwrapper');
+
+        unless ( scalar run(    command => [$perl, $run_perl, BUILD->($dir), 'prereq_data', @buildflags],
+                                buffer  => \$content,
+                                verbose => 0 ) 
+        ) {
+            error( loc( "Build 'prereq_data' failed: %1 %2", $!, $content ) );
+            return;
+        }
+
+    }
+    else {
+        my $file = File::Spec->catfile( $dir, '_build', 'prereqs' );
+        return unless -f $file;
+
+        my $fh = FileHandle->new();
+
+        unless( $fh->open( $file ) ) {
+           error( loc( "Cannot open '%1': %2", $file, $! ) );
+           return;
+        }
+        
+        $content = do { local $/; <$fh> };
+    }
+
+    return unless $content;
+    my $bphash = eval $content;
+    return unless $bphash and ref $bphash eq 'HASH';
+    foreach my $type ('requires', 'build_requires') {
+       next unless $bphash->{$type} and ref $bphash->{$type} eq 'HASH';
+       $prereqs->{$_} = $bphash->{$type}->{$_} for keys %{ $bphash->{$type} };
+    }
+
+    # Temporary fix
+    delete $prereqs->{'perl'};
+
+    ### allows for a user defined callback to filter the prerequisite
+    ### list as they see fit, to remove (or add) any prereqs they see
+    ### fit. The default installed callback will return the hashref in
+    ### an unmodified form
+    ### this callback got added after cpanplus 0.0562, so use a 'can'
+    ### to find out if it's supported. For older versions, we'll just
+    ### return the hashref as is ourselves.
+    my $href    = $cb->_callbacks->can('filter_prereqs')
+                    ? $cb->_callbacks->filter_prereqs->( $cb, $prereqs )
+                    : $prereqs;
+
+    $self->status->prereqs( $href );
+
+    ### make sure it's not the same ref
+    return { %$href };
+}
+
+=pod
+
+=head2 $dist->create([perl => '/path/to/perl', buildflags => 'EXTRA=FLAGS', prereq_target => TARGET, force => BOOL, verbose => BOOL, skiptest => BOOL])
+
+C<create> preps a distribution for installation. This means it will
+run C<Build> and C<Build test>.
+This will also satisfy any prerequisites the module may have.
+
+If you set C<skiptest> to true, it will skip the C<Build test> stage.
+If you set C<force> to true, it will go over all the stages of the
+C<Build> process again, ignoring any previously cached results. It
+will also ignore a bad return value from C<Build test> and still allow
+the operation to return true.
+
+Returns true on success and false on failure.
+
+You may then call C<< $dist->install >> on the object to actually
+install it.
+
+=cut
+
+sub create {
+    ### just in case you already did a create call for this module object
+    ### just via a different dist object
+    my $dist = shift;
+    my $self = $dist->parent;
+
+    ### we're also the cpan_dist, since we don't need to have anything
+    ### prepared from another installer
+    $dist    = $self->status->dist_cpan if      $self->status->dist_cpan;
+    $self->status->dist_cpan( $dist )   unless  $self->status->dist_cpan;
+
+    my $cb   = $self->parent;
+    my $conf = $cb->configure_object;
+    my %hash = @_;
+
+    my $dir;
+    unless( $dir = $self->status->extract ) {
+        error( loc( "No dir found to operate on!" ) );
+        return;
+    }
+
+    my $args;
+    my( $force, $verbose, $buildflags, $skiptest, $prereq_target,
+        $perl, $prereq_format, $prereq_build);
+    {   local $Params::Check::ALLOW_UNKNOWN = 1;
+        my $tmpl = {
+            force           => {    default => $conf->get_conf('force'),
+                                    store   => \$force },
+            verbose         => {    default => $conf->get_conf('verbose'),
+                                    store   => \$verbose },
+            perl            => {    default => $^X, store => \$perl },
+            buildflags      => {    default => $conf->get_conf('buildflags'),
+                                    store   => \$buildflags },
+            skiptest        => {    default => $conf->get_conf('skiptest'),
+                                    store   => \$skiptest },
+            prereq_target   => {    default => '', store => \$prereq_target },
+            ### don't set the default format to 'build' -- that is wrong!
+            prereq_format   => {    #default => $self->status->installer_type,
+                                    default => '',
+                                    store   => \$prereq_format },
+            prereq_build    => {    default => 0, store => \$prereq_build },                                    
+        };
+
+        $args = check( $tmpl, \%hash ) or return;
+    }
+
+    # restore the state as we have created this already.
+    if ( $dist->status->created && !$force ) {
+        ### add this directory to your lib ###
+        $self->add_to_includepath();
+        return 1;
+    }
+
+    $dist->status->_create_args( $args );
+
+    ### is this dist prepared?
+    unless( $dist->status->prepared ) {
+        error( loc( "You have not successfully prepared a '%2' distribution ".
+                    "yet -- cannot create yet", __PACKAGE__ ) );
+        return;
+    }
+
+    ### chdir to work directory ###
+    my $orig = cwd();
+    unless( $cb->_chdir( dir => $dir ) ) {
+        error( loc( "Could not chdir to build directory '%1'", $dir ) );
+        return;
+    }
+
+    ### by now we've loaded module::build, and we're using the API, so
+    ### it's safe to remove CPANPLUS::inc from our inc path, especially
+    ### because it can trip up tests run under taint (just like EU::MM).
+    ### turn off our PERL5OPT so no modules from CPANPLUS::inc get
+    ### included in make test -- it should build without.
+    ### also, modules that run in taint mode break if we leave
+    ### our code ref in perl5opt
+    ### XXX we've removed the ENV settings from cp::inc, so only need
+    ### to reset the @INC
+    #local $ENV{PERL5OPT} = CPANPLUS::inc->original_perl5opt;
+    #local $ENV{PERL5LIB} = CPANPLUS::inc->original_perl5lib;
+    #local @INC           = CPANPLUS::inc->original_inc;
+
+    ### but do it *before* the new_from_context, as M::B seems
+    ### to be actually running the file...
+    ### an unshift in the block seems to be ignored.. somehow...
+    #{   my $lib = $self->best_path_to_module_build;
+    #    unshift @INC, $lib if $lib;
+    #}
+    unshift @INC, $self->best_path_to_module_build
+                if $self->best_path_to_module_build;
+
+    ### this will generate warnings under anything lower than M::B 0.2606
+    my @buildflags = $dist->_buildflags_as_list( $buildflags );
+    $dist->status->_buildflags( $buildflags );
+
+    my $fail; my $prereq_fail; my $test_fail;
+    RUN: {
+
+        my $run_perl    = $conf->get_program('perlwrapper');
+
+        ### this will set the directory back to the start
+        ### dir, so we must chdir /again/
+        my $ok = $dist->_resolve_prereqs(
+                        force           => $force,
+                        format          => $prereq_format,
+                        verbose         => $verbose,
+                        prereqs         => $self->status->prereqs,
+                        target          => $prereq_target,
+                        prereq_build    => $prereq_build,
+                    );
+
+        unless( $cb->_chdir( dir => $dir ) ) {
+            error( loc( "Could not chdir to build directory '%1'", $dir ) );
+            return;
+        }
+
+        unless( $ok ) {
+            #### use $dist->flush to reset the cache ###
+            error( loc( "Unable to satisfy prerequisites for '%1' " .
+                        "-- aborting install", $self->module ) );
+            $dist->status->build(0);
+            $fail++; $prereq_fail++;
+            last RUN;
+        }
+
+        my ($captured, $cmd);
+        if ( ON_VMS ) {
+            $cmd = [$perl, BUILD->($dir), @buildflags];
+        }
+        else {
+            $cmd = [$perl, $run_perl, BUILD->($dir), @buildflags];
+        }
+
+        unless ( scalar run(    command => $cmd,
+                                buffer  => \$captured,
+                                verbose => $verbose ) 
+        ) {
+            error( loc( "MAKE failed:\n%1", $captured ) );
+            $dist->status->build(0);
+            $fail++; last RUN;
+        }
+
+        msg( $captured, 0 );
+
+        $dist->status->build(1);
+
+        ### add this directory to your lib ###
+        $self->add_to_includepath();
+
+        ### this buffer will not include what tests failed due to a 
+        ### M::B/Test::Harness bug. Reported as #9793 with patch 
+        ### against 0.2607 on 26/1/2005
+        unless( $skiptest ) {
+            my $test_output;
+            if ( ON_VMS ) {
+                $cmd     = [$perl, BUILD->($dir), "test", @buildflags];
+            }
+            else {
+                $cmd     = [$perl, $run_perl, BUILD->($dir), "test", @buildflags];
+            }
+            unless ( scalar run(    command => $cmd,
+                                    buffer  => \$test_output,
+                                    verbose => $verbose ) 
+            ) {
+                error( loc( "MAKE TEST failed:\n%1 ", $test_output ) );
+
+                ### mark specifically *test* failure.. so we dont
+                ### send success on force...
+                $test_fail++;
+
+                if( !$force and !$cb->_callbacks->proceed_on_test_failure->(
+                                      $self, $@ )
+                ) {
+                    $dist->status->test(0);
+                    $fail++; last RUN;
+                }
+
+            } 
+            else {
+                msg( loc( "MAKE TEST passed:\n%1", $test_output ), 0 );
+                #msg( $test_output, 0 );
+                $dist->status->test(1);
+            }
+        } 
+        else {
+            msg(loc("Tests skipped"), $verbose);
+        }
+    }
+
+    unless( $cb->_chdir( dir => $orig ) ) {
+        error( loc( "Could not chdir back to start dir '%1'", $orig ) );
+    }
+
+    ### send out test report? ###
+    if( $conf->get_conf('cpantest') and not $prereq_fail ) {
+        $cb->_send_report(
+            module          => $self,
+            failed          => $test_fail || $fail,
+            buffer          => CPANPLUS::Error->stack_as_string,
+            verbose         => $verbose,
+            force           => $force,
+            tests_skipped   => $skiptest,
+        ) or error(loc("Failed to send test report for '%1'",
+                    $self->module ) );
+    }
+
+    return $dist->status->created( $fail ? 0 : 1 );
+}
+
+=head2 $dist->install([verbose => BOOL, perl => /path/to/perl])
+
+Actually installs the created dist.
+
+Returns true on success and false on failure.
+
+=cut
+
+sub install {
+    ### just in case you already did a create call for this module object
+    ### just via a different dist object
+    my $dist = shift;
+    my $self = $dist->parent;
+
+    ### we're also the cpan_dist, since we don't need to have anything
+    ### prepared from another installer
+    $dist    = $self->status->dist_cpan if $self->status->dist_cpan;
+
+    my $cb   = $self->parent;
+    my $conf = $cb->configure_object;
+    my %hash = @_;
+
+    
+    my $verbose; my $perl; my $force; my $buildflags;
+    {   local $Params::Check::ALLOW_UNKNOWN = 1;
+        my $tmpl = {
+            verbose => { default => $conf->get_conf('verbose'),
+                         store   => \$verbose },
+            force   => { default => $conf->get_conf('force'),
+                         store   => \$force },
+            buildflags => { default => $conf->get_conf('buildflags'),
+                            store   => \$buildflags },
+            perl    => { default => $^X, store   => \$perl },
+        };
+    
+        my $args = check( $tmpl, \%hash ) or return;
+        $dist->status->_install_args( $args );
+    }
+
+    my $dir;
+    unless( $dir = $self->status->extract ) {
+        error( loc( "No dir found to operate on!" ) );
+        return;
+    }
+
+    my $orig = cwd();
+
+    unless( $cb->_chdir( dir => $dir ) ) {
+        error( loc( "Could not chdir to build directory '%1'", $dir ) );
+        return;
+    }
+
+    ### value set and false -- means failure ###
+    if( defined $self->status->installed && 
+        !$self->status->installed && !$force
+    ) {
+        error( loc( "Module '%1' has failed to install before this session " .
+                    "-- aborting install", $self->module ) );
+        return;
+    }
+
+    my $fail;
+    my @buildflags = $dist->_buildflags_as_list( $buildflags );
+    my $run_perl    = $conf->get_program('perlwrapper');
+
+    ### hmm, how is this going to deal with sudo?
+    ### for now, check effective uid, if it's not root,
+    ### shell out, otherwise use the method
+    if( $> ) {
+
+        ### don't worry about loading the right version of M::B anymore
+        ### the 'new_from_context' already added the 'right' path to
+        ### M::B at the top of the build.pl
+        my $cmd;
+        if ( ON_VMS ) {
+            $cmd     = [$perl, BUILD->($dir), "install", @buildflags];
+        }
+        else {
+            $cmd     = [$perl, $run_perl, BUILD->($dir), "install", @buildflags];
+        }
+        my $sudo    = $conf->get_program('sudo');
+        unshift @$cmd, $sudo if $sudo;
+
+
+        my $buffer;
+        unless( scalar run( command => $cmd,
+                            buffer  => \$buffer,
+                            verbose => $verbose )
+        ) {
+            error(loc("Could not run '%1': %2", 'Build install', $buffer));
+            $fail++;
+        }
+    } else {
+        my ($install_output, $cmd);
+        if ( ON_VMS ) {
+            $cmd     = [$perl, BUILD->($dir), "install", @buildflags];
+        }
+        else {
+            $cmd     = [$perl, $run_perl, BUILD->($dir), "install", @buildflags];
+        }
+        unless( scalar run( command => $cmd,
+                            buffer  => \$install_output,
+                            verbose => $verbose )
+        ) {
+            error(loc("Could not run '%1': %2", 'Build install', $install_output));
+            $fail++;
+        }
+        else {
+            msg( $install_output, 0 );
+        }
+    }
+
+
+    unless( $cb->_chdir( dir => $orig ) ) {
+        error( loc( "Could not chdir back to start dir '%1'", $orig ) );
+    }
+
+    return $dist->status->installed( $fail ? 0 : 1 );
+}
+
+### returns the string 'foo=bar --zot quux'
+###        as the list 'foo=bar', '--zot', 'qux'
+sub _buildflags_as_list {
+    my $self    = shift;
+    my $flags   = shift or return;
+
+    return Module::Build->split_like_shell($flags);
+}
+
+=head1 AUTHOR
+
+Originally by Jos Boumans E<lt>kane@cpan.orgE<gt>.  Brought to working
+condition by Ken Williams E<lt>kwilliams@cpan.orgE<gt>.
+
+Other hackery and currently maintained by Chris C<BinGOs> Williams ( no relation ). E<lt>bingos@cpan.orgE<gt>.
+
+=head1 LICENSE
+
+The CPAN++ interface (of which this module is a part of) is
+copyright (c) 2001, 2002, 2003, 2004, 2005 Jos Boumans E<lt>kane@cpan.orgE<gt>.
+All rights reserved.
+
+This library is free software;
+you may redistribute and/or modify it under the same
+terms as Perl itself.
+
+=cut
+
+qq[Putting the Module::Build into CPANPLUS];
+
+
+# Local variables:
+# c-indentation-style: bsd
+# c-basic-offset: 4
+# indent-tabs-mode: nil
+# End:
+# vim: expandtab shiftwidth=4:
+
diff --git a/cpan/CPANPLUS-Dist-Build/lib/CPANPLUS/Dist/Build/Constants.pm b/cpan/CPANPLUS-Dist-Build/lib/CPANPLUS/Dist/Build/Constants.pm
new file mode 100644
index 0000000000..c04c247c6c
--- /dev/null
+++ b/cpan/CPANPLUS-Dist-Build/lib/CPANPLUS/Dist/Build/Constants.pm
@@ -0,0 +1,69 @@
+package CPANPLUS::Dist::Build::Constants;
+
+use strict;
+use warnings;
+use File::Spec;
+
+BEGIN {
+
+    require Exporter;
+    use vars    qw[$VERSION @ISA @EXPORT];
+  
+    $VERSION    = '0.40';
+    @ISA        = qw[Exporter];
+    @EXPORT     = qw[ BUILD_DIR BUILD ];
+}
+
+
+use constant BUILD_DIR      => sub { return @_
+                                        ? File::Spec->catdir($_[0], '_build')
+                                        : '_build';
+                            }; 
+use constant BUILD          => sub { my $file = @_
+                                        ? File::Spec->catfile($_[0], 'Build')
+                                        : 'Build';
+                                        
+                                     ### on VMS, '.com' is appended when
+                                     ### creating the Build file
+                                     $file .= '.com' if $^O eq 'VMS';     
+                                     
+                                     return $file;
+                            };
+                            
+1;
+
+=head1 NAME
+
+CPANPLUS::Dist::Build::Constants - Constants for CPANPLUS::Dist::Build
+
+=head1 SYNOPSIS
+
+  use CPANPLUS::Dist::Build::Constants;
+
+=head1 DESCRIPTION
+
+CPANPLUS::Dist::Build::Constants provides some constants required by L<CPANPLUS::Dist::Build>.
+
+=head1 AUTHOR
+
+Originally by Jos Boumans E<lt>kane@cpan.orgE<gt>.  Brought to working
+condition and currently maintained by Ken Williams E<lt>kwilliams@cpan.orgE<gt>.
+
+=head1 LICENSE
+
+The CPAN++ interface (of which this module is a part of) is
+copyright (c) 2001, 2002, 2003, 2004, 2005 Jos Boumans E<lt>kane@cpan.orgE<gt>.
+All rights reserved.
+
+This library is free software;
+you may redistribute and/or modify it under the same
+terms as Perl itself.
+
+=cut
+
+# Local variables:
+# c-indentation-style: bsd
+# c-basic-offset: 4
+# indent-tabs-mode: nil
+# End:
+# vim: expandtab shiftwidth=4:
diff --git a/cpan/CPANPLUS-Dist-Build/t/01_CPANPLUS-Dist-Build-Constants.t b/cpan/CPANPLUS-Dist-Build/t/01_CPANPLUS-Dist-Build-Constants.t
new file mode 100644
index 0000000000..a1be08473d
--- /dev/null
+++ b/cpan/CPANPLUS-Dist-Build/t/01_CPANPLUS-Dist-Build-Constants.t
@@ -0,0 +1,33 @@
+### make sure we can find our conf.pl file
+BEGIN { 
+    use FindBin; 
+    require "$FindBin::Bin/inc/conf.pl";
+}
+
+
+
+BEGIN { chdir 't' if -d 't' };
+
+### this is to make devel::cover happy ###
+BEGIN {
+    use File::Spec;
+    require lib;
+    for (qw[../lib inc]) {
+        my $l = 'lib'; $l->import(File::Spec->rel2abs($_)) 
+    }
+}
+
+use strict;
+use Test::More 'no_plan';
+
+my $Class = 'CPANPLUS::Dist::Build::Constants';
+
+
+use_ok( $Class );
+
+for my $name ( qw[BUILD BUILD_DIR] ) {
+
+    my $sub = $Class->can( $name );   
+    ok( $sub,                   "$Class can $name" );
+    ok( $sub->(),               "   $name called OK" );
+}    
diff --git a/cpan/CPANPLUS-Dist-Build/t/02_CPANPLUS-Dist-Build.t b/cpan/CPANPLUS-Dist-Build/t/02_CPANPLUS-Dist-Build.t
new file mode 100644
index 0000000000..23f939831c
--- /dev/null
+++ b/cpan/CPANPLUS-Dist-Build/t/02_CPANPLUS-Dist-Build.t
@@ -0,0 +1,274 @@
+### make sure we can find our conf.pl file
+BEGIN { 
+    use FindBin; 
+    require "$FindBin::Bin/inc/conf.pl";
+}
+
+use strict;
+use CPANPLUS::Configure;
+use CPANPLUS::Backend;
+use CPANPLUS::Internals::Constants;
+use CPANPLUS::Module::Fake;
+use CPANPLUS::Module::Author::Fake;
+
+use Config;
+use Test::More      'no_plan';
+use File::Basename  qw[basename];
+use Data::Dumper;
+use IPC::Cmd        'can_run';
+
+$SIG{__WARN__} = sub {warn @_ unless @_ && $_[0] =~ /redefined|isn't numeric/};
+
+# Load these two modules in advance, even though they would be
+# auto-loaded, because we want to override some of their subs.
+use ExtUtils::Packlist;
+use ExtUtils::Installed;
+
+my $Class   = 'CPANPLUS::Dist::Build';
+my $Utils   = 'CPANPLUS::Internals::Utils';
+my $Have_CC =  can_run($Config{'cc'} )? 1 : 0;
+my $Usedl   = $Config{usedl} ? 1 : 0;
+
+
+my $Lib     = File::Spec->rel2abs(File::Spec->catdir( qw[dummy-perl] ));
+my $Src     = File::Spec->rel2abs(File::Spec->catdir( qw[src] ));
+
+my $Verbose = @ARGV ? 1 : 0;
+my $Conf    = gimme_conf();
+my $CB      = CPANPLUS::Backend->new( $Conf );
+
+#$Conf->set_conf( base       => 'dummy-cpanplus' );
+#$Conf->set_conf( dist_type  => '' );
+#$Conf->set_conf( verbose    => $Verbose );
+#$Conf->set_conf( signature  => 0 );
+### running tests will mess with the test output so skip 'm
+#$Conf->set_conf( skiptest   => 1 );
+
+### create a fake object, so we don't use the actual module tree
+### make sure to add dslip data, so CPANPLUS doesn't try to find
+### it in another module in the package, for which it needs the
+### module tree
+my $Mod = CPANPLUS::Module::Fake->new(
+                module  => 'Foo::Bar',
+                path    => 'src',
+                author  => CPANPLUS::Module::Author::Fake->new,
+                package => 'Foo-Bar-0.01.tar.gz',
+                dslip   => 'RdpO?',
+            );
+
+### dmq tells us that we should run with /nologo
+### if using nmake, as it's very noise otherwise.
+### XXX copied from CPANPLUS' test include file!
+{   my $make = $Conf->get_program('make');
+    if( $make and basename($make) =~ /^nmake/i and
+        $make !~ m|/nologo|
+    ) {
+        $make .= ' /nologo';
+        $Conf->set_program( make => $make );
+    }
+}
+    
+
+                # path, cc needed?
+my %Map     = ( noxs    => 0,
+                xs      => 1 
+            );        
+
+
+### Disable certain possible settings, so we dont accidentally
+### touch anything outside our sandbox
+{   
+    ### set buildflags to install in our dummy perl dir
+    $Conf->set_conf( buildflags => "install_base=$Lib" );
+    
+    ### don't start sending test reports now... ###
+    $CB->_callbacks->send_test_report( sub { 0 } );
+    $Conf->set_conf( cpantest => 0 );
+    
+    ### we dont need sudo -- we're installing in our own sandbox now
+    $Conf->set_program( sudo => undef );
+}
+
+use_ok( $Class );
+
+ok( $Class->format_available,   "Format is available" );
+
+
+while( my($path,$need_cc) = each %Map ) {
+
+    my $mod = $Mod->clone;
+    ok( $mod,                   "Module object created for '$path'" );        
+                
+    ### set the fetch location -- it's local
+    {   my $where = File::Spec->rel2abs(
+                            File::Spec->catfile( $Src, $path, $mod->package )
+                        );
+                        
+        $mod->status->fetch( $where );
+
+        ok( -e $where,          "   Tarball '$where' exists" );
+    }
+
+    ok( $mod->prepare,          "   Preparing module" );
+
+    ok( $mod->status->dist_cpan,    
+                                "   Dist registered as status" );
+
+    isa_ok( $mod->status->dist_cpan, $Class );
+
+    ok( $mod->status->dist_cpan->status->prepared,
+                                "   Prepared status registered" );
+    is( $mod->status->dist_cpan->status->distdir, $mod->status->extract,
+                                "   Distdir status registered properly" );
+
+
+    is( $mod->status->installer_type, INSTALLER_BUILD, 
+                                "   Proper installer type found" );
+
+
+    ### we might not have a C compiler
+    SKIP: {
+        skip("Perl wasn't built with support for dynamic loading " .
+             "-- skipping compile tests", 5) unless $Usedl;
+        skip("The CC compiler listed in Config.pm is not available " .
+             "-- skipping compile tests", 5) if $need_cc && !$Have_CC;
+        skip("Module::Build is not compiled with C support ".
+             "-- skipping compile tests", 5) 
+             unless eval { require Module::Build::ConfigData;
+             Module::Build::ConfigData->feature('C_support') };
+
+        ok( $mod->create( ),    "Creating module" );
+        ok( $mod->status->dist_cpan->status->created,
+                                "   Created status registered" );
+
+        ### install tests
+        SKIP: {
+            skip("Install tests require Module::Build 0.2606 or higher", 2)
+                unless $Module::Build::VERSION >= '0.2606';
+        
+            ### flush the lib cache
+            ### otherwise, cpanplus thinks the module's already installed
+            ### since the blib is already in @INC
+            $CB->_flush( list => [qw|lib|] );
+        
+            ### force the install, make sure the Dist::Build->install()
+            ### sub gets called
+            ok( $mod->install( force => 1 ),
+                                "Installing module" ); 
+            ok( $mod->status->installed,    
+                                "   Status says module installed" );
+        }
+
+        SKIP: {
+            my $minversion = 0.2609;
+            skip(qq[Uninstalling requires at least Module::Build $minversion], 1)
+              unless eval { Module::Build->VERSION($minversion); 1 };
+
+            # The installation directory actually needs to be in @INC
+            # in order to test uninstallation
+            {   my $libdir = File::Spec->catdir($Lib, 'lib', 'perl5');
+                
+                # lib.pm is documented to require unix-style paths
+                $libdir = VMS::Filespec::unixify($libdir) if $^O eq 'VMS';
+
+                'lib'->import( $libdir );
+            }
+
+            # EU::Installed and CP+::M are only capable of searching
+            # for modules in the core directories.  We need to fake
+            # them out with our own subs here.
+            my $packlist = find_module($mod->name . '::.packlist');
+            ok $packlist, "Found packlist";
+            
+            my $p = ExtUtils::Packlist->new($packlist);
+            ok keys(%$p) > 0, "Packlist contains entries";
+
+            local *CPANPLUS::Module::installed_version = sub {1};
+            local *CPANPLUS::Module::packlist = sub { [$p] };
+            local *ExtUtils::Installed::files = sub { keys %$p };
+            
+            ok( $mod->uninstall,"Uninstalling module" );
+        }
+    }
+
+    ### throw away all the extracted stuff
+    $Utils->_rmdir( dir => $Conf->get_conf('base') );
+}
+
+### test ENV setting while running Build.PL code
+SKIP: {   ### use print() not die() -- we're redirecting STDERR in tests!
+    my $env     = ENV_CPANPLUS_IS_EXECUTING;
+    skip("Can't test ENV{$env} -- no buffers available")
+      unless IPC::Cmd->can_capture_buffer;
+    my $clone   = $Mod->clone;
+    
+    ok( $clone,                 'Testing ENV settings $dist->prepare' );
+    
+    $clone->status->fetch( File::Spec->catfile($Src, 'noxs', $clone->package) );
+    ok( $clone->extract,        '   Files extracted' );
+    
+    ### write our own Build.PL file    
+    my $build_pl = BUILD_PL->( $clone->status->extract );
+    {   my $fh   = OPEN_FILE->( $build_pl, '>' );
+        print $fh "die qq[ENV=\$ENV{$env}\n];";
+        close $fh;
+    }
+    ok( -e $build_pl,           "   File exists" );
+
+    ### clear errors    
+    CPANPLUS::Error->flush;
+
+    ### since we're die'ing in the Build.PL, localize 
+    ### $CPANPLUS::Error::ERROR_FH and redirect to devnull
+    ### so we dont spam the result through the test 
+    ### as this is expected behaviour after all.
+    my $rv = do {
+        local *CPANPLUS::Error::ERROR_FH;
+        open $CPANPLUS::Error::ERROR_FH, ">", File::Spec->devnull;
+        $clone->prepare( force => 1 ) 
+    };
+    ok( !$rv,                   '   $mod->prepare failed' );
+
+    my $re = quotemeta( $build_pl );
+    like( CPANPLUS::Error->stack_as_string, qr/ENV=$re/,
+                                "   \$ENV $env set correctly during execution");
+
+    ### and the ENV var should no longer be set now
+    ok( !$ENV{$env},            "   ENV var now unset" );
+}    
+
+
+sub find_module {
+  my $module = shift;
+
+  ### Don't add the .pm yet, in case it's a packlist or something 
+  ### like ExtUtils::xsubpp.
+  my $file = File::Spec->catfile( split m/::/, $module );
+  my $candidate;
+  foreach (@INC) {
+    if (-e ($candidate = File::Spec->catfile($_, $file))
+        or
+        -e ($candidate = File::Spec->catfile($_, "$file.pm"))
+        or
+        -e ($candidate = File::Spec->catfile($_, 'auto', $file))
+        or
+        -e ($candidate = File::Spec->catfile($_, 'auto', "$file.pm"))
+        or
+        -e ($candidate = File::Spec->catfile($_, $Config{archname},
+                                             'auto', $file))
+        or
+        -e ($candidate = File::Spec->catfile($_, $Config{archname},
+                                             'auto', "$file.pm"))) {
+      return $candidate;
+    }
+  }
+  return;
+}
+
+
+# Local variables:
+# c-indentation-style: bsd
+# c-basic-offset: 4
+# indent-tabs-mode: nil
+# End:
+# vim: expandtab shiftwidth=4:
diff --git a/cpan/CPANPLUS-Dist-Build/t/dummy-CPAN/authors/01mailrc.txt.gz b/cpan/CPANPLUS-Dist-Build/t/dummy-CPAN/authors/01mailrc.txt.gz
new file mode 100644
index 0000000000..92716ebc1f
--- /dev/null
+++ b/cpan/CPANPLUS-Dist-Build/t/dummy-CPAN/authors/01mailrc.txt.gz
diff --git a/cpan/CPANPLUS-Dist-Build/t/dummy-CPAN/modules/02packages.details.txt.gz b/cpan/CPANPLUS-Dist-Build/t/dummy-CPAN/modules/02packages.details.txt.gz
new file mode 100644
index 0000000000..898bef1e22
--- /dev/null
+++ b/cpan/CPANPLUS-Dist-Build/t/dummy-CPAN/modules/02packages.details.txt.gz
diff --git a/cpan/CPANPLUS-Dist-Build/t/dummy-CPAN/modules/03modlist.data.gz b/cpan/CPANPLUS-Dist-Build/t/dummy-CPAN/modules/03modlist.data.gz
new file mode 100644
index 0000000000..6574e158bd
--- /dev/null
+++ b/cpan/CPANPLUS-Dist-Build/t/dummy-CPAN/modules/03modlist.data.gz
diff --git a/cpan/CPANPLUS-Dist-Build/t/dummy-perl/.hidden b/cpan/CPANPLUS-Dist-Build/t/dummy-perl/.hidden
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/cpan/CPANPLUS-Dist-Build/t/dummy-perl/.hidden
diff --git a/cpan/CPANPLUS-Dist-Build/t/inc/conf.pl b/cpan/CPANPLUS-Dist-Build/t/inc/conf.pl
new file mode 100644
index 0000000000..f8268b1167
--- /dev/null
+++ b/cpan/CPANPLUS-Dist-Build/t/inc/conf.pl
@@ -0,0 +1,278 @@
+### On VMS, the ENV is not reset after the program terminates.
+### So reset it here explicitly
+my ($old_env_path, $old_env_perl5lib);
+BEGIN {
+    use FindBin; 
+    use File::Spec;
+    
+    ### paths to our own 'lib' and 'inc' dirs
+    ### include them, relative from t/
+    my @paths   = map { "$FindBin::Bin/$_" } qw[../lib inc];
+
+    ### absolute'ify the paths in @INC;
+    my @rel2abs = map { File::Spec->rel2abs( $_ ) }
+                    grep { not File::Spec->file_name_is_absolute( $_ ) } @INC;
+    
+    ### use require to make devel::cover happy
+    require lib;
+    for ( @paths, @rel2abs ) { 
+        my $l = 'lib'; 
+        $l->import( $_ ) 
+    }
+
+    use Config;
+
+    ### and add them to the environment, so shellouts get them
+    $old_env_perl5lib = $ENV{'PERL5LIB'};
+    $ENV{'PERL5LIB'}  = join $Config{'path_sep'}, 
+                        grep { defined } $ENV{'PERL5LIB'}, @paths, @rel2abs;
+    
+    ### add CPANPLUS' bin dir to the front of $ENV{PATH}, so that cpanp-run-perl
+    ### and friends get picked up, only under PERL_CORE though.
+    if ( $ENV{PERL_CORE} ) {
+       $old_env_path = $ENV{PATH};
+       $ENV{'PATH'}  = join $Config{'path_sep'}, 
+                    grep { defined } "$FindBin::Bin/../../CPANPLUS/bin", $ENV{'PATH'};
+
+    }
+
+    ### Fix up the path to perl, as we're about to chdir
+    ### but only under perlcore, or if the path contains delimiters,
+    ### meaning it's relative, but not looked up in your $PATH
+    $^X = File::Spec->rel2abs( $^X ) 
+        if $ENV{PERL_CORE} or ( $^X =~ m|[/\\]| );
+
+    ### chdir to our own test dir, so we know all files are relative 
+    ### to this point, no matter whether run from perlcore tests or
+    ### regular CPAN installs
+    chdir "$FindBin::Bin" if -d "$FindBin::Bin"
+}
+
+BEGIN {
+    use IPC::Cmd;
+   
+    ### Win32 has issues with redirecting FD's properly in IPC::Run:
+    ### Can't redirect fd #4 on Win32 at IPC/Run.pm line 2801
+    $IPC::Cmd::USE_IPC_RUN = 0 if $^O eq 'MSWin32';
+    $IPC::Cmd::USE_IPC_RUN = 0 if $^O eq 'MSWin32';
+}
+
+### Use a $^O comparison, as depending on module at this time
+### may cause weird errors/warnings
+END {
+    if ($^O eq 'VMS') {
+        ### VMS environment variables modified by this test need to be put back
+        ### path is "magic" on VMS, we can not tell if it really existed before
+        ### this was run, because VMS will magically pretend that a PATH
+        ### environment variable exists set to the current working directory
+        $ENV{PATH} = $old_env_path;
+
+        if (defined $old_env_perl5lib) {
+            $ENV{PERL5LIB} = $old_env_perl5lib;
+        } else {
+            delete $ENV{PERL5LIB};
+        }
+    }
+}
+
+use strict;
+use CPANPLUS::Configure;
+use CPANPLUS::Error ();
+
+use File::Path      qw[rmtree];
+use FileHandle;
+use File::Basename  qw[basename];
+
+{   ### Force the ignoring of .po files for L::M::S
+    $INC{'Locale::Maketext::Lexicon.pm'} = __FILE__;
+    $Locale::Maketext::Lexicon::VERSION = 0;
+}
+
+my $Env = 'PERL5_CPANPLUS_TEST_VERBOSE';
+
+# prereq has to be in our package file && core!
+use constant TEST_CONF_PREREQ           => 'Cwd';   
+use constant TEST_CONF_MODULE           => 'Foo::Bar::EU::NOXS';
+use constant TEST_CONF_MODULE_SUB       => 'Foo::Bar::EU::NOXS::Sub';
+use constant TEST_CONF_AUTHOR           => 'EUNOXS';
+use constant TEST_CONF_INST_MODULE      => 'Foo::Bar';
+use constant TEST_CONF_INVALID_MODULE   => 'fnurk';
+use constant TEST_CONF_MIRROR_DIR       => 'dummy-localmirror';
+use constant TEST_CONF_CPAN_DIR         => 'dummy-CPAN';
+use constant TEST_CONF_CPANPLUS_DIR     => 'dummy-cpanplus';
+use constant TEST_CONF_INSTALL_DIR      => File::Spec->rel2abs(
+                                                File::Spec->catdir(      
+                                                    TEST_CONF_CPANPLUS_DIR,
+                                                    'install'
+                                                )
+                                            );       
+
+### we might need this Some Day when we're installing into
+### our own sandbox. see t/20.t for details
+# use constant TEST_INSTALL_DIR       => do {
+#     my $dir = File::Spec->rel2abs( 'dummy-perl' );
+# 
+#     ### clean up paths if we are on win32    
+#     ### dirs with spaces will be.. bad :(
+#     $^O eq 'MSWin32'
+#         ? Win32::GetShortPathName( $dir )
+#         : $dir;
+# };        
+
+# use constant TEST_INSTALL_DIR_LIB 
+#     => File::Spec->catdir( TEST_INSTALL_DIR, 'lib' );
+# use constant TEST_INSTALL_DIR_BIN 
+#     => File::Spec->catdir( TEST_INSTALL_DIR, 'bin' );
+# use constant TEST_INSTALL_DIR_MAN1 
+#     => File::Spec->catdir( TEST_INSTALL_DIR, 'man', 'man1' );
+# use constant TEST_INSTALL_DIR_MAN3
+#     => File::Spec->catdir( TEST_INSTALL_DIR, 'man', 'man3' );
+# use constant TEST_INSTALL_DIR_ARCH
+#     => File::Spec->catdir( TEST_INSTALL_DIR, 'arch' );
+# 
+# use constant TEST_INSTALL_EU_MM_FLAGS =>
+#     ' INSTALLDIRS=site' .
+#     ' INSTALLSITELIB='     . TEST_INSTALL_DIR_LIB .
+#     ' INSTALLSITEARCH='    . TEST_INSTALL_DIR_ARCH .    # .packlist
+#     ' INSTALLARCHLIB='     . TEST_INSTALL_DIR_ARCH .    # perllocal.pod
+#     ' INSTALLSITEBIN='     . TEST_INSTALL_DIR_BIN .
+#     ' INSTALLSCRIPT='      . TEST_INSTALL_DIR_BIN .
+#     ' INSTALLSITEMAN1DIR=' . TEST_INSTALL_DIR_MAN1 .
+#     ' INSTALLSITEMAN3DIR=' . TEST_INSTALL_DIR_MAN3;
+
+
+sub dummy_cpan_dir {
+    ### VMS needs this in directory format for rel2abs
+    my $test_dir = $^O eq 'VMS'
+                    ? File::Spec->catdir(TEST_CONF_CPAN_DIR)
+                    : TEST_CONF_CPAN_DIR;
+
+    ### Convert to an absolute file specification
+    my $abs_test_dir = File::Spec->rel2abs($test_dir);
+    
+    ### According to John M: the hosts path needs to be in UNIX format.  
+    ### File::Spec::Unix->rel2abs does not work at all on VMS
+    $abs_test_dir    = VMS::Filespec::unixify( $abs_test_dir ) if $^O eq 'VMS';
+
+    return $abs_test_dir;
+}
+
+sub gimme_conf { 
+
+    ### don't load any other configs than the heuristic one
+    ### during tests. They might hold broken/incorrect data
+    ### for our test suite. Bug [perl #43629] showed this.
+    my $conf = CPANPLUS::Configure->new( load_configs => 0 );
+
+    my $dummy_cpan = dummy_cpan_dir();
+    
+    $conf->set_conf( hosts  => [ { 
+                        path        => $dummy_cpan,
+                        scheme      => 'file',
+                    } ],      
+    );
+    $conf->set_conf( base       => File::Spec->rel2abs(TEST_CONF_CPANPLUS_DIR));
+    $conf->set_conf( dist_type  => '' );
+    $conf->set_conf( signature  => 0 );
+    $conf->set_conf( verbose    => 1 ) if $ENV{ $Env };
+    
+    ### never use a pager in the test suite
+    $conf->set_program( pager   => '' );
+
+    ### dmq tells us that we should run with /nologo
+    ### if using nmake, as it's very noisy otherwise.
+    {   my $make = $conf->get_program('make');
+        if( $make and basename($make) =~ /^nmake/i ) {
+            $conf->set_conf( makeflags => '/nologo' );
+        }
+    }
+
+    $conf->set_conf( source_engine =>  $ENV{CPANPLUS_SOURCE_ENGINE} )
+        if $ENV{CPANPLUS_SOURCE_ENGINE};
+    
+    _clean_test_dir( [
+        $conf->get_conf('base'),     
+        TEST_CONF_MIRROR_DIR,
+#         TEST_INSTALL_DIR_LIB,
+#         TEST_INSTALL_DIR_BIN,
+#         TEST_INSTALL_DIR_MAN1, 
+#         TEST_INSTALL_DIR_MAN3,
+    ], (  $ENV{PERL_CORE} ? 0 : 1 ) );
+        
+    return $conf;
+};
+
+# placeholder
+
+### clean these files if we're under perl core
+END { 
+    if ( $ENV{PERL_CORE} ) {
+
+        _clean_test_dir( [
+            gimme_conf->get_conf('base'),   
+            TEST_CONF_MIRROR_DIR,
+    #         TEST_INSTALL_DIR_LIB,
+    #         TEST_INSTALL_DIR_BIN,
+    #         TEST_INSTALL_DIR_MAN1, 
+    #         TEST_INSTALL_DIR_MAN3,
+        ], 0 ); # DO NOT be verbose under perl core -- makes tests fail
+    }
+}
+
+### whenever we start a new script, we want to clean out our
+### old files from the test '.cpanplus' dir..
+sub _clean_test_dir {
+    my $dirs    = shift || [];
+    my $verbose = shift || 0;
+
+    for my $dir ( @$dirs ) {
+
+        ### no point if it doesn't exist;
+        next unless -d $dir;
+
+        my $dh;
+        opendir $dh, $dir or die "Could not open basedir '$dir': $!";
+        while( my $file = readdir $dh ) { 
+            next if $file =~ /^\./;  # skip dot files
+            
+            my $path = File::Spec->catfile( $dir, $file );
+            
+            ### directory, rmtree it
+            if( -d $path ) {
+
+                ### John Malmberg reports yet another VMS issue:
+                ### A directory name on VMS in VMS format ends with .dir 
+                ### when it is referenced as a file.
+                ### In UNIX format traditionally PERL on VMS does not remove the
+                ### '.dir', however the VMS C library conversion routines do
+                ### remove the '.dir' and the VMS C library routines can not 
+                ### handle the '.dir' being present on UNIX format filenames.
+                ### So code doing the fixup has on VMS has to be able to handle 
+                ### both UNIX format names and VMS format names. 
+                
+                ### XXX See http://www.xray.mpe.mpg.de/
+                ### mailing-lists/perl5-porters/2007-10/msg00064.html
+                ### for details -- the below regex could use some touchups
+                ### according to John. M.            
+                $file =~ s/\.dir$//i if $^O eq 'VMS';
+                
+                my $dirpath = File::Spec->catdir( $dir, $file );
+
+                print "# Deleting directory '$dirpath'\n" if $verbose;
+                eval { rmtree( $dirpath ) };
+                warn "Could not delete '$dirpath' while cleaning up '$dir'" 
+                    if $@;
+           
+            ### regular file
+            } else {
+                print "# Deleting file '$path'\n" if $verbose;
+                1 while unlink $path;
+            }            
+        }       
+    
+        close $dh;
+    }
+    
+    return 1;
+}
+1;
diff --git a/cpan/CPANPLUS-Dist-Build/t/src/noxs/Foo-Bar-0.01.tar.gz b/cpan/CPANPLUS-Dist-Build/t/src/noxs/Foo-Bar-0.01.tar.gz
new file mode 100644
index 0000000000..0d499cd40d
--- /dev/null
+++ b/cpan/CPANPLUS-Dist-Build/t/src/noxs/Foo-Bar-0.01.tar.gz
diff --git a/cpan/CPANPLUS-Dist-Build/t/src/xs/Foo-Bar-0.01.tar.gz b/cpan/CPANPLUS-Dist-Build/t/src/xs/Foo-Bar-0.01.tar.gz
new file mode 100644
index 0000000000..a092523e36
--- /dev/null
+++ b/cpan/CPANPLUS-Dist-Build/t/src/xs/Foo-Bar-0.01.tar.gz