| Module::Load::Conditional - Looking up module information / loading at runtime |
Module::Load::Conditional - Looking up module information / loading at runtime
use Module::Load::Conditional qw[can_load check_install requires];
my $use_list = {
CPANPLUS => 0.05,
LWP => 5.60,
'Test::More' => undef,
};
print can_load( modules => $use_list )
? 'all modules loaded successfully'
: 'failed to load required modules';
my $rv = check_install( module => 'LWP', version => 5.60 )
or print 'LWP is not installed!';
print 'LWP up to date' if $rv->{uptodate};
print "LWP version is $rv->{version}\n";
print "LWP is installed as file $rv->{file}\n";
print "LWP requires the following modules to be installed:\n";
print join "\n", requires('LWP');
### allow M::L::C to peek in your %INC rather than just
### scanning @INC
$Module::Load::Conditional::CHECK_INC_HASH = 1;
### reset the 'can_load' cache
undef $Module::Load::Conditional::CACHE;
### don't have Module::Load::Conditional issue warnings --
### default is '1'
$Module::Load::Conditional::VERBOSE = 0;
### The last error that happened during a call to 'can_load'
my $err = $Module::Load::Conditional::ERROR;
Module::Load::Conditional provides simple ways to query and possibly load any of the modules you have installed on your system during runtime.
It is able to load multiple modules at once or none at all if one of them was not able to load. It also takes care of any error checking and so forth.
check_install allows you to verify if a certain module is installed
or not. You may call it with the following arguments:
It will return undef if it was not able to find where the module was installed, or a hash reference with the following keys if it was able to find the file:
@INC entry, where the module was
loaded from.
undef if
the module had no (or unparsable) version number, or if the variable
$Module::Load::Conditional::FIND_VERSION was set to true.
(See the GLOBAL VARIABLES section below for details)
check_install had no way to verify clearly.
See also $Module::Load::Conditional::DEPRECATED, which affects
the outcome of this value.
can_load will take a list of modules, optionally with version
numbers and determine if it is able to load them. If it can load *ALL*
of them, it will. If one or more are unloadable, none will be loaded.
This is particularly useful if you have More Than One Way (tm) to solve a problem in a program, and only wish to continue down a path if all modules could be loaded, and not load them if they couldn't.
This function uses the load function or the autoload_remote function
from Module::Load under the hood.
can_load takes the following arguments:
can_load keeps its results in a cache, so it will not load the
same module twice, nor will it attempt to load a module that has
already failed to load before. By default, can_load will check its
cache, but you can override that by setting nocache to true.
See the autoload function and the autoload_remote function from the Module::Load manpage for details.
requires can tell you what other modules a particular module
requires. This is particularly useful when you're intending to write
a module for public release and are listing its prerequisites.
requires takes but one argument: the name of a module.
It will then first check if it can actually load this module, and
return undef if it can't.
Otherwise, it will return a list of modules and pragmas that would
have been loaded on the module's behalf.
Note: The list require returns has originated from your current
perl and your current install.
The behaviour of Module::Load::Conditional can be altered by changing the following global variables:
This controls whether Module::Load::Conditional will issue warnings and explanations as to why certain things may have failed. If you set it to 0, Module::Load::Conditional will not output any warnings. The default is 0;
This controls whether Module::Load::Conditional will try to parse (and eval) the version from the module you're trying to load.
If you don't wish to do this, set this variable to false. Understand
then that version comparisons are not possible, and Module::Load::Conditional
can not tell you what module version you have installed.
This may be desirable from a security or performance point of view.
Note that $FIND_VERSION code runs safely under taint mode.
The default is 1;
This controls whether Module::Load::Conditional checks your
%INC hash to see if a module is available. By default, only
@INC is scanned to see if a module is physically on your
filesystem, or available via an @INC-hook. Setting this variable
to true will trust any entries in %INC and return them for
you.
The default is 0;
This controls whether Module::Load::Conditional sanitises @INC
by removing ``.''. The current default setting is 0, but this
may change in a future release.
This holds the cache of the can_load function. If you explicitly
want to remove the current cache, you can set this variable to
undef
This holds a string of the last error that happened during a call to
can_load. It is useful to inspect this when can_load returns
undef.
This controls whether Module::Load::Conditional checks if
a dual-life core module has been deprecated. If this is set to
true check_install will return false to uptodate, if
a dual-life module is found to be loaded from $Config{privlibexp}
The default is 0;
Module::Load
Please report bugs or other issues to <bug-module-load-conditional@rt.cpan.org>.
This module by Jos Boumans <kane@cpan.org>.
This library is free software; you may redistribute and/or modify it under the same terms as Perl itself.
| Module::Load::Conditional - Looking up module information / loading at runtime |