File Coverage

blib/lib/lazy.pm

Criterion	Covered	Total	%
statement	41	48	85.4
branch	7	10	70.0
condition	11	15	73.3
subroutine	8	9	88.8
pod			n/a
total	67	82	81.7

package lazy;

use strict;
use warnings;

our $VERSION = '0.000007';

use App::cpm 0.975;    # CLI has no $VERSION
use App::cpm::CLI;

# Cargo-culted from App::cpm::CLI
# Adding pass_through so that we don't have to keep up with all possible options
use Getopt::Long qw(
    :config
    no_auto_abbrev
    no_ignore_case
    bundling
    pass_through
);

use Module::Loaded qw( is_loaded );

sub import {
    shift;
    my @args = @_;

    my $is_global;
    my $local_lib;

    {
        local @ARGV = @args;

        # Stolen from App::cpm::CLI::parse_options()
        GetOptions(
            'L|local-lib-contained=s' => \$local_lib,
            'g|global'                => \$is_global,
        );
    }

    # Generally assume a global install, which makes the invocation as
    # simple as:

    # perl -Mlazy foo.pl

    # However, if we're already using local::lib and --global has not been
    # explicitly set and no local::lib has been explicitly set, let's try
    # to DTRT and use the correct local::lib.

    # This allows us to do something like:
    # perl -Mlocal::lib -Mlazy foo.pl

    # This may or may not be a good idea.

    # Allowing --local-lib-contained to be passed is mostly useful for
    # testing.  For real world cases, the user should specify the
    # local::lib via local::lib itself.

    # perl -Mlocal::lib=my_local_lib -Mlazy foo.pl

    if ( ( !$is_global && !$local_lib ) && is_loaded('local::lib') ) {
        my @paths = local::lib->new->active_paths;
        my $path  = shift @paths;
        if ($path) {
            push @args, ( '-L', $path );
            _print_msg_about_local_lib($path);
        }
    }

    # Assume a global install if local::lib is not in use or has not been
    # explicitly invoked.

    elsif ( !$is_global && !$local_lib ) {
        push @args, ('-g');
    }

    my $cpm = App::cpm::CLI->new;

    # Push the hook onto @INC and then re-add all of @INC again.  This way, if
    # we got to the hook and tried to install, we can re-try @INC to see if the
    # module can now be used.

    push @INC, sub {
        shift;

        my $name = shift;
        $name =~ s{/}{::}g;
        $name =~ s{\.pm\z}{};

        # Don't try to install if we're called inside an eval
        # See https://stackoverflow.com/questions/51483287/how-to-detect-if-perl-code-is-being-run-inside-an-eval/
        for my $level ( 0 .. 20 ) {
            my @caller = caller($level);
            last unless @caller;

            if (
                (
                       ( $caller[1] && $caller[1] =~ m{eval} )
                    || ( $caller[3] && $caller[3] =~ m{eval} )
                )
                && ( $caller[0] ne 'Capture::Tiny' )
            ) {
                my @args = (
                    $caller[0], $name, $name, $caller[1], $caller[2],
                    $caller[0]
                );
                warn sprintf( <<'EOF', @args );
Code in package "%s" is attempting to load %s from inside an eval, so we are not installing %s.
See %s at line %s
Please open an issue if %s should be whitelisted.
EOF
                return;
            }
        }

        $cpm->run( 'install', @args, $name );
        return 1;
    }, @INC;
}

sub _print_msg_about_local_lib {
    my $path = shift;

    print <<"EOF";

********

You haven't included any arguments for App::cpm via lazy, but you've
loaded local::lib, so we're going to install all modules into:

$path

If you do not want to do this, you can explicitly invoke a global install via:

    perl -Mlazy=-g path/to/script.pl

or, from inside your code:

    use lazy qw( -g );

If you would like to install to a different local lib:

    perl -Mlocal::lib=my_local_lib -Mlazy path/to/script.pl

or, from inside your code:

    use local::lib qw( my_local_lib );
    use lazy;

********

EOF
}

1;

# ABSTRACT: Lazily install missing Perl modules

__END__