local::lib::deps - Maintain a module specific lib path for that modules dependencies.

    use local::lib::deps;
    $local::lib::deps->install_deps( 'My::Module', 'Dep::One', 'Dep::Two' );

    use local::lib::deps;
    $moduledeps = local::lib::deps->new(
        base_path => '/path/to/dep/storage',
    );
    $moduledeps->install_deps( 'My::Module', 'Dep::One', 'Dep::Two', ... );

    use local::lib::deps qw/ My::Module My::ModuleTwo/;
    use Dep::One;

    use local::lib::deps;
    BEGIN {
        $moduledeps = local::lib::deps->new(
            base_path => '/path/to/dep/storage',
        );
        $moduledeps->add_paths( qw/ My::Module My::ModuleTwo/ );
    }
    use Dep::One;

    use local::lib::deps -locallib => 'My::Module';

    use local::lib::deps;
    $moduledeps = local::lib::deps->new(
        module => 'My::Module',
        base_path => '/path/to/dep/storage',
    );
    $moduledeps->locallib;

package local::lib::deps;
use warnings;
use strict;
use Cwd;
use Config;
use Data::Dumper;

our $VERSION = 0.09;
our %PATHS_ADDED;
our $START_PATH = getcwd();
our %INITIALIZED;

sub import {
    my ( $package, @params ) = @_;
    my @modules = grep { $_ !~ m/^-/ } @params;
                      # Copy $_ so we don't change @params
    my %flags = map { my $i = $_; $i =~ s/^-//g; $i => 1 } grep { $_ =~ m/^-/ } @params;
    unless ( @modules ) {
        my ($module) = caller;
        @modules = ( $module );
    }
    if ( $flags{locallib} ) {
        die( "Can only specify one module to use with the -locallib flag.\n" ) if @modules > 1;
        $package->locallib( @modules );
        return;
    }
    $package->add_paths( @modules );
}

sub new {
    my ( $class, %params ) = @_;
    $class = ref $class || $class;
    return bless( { %params }, $class );
}

sub add_paths {
    my $self = shift;
    my  @modules = @_;
    $self->_add_path( $_ ) for @modules;
}

sub locallib {
    my ( $self, $module ) = @_;
    $module = $self->module if $self->is_object;
    my $mpath = __absolute_path( $self->_full_module_path( $module ));
    $self->_add_path( $module );
    eval "use local::lib '$mpath'";
    die( $@ ) if $@;
}

sub install_deps {
    my ( $self, $pkg, @deps) = @_;
    print "Forking child process to run cpan...\n";
    if ( my $pid = fork ) {
        waitpid( $pid, 0 );
    }
    else {
        $self->_install_deps( $pkg, @deps );
        exit;
    }
}

sub force_deps {
    my ( $self, $pkg, @deps) = @_;
    print "Forking child process to run cpan (force)...\n";
    if ( my $pid = fork ) {
        waitpid( $pid, 0 );
    }
    else {
        $self->_force_deps( $pkg, @deps );
        exit;
    }
}

sub is_object {
    my $self = shift;
    return unless ref $self;
    return UNIVERSAL::isa( $self, 'UNIVERSAL' );
}

sub module {
    my $self = shift;
    return unless $self->is_object;
    return $self->{ module };
}

sub base_path {
    my $self = shift;
    my $class = $self;
    if ( $self->is_object ) {
        return $self->{ base_path } if $self->{ base_path };
        $class = ref $self;
    }

#    my $llpath = __FILE__;
#    $llpath =~ s,/[^/]*$,,ig;
#    $llpath .= '/deps';

    my $file = $INC{ join("/", split('::', $class)) . ".pm" } || __FILE__;
    my $path = $file;
    $path =~ s,/[^/]*$,,ig;
    $path .= '/deps';

    $self->{ base_path } = $path if ( $self->is_object );

    return $path;
}

sub cpan_config {
    my $self = shift;
    return $self->{ cpan_config };
}

sub _module_path {
    my $self = shift;
    my ( $module ) = @_;
    my $mpath = $module;
    $mpath =~ s,::,/,g;
    return $mpath;
}

sub _full_module_path {
    my $self = shift;
    return join( "/", $self->base_path(), $self->_module_path( @_ ));
}

sub _add_path {
    my $self = shift;
    my ( $module ) = @_;

    for my $path ( $self->_path( $module ), $self->_arch_path( $module )) {
        $path = __absolute_path( $path );
        next if $PATHS_ADDED{ $path }++;
        unshift @INC, $path;
    }
    #Shamelessly copied from local::lib;
    $ENV{PERL5LIB} = join( $Config{path_sep}, @INC );
}

sub _path {
    my $self = shift;
    return join( "/", $self->_full_module_path( @_ ), "lib/perl5" );
}

sub _arch_path {
    my $self = shift;
    return join( "/", $self->_path( @_ ), $Config{archname});
}

sub __absolute_path {
    my ( $dir ) = @_;
    if ( $dir !~ m,^/, ) {
        return "$START_PATH/$dir";
    }
    return $dir;
}

sub _force_deps {
    my $self = shift;
    $self->_do_deps( 'force', @_ );
}

sub _install_deps {
    my $self = shift;
    $self->_do_deps( 'normal', @_ );
}

#our %INITIALIZED;
sub _do_deps {
    my $self = shift;
    my ($mode, $pkg, @deps) = @_;
    my $origin = getcwd();

    require CPAN;
    CPAN::HandleConfig->load();
    $CPAN::Config = {
        %{ $CPAN::Config },
        %{ $self->cpan_config },
    };
    CPAN::Shell::setup_output();
    CPAN::Index->reload();

    unless ( $INITIALIZED{ $pkg }++ ) {
        local $CPAN::Config->{makepl_arg} = '--bootstrap=' . __absolute_path( $self->_full_module_path( $pkg ));
        CPAN::Shell->install( 'local::lib' );
    }

    # We want to install to the locallib.
    chdir( $origin );
    $self->locallib( $pkg );
    if ( $self->{ debug } ) {
        require Data::Dumper;
        Data::Dumper->import;
        print Dumper({ INC => \@INC, ENV => \%ENV, Config => $CPAN::Config });
    }

    foreach my $dep ( @deps ) {
        CPAN::Shell->install( $dep ) if $mode eq 'normal';
        CPAN::Shell->force( 'install', $dep ) if $mode eq 'force';
    }

    # Be kind rewind.
    chdir( $origin );
}

1;

__END__