Update Module-Load to CPAN version 0.28

  [DELTA]

0.28    Sat Jan  4 11:07:27 GMT 2014
* Fix 'Prototype after' warnings

0.26    Sat Jan  4 10:08:35 GMT 2014
* New functions added (reisub)
* Documented by magnolia

2 files changed, 537 insertions, 22 deletions

diff --git a/cpan/Module-Load/lib/Module/Load.pm b/cpan/Module-Load/lib/Module/Load.pm
index 6046484744..bc788b5324 100644
--- a/cpan/Module-Load/lib/Module/Load.pm
+++ b/cpan/Module-Load/lib/Module/Load.pm
@@ -1,19 +1,68 @@
 package Module::Load;
 
-$VERSION = '0.24';
+$VERSION = '0.28';
 
 use strict;
 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
+        );
+
+        @$h{@_} = ();
+
+        (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 +83,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 +148,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 +185,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 +280,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 +350,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
diff --git a/cpan/Module-Load/t/02_Module-Load.t b/cpan/Module-Load/t/02_Module-Load.t
new file mode 100644
index 0000000000..0c715577f1
--- /dev/null
+++ b/cpan/Module-Load/t/02_Module-Load.t
@@ -0,0 +1,346 @@
+#!perl
+
+use Test::More;
+use strict;
+
+#
+# Module::Load; test new features:
+#    autoload;
+#    remote_load
+#    autload_remote
+#  and options: '','none',undef,'all','load','autoload','load_remote'
+#
+# License: This library is free software; you may redistribute and/or modify it under the same terms as Perl itself.
+#
+#  Author (jabber/email) : reisub@yandex.ru
+#
+
+my ($afx, $cnt, $r, $tcode) = ('TestXYZ_', 0);
+
+sub _reset{
+    undef %{Data::Dumper::};
+    undef %{XYZ::Module::};
+    eval "undef %{$afx$cnt::}";
+    delete $INC{'Data/Dumper.pm'};
+}
+
+sub _test{
+    $cnt++;
+    $tcode = "package $afx$cnt; my \$WORLD='PEACE';" . join '', @_;
+#    print "tcode:$tcode\n";
+    $r = eval($tcode) || $@;
+}
+
+sub is_peace_in_world{
+    like $r, qr/(WORLD\W+)?PEACE/o, $_[0] || '.';
+    goto &_reset;
+}
+
+sub isnt_peace_in_world{
+    unlike $r, qr/(WORLD\W+)?PEACE/o, $_[0] || '.';
+    goto &_reset;
+}
+
+sub isnt_def_sub{
+    like $r, qr/Undefined\s+subroutine/io, $_[0] || '.';
+    goto &_reset;
+}
+
+sub cant_locate{
+	like $r, qr/Can't\s+locate/io, $_[0] || '.';
+    goto &_reset;
+}
+
+subtest 'load/prevcompat' => sub{
+    _test('use Module::Load;
+	    load("Data::Dumper");
+    	    Data::Dumper->Dump([$WORLD]);');
+    is_peace_in_world('default import');
+
+    _test('use Module::Load "load";
+	    load("Data::Dumper");
+    	    Data::Dumper->Dump([$WORLD]);');
+    is_peace_in_world();
+
+    _test('use Module::Load;
+	    load("Data::Dumper");
+    	    Dumper([$WORLD]);');
+    isnt_def_sub();
+
+    _test('use Module::Load;
+	    load("Data::Dumper","Dumper");
+    	    Data::Dumper->Dump([$WORLD]);');
+    is_peace_in_world();
+
+    _test('use Module::Load;
+	    load("Data::Dumper","Dumper","DumperX");
+    	    Data::Dumper->Dump([$WORLD]);');
+    is_peace_in_world();
+
+	_test('use Module::Load "all";
+	    load("Data::Dumper","Dumper","DumperX");
+    	    DumperX([$WORLD]);');
+    is_peace_in_world();
+
+    _test('use Module::Load "all";
+		load("______");');
+    cant_locate();
+
+    _test('use Module::Load "";
+			load("Data::Dumper");
+    	    Data::Dumper->Dump([$WORLD]);');
+    isnt_def_sub();
+
+	_test('use Module::Load "none";
+			load("Data::Dumper");
+    	    Data::Dumper->Dump([$WORLD]);');
+    isnt_def_sub();
+
+	_test('use Module::Load undef;
+			load("Data::Dumper");
+    	    Data::Dumper->Dump([$WORLD]);');
+    isnt_def_sub();
+
+    done_testing();
+};
+
+subtest 'autoload' => sub{
+    _test('use Module::Load;
+			autoload("Data::Dumper");
+    	    Data::Dumper->Dump([$WORLD]);');
+    is_peace_in_world('default import');
+
+    _test('use Module::Load;
+			Module::Load::autoload("Data::Dumper");
+    	    Data::Dumper->Dump([$WORLD]);');
+    is_peace_in_world();
+
+    _test('use Module::Load;
+			Module::Load::autoload("Data::Dumper");
+    	    Dumper($WORLD);');
+    is_peace_in_world();
+
+    _test('use Module::Load;
+			Module::Load::autoload("Data::Dumper","Dumper");
+    	    Dumper($WORLD);');
+    is_peace_in_world();
+
+    _test('use Module::Load;
+			Module::Load::autoload("Data::Dumper","Dumper","DumperX");
+    	    DumperX($WORLD);');
+    is_peace_in_world();
+
+    _test('use Module::Load "autoload";
+			autoload("Data::Dumper");
+    	    Dumper($WORLD);');
+    is_peace_in_world();
+
+    _test('use Module::Load "all";
+			autoload("Data::Dumper");
+    	    Dumper($WORLD);');
+    is_peace_in_world();
+
+    _test('use Module::Load "all";
+			autoload("Data::Dumper","Dumper","DumperX");
+    	    DumperX($WORLD);');
+    is_peace_in_world();
+
+    _test('use Module::Load "all";
+			autoload("______");');
+    cant_locate();
+
+    _test('use Module::Load "";
+			autoload("Data::Dumper");
+    	    Data::Dumper->Dump([$WORLD]);');
+    isnt_def_sub();
+
+	_test('use Module::Load "none";
+			autoload("Data::Dumper");
+    	    Data::Dumper->Dump([$WORLD]);');
+    isnt_def_sub();
+
+	_test('use Module::Load undef;
+			autoload("Data::Dumper");
+    	    Data::Dumper->Dump([$WORLD]);');
+    isnt_def_sub();
+
+    done_testing();
+};
+
+subtest 'noimport' => sub{
+    for my $asq('"none"', '""', 'undef'){
+		_test('use Module::Load '.$asq.';
+				load("Data::Dumper");
+				Data::Dumper->Dump([$WORLD]);');
+		isnt_def_sub();
+
+		_test('use Module::Load '.$asq.';
+				autoload("Data::Dumper");
+				Data::Dumper->Dump([$WORLD]);');
+		isnt_def_sub();
+
+		_test('use Module::Load '.$asq.';
+				load_remote("XYZ::Module" => "Data::Dumper");
+				Data::Dumper->Dump([$WORLD]);');
+		isnt_def_sub();
+
+		_test('use Module::Load '.$asq.';
+				autoload_remote("XYZ::Module" => "Data::Dumper");
+				Data::Dumper->Dump([$WORLD]);');
+		isnt_def_sub();
+    }
+    done_testing();
+};
+
+subtest 'load_remote' => sub{
+    _test('use Module::Load;
+	    load_remote("XYZ::Module","Data::Dumper");
+    	    Data::Dumper->Dump([$WORLD]);');
+    isnt_def_sub();
+
+    _test('use Module::Load;
+	    load_remote("XYZ::Module","Data::Dumper");
+    	    Dumper([$WORLD]);');
+    isnt_def_sub();
+
+    _test('use Module::Load;
+	    Module::Load::load_remote("XYZ::Module","Data::Dumper");
+	    Data::Dumper->Dump([$WORLD]);');
+    is_peace_in_world();
+
+    _test('use Module::Load;
+	    Module::Load::load_remote("XYZ::Module","Data::Dumper");
+	    XYZ::Module::Dumper($WORLD);');
+    isnt_def_sub();
+
+    _test('use Module::Load;
+	    Module::Load::load_remote("XYZ::Module","Data::Dumper","Dumper");
+	    XYZ::Module::Dumper($WORLD);');
+    is_peace_in_world();
+
+    _test('use Module::Load;
+	    Module::Load::load_remote("XYZ::Module","Data::Dumper","Dumper","DumperX");
+	    XYZ::Module::Dumper($WORLD);');
+    is_peace_in_world();
+
+    _test('use Module::Load "load_remote";
+	    load_remote("XYZ::Module","Data::Dumper","Dumper","DumperX");
+	    XYZ::Module::Dumper($WORLD);');
+    is_peace_in_world();
+
+    _test('use Module::Load "all";
+	    load_remote("XYZ::Module","Data::Dumper","Dumper","DumperX");
+	    XYZ::Module::Dumper($WORLD);');
+    is_peace_in_world();
+
+	_test('use Module::Load "all";
+	    load_remote("XYZ::Module","______","Data::Dumper");
+	    XYZ::Module::Dumper($WORLD);');
+    cant_locate();
+};
+
+subtest 'autoload_remote' => sub{
+    _test('use Module::Load;
+	    autoload_remote("XYZ::Module","Data::Dumper");
+	    Data::Dumper->Dump([$WORLD]);');
+    isnt_def_sub();
+
+    _test('use Module::Load;
+	    autoload_remote("XYZ::Module","Data::Dumper");
+	    Dumper([$WORLD]);');
+    isnt_def_sub();
+
+    _test('use Module::Load;
+	    Module::Load::autoload_remote("XYZ::Module","Data::Dumper");
+	    Data::Dumper->Dump([$WORLD]);');
+    is_peace_in_world();
+
+    _test('use Module::Load;
+	    Module::Load::autoload_remote("XYZ::Module","Data::Dumper");
+	    XYZ::Module::Dumper($WORLD);');
+    is_peace_in_world();
+
+    _test('use Module::Load;
+	    Module::Load::autoload_remote("XYZ::Module","Data::Dumper","Dumper","DumperX");
+	    XYZ::Module::DumperX($WORLD);');
+    is_peace_in_world();
+
+    _test('use Module::Load "autoload_remote";
+	    autoload_remote("XYZ::Module","Data::Dumper","Dumper","DumperX");
+	    XYZ::Module::Dumper($WORLD);');
+    is_peace_in_world();
+
+    _test('use Module::Load "all";
+	    autoload_remote("XYZ::Module","______","Data::Dumper");
+	    XYZ::Module::Dumper($WORLD);');
+    cant_locate();
+
+	done_testing();
+};
+
+subtest 'complex' => sub{
+	_test('use Module::Load "load","autoload","none";
+			load("Data::Dumper");
+	    Data::Dumper->Dump([$WORLD]);');
+    isnt_def_sub();
+
+	_test('use Module::Load "load","autoload","none";
+			autoload("Data::Dumper");
+	    Data::Dumper->Dump([$WORLD]);');
+    isnt_def_sub();
+
+	_test('use Module::Load "load","autoload","none";
+			load_remote("Data::Dumper");
+	    Data::Dumper->Dump([$WORLD]);');
+    isnt_def_sub();
+
+	_test('use Module::Load "load","autoload","none";
+			autoload_remote("Data::Dumper");
+	    Data::Dumper->Dump([$WORLD]);');
+    isnt_def_sub();
+
+
+	_test('use Module::Load "load","autoload";
+			load("Data::Dumper", "Dumper");
+			autoload("Carp");
+	    croak( Dumper([$WORLD]) );');
+    is_peace_in_world();
+
+	_test('use Module::Load "load","autoload";
+			load_remote("Data::Dumper");');
+    isnt_def_sub();
+
+	_test('use Module::Load "load","autoload";
+			autoload_remote("Data::Dumper");');
+    isnt_def_sub();
+
+	_test('use Module::Load "load","autoload","none";
+			autoload_remote("Data::Dumper");
+	    Data::Dumper->Dump([$WORLD]);');
+    isnt_def_sub();
+
+	_test('use Module::Load "load","autoload","load_remote","autoload_remote";
+			load("Carp");
+			autoload("Data::Dumper");
+			load_remote("XYZ::Module", "Carp");
+			autoload_remote("XYZ::Module", "Carp");
+	    Dumper([$WORLD]);');
+    is_peace_in_world();
+
+	_test('use Module::Load "all";
+			load("Carp");
+			autoload("Data::Dumper");
+			load_remote("XYZ::Module" => "Carp");
+			autoload_remote("XYZ::Module" => "Carp");
+	    Dumper([$WORLD]);');
+    is_peace_in_world();
+
+	_test('use Module::Load "all","";
+			load("Carp");');
+    isnt_def_sub();
+
+    done_testing();
+};
+
+done_testing();
+