diff options
Diffstat (limited to 'Master/tlpkg/tlperl/lib/Module/Load.pm')
| -rw-r--r-- | Master/tlpkg/tlperl/lib/Module/Load.pm | 214 |
1 files changed, 192 insertions, 22 deletions
diff --git a/Master/tlpkg/tlperl/lib/Module/Load.pm b/Master/tlpkg/tlperl/lib/Module/Load.pm index 60464847449..9e69f832300 100644 --- a/Master/tlpkg/tlperl/lib/Module/Load.pm +++ b/Master/tlpkg/tlperl/lib/Module/Load.pm @@ -1,19 +1,69 @@ package Module::Load; -$VERSION = '0.24'; +$VERSION = '0.32'; use strict; +use warnings; use File::Spec (); sub import { my $who = _who(); + my $h; shift; { no strict 'refs'; - *{"${who}::load"} = *load; + + @_ or ( + *{"${who}::load"} = \&load, # compat to prev version + *{"${who}::autoload"} = \&autoload, + return + ); + + map { $h->{$_} = () if defined $_ } @_; + + (exists $h->{none} or exists $h->{''}) + and shift, last; + + ((exists $h->{autoload} and shift,1) or (exists $h->{all} and shift)) + and *{"${who}::autoload"} = \&autoload; + + ((exists $h->{load} and shift,1) or exists $h->{all}) + and *{"${who}::load"} = \&load; + + ((exists $h->{load_remote} and shift,1) or exists $h->{all}) + and *{"${who}::load_remote"} = \&load_remote; + + ((exists $h->{autoload_remote} and shift,1) or exists $h->{all}) + and *{"${who}::autoload_remote"} = \&autoload_remote; + } + +} + +sub load(*;@){ + goto &_load; +} + +sub autoload(*;@){ + unshift @_, 'autoimport'; + goto &_load; +} + +sub load_remote($$;@){ + my ($dst, $src, @exp) = @_; + + eval "package $dst;Module::Load::load('$src', qw/@exp/);"; + $@ && die "$@"; } -sub load (*;@) { +sub autoload_remote($$;@){ + my ($dst, $src, @exp) = @_; + + eval "package $dst;Module::Load::autoload('$src', qw/@exp/);"; + $@ && die "$@"; +} + +sub _load{ + my $autoimport = $_[0] eq 'autoimport' and shift; my $mod = shift or return; my $who = _who(); @@ -34,13 +84,20 @@ sub load (*;@) { ### This addresses #41883: Module::Load cannot import ### non-Exporter module. ->import() routines weren't ### properly called when load() was used. + { no strict 'refs'; my $import; - if (@_ and $import = $mod->can('import')) { - unshift @_, $mod; - goto &$import; - } + + ((@_ or $autoimport) and ( + $import = $mod->can('import') + ) and ( + unshift(@_, $mod), + goto &$import, + return + ) + ); } + } sub _to_file{ @@ -92,26 +149,31 @@ Module::Load - runtime require of both modules and files =head1 SYNOPSIS - use Module::Load; + use Module::Load; + + my $module = 'Data::Dumper'; + + load Data::Dumper; # loads that module, but not import any functions + # -> cannot use 'Dumper' function - my $module = 'Data:Dumper'; - load Data::Dumper; # loads that module - load 'Data::Dumper'; # ditto - load $module # tritto + load 'Data::Dumper'; # ditto + load $module # tritto - my $script = 'some/script.pl' - load $script; - load 'some/script.pl'; # use quotes because of punctuations + autoload Data::Dumper; # loads that module and imports the default functions + # -> can use 'Dumper' function - load thing; # try 'thing' first, then 'thing.pm' + my $script = 'some/script.pl' + load $script; + load 'some/script.pl'; # use quotes because of punctuations - load CGI, ':standard' # like 'use CGI qw[:standard]' + load thing; # try 'thing' first, then 'thing.pm' + load CGI, ':all'; # like 'use CGI qw[:standard]' =head1 DESCRIPTION -C<load> eliminates the need to know whether you are trying to require -either a file or a module. +C<Module::Load> eliminates the need to know whether you are trying +to require either a file or a module. If you consult C<perldoc -f require> you will see that C<require> will behave differently when given a bareword or a string. @@ -124,11 +186,80 @@ modules at runtime, since you will need to change the module notation (C<Acme::Comment>) to a file notation fitting the particular platform you are on. -C<load> eliminates the need for this overhead and will just DWYM. +C<Module::Load> eliminates the need for this overhead and will +just DWYM. + +=head2 Difference between C<load> and C<autoload> + +C<Module::Load> imports the two functions - C<load> and C<autoload> + +C<autoload> imports the default functions automatically, +but C<load> do not import any functions. + +C<autoload> is usable under C<BEGIN{};>. + +Both the functions can import the functions that are specified. + +Following codes are same. + + load File::Spec::Functions, qw/splitpath/; + + autoload File::Spec::Functions, qw/splitpath/; + +=head1 FUNCTIONS + +=over 4 + +=item load + +Loads a specified module. + +See L</Rules> for detailed loading rule. + +=item autoload + +Loads a specified module and imports the default functions. + +Except importing the functions, 'autoload' is same as 'load'. + +=item load_remote + +Loads a specified module to the specified package. + + use Module::Load 'load_remote'; + + my $pkg = 'Other::Package'; + + load_remote $pkg, 'Data::Dumper'; # load a module to 'Other::Package' + # but do not import 'Dumper' function + +A module for loading must be quoted. + +Except specifing the package and quoting module name, +'load_remote' is same as 'load'. + +=item autoload_remote + +Loads a specified module and imports the default functions to the specified package. + + use Module::Load 'autoload_remote'; + + my $pkg = 'Other::Package'; + + autoload_remote $pkg, 'Data::Dumper'; # load a module to 'Other::Package' + # and imports 'Dumper' function + +A module for loading must be quoted. + +Except specifing the package and quoting module name, +'autoload_remote' is same as 'load_remote'. + +=back =head1 Rules -C<load> has the following rules to decide what it thinks you want: +All functions have the following rules to decide what it thinks +you want: =over 4 @@ -150,6 +281,46 @@ the respective error messages. =back +=head1 IMPORTS THE FUNCTIONS + +'load' and 'autoload' are imported by default, but 'load_remote' and +'autoload_remote' are not imported. + +To use 'load_remote' or 'autoload_remote', specify at 'use'. + +=over 4 + +=item "load","autoload","load_remote","autoload_remote" + +Imports the selected functions. + + # imports 'load' and 'autoload' (default) + use Module::Load; + + # imports 'autoload' only + use Module::Load 'autoload'; + + # imports 'autoload' and 'autoload_remote', but don't import 'load'; + use Module::Load qw/autoload autoload_remote/; + +=item 'all' + +Imports all the functions. + + use Module::Load 'all'; # imports load, autoload, load_remote, autoload_remote + +=item '','none',undef + +Not import any functions (C<load> and C<autoload> are not imported). + + use Module::Load ''; + + use Module::Load 'none'; + + use Module::Load undef; + +=back + =head1 Caveats Because of a bug in perl (#19213), at least in version 5.6.1, we have @@ -180,5 +351,4 @@ This module by Jos Boumans E<lt>kane@cpan.orgE<gt>. This library is free software; you may redistribute and/or modify it under the same terms as Perl itself. - =cut |