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

diff --git a/MANIFEST b/MANIFEST
index 5f2bab1..a0a8578 100644 (file)
--- a/MANIFEST
+++ b/MANIFEST
@@ -1620,6 +1620,7 @@ cpan/Module-Loaded/lib/Module/Loaded.pm   Module::Loaded
 cpan/Module-Loaded/t/01_Module-Loaded.t        Module::Loaded tests
 cpan/Module-Load/lib/Module/Load.pm            Module::Load
 cpan/Module-Load/t/01_Module-Load.t            Module::Load tests
+cpan/Module-Load/t/02_Module-Load.t            Module::Load tests
 cpan/Module-Load/t/to_load/config_file         Module::Load tests
 cpan/Module-Load/t/to_load/LoadIt.pm           Module::Load tests
 cpan/Module-Load/t/to_load/LoadMe.pl           Module::Load tests

diff --git a/Porting/Maintainers.pl b/Porting/Maintainers.pl
index 92e67d8..154aeb4 100755 (executable)
--- a/Porting/Maintainers.pl
+++ b/Porting/Maintainers.pl
@@ -809,7 +809,7 @@ use File::Glob qw(:case);
     },
 
     'Module::Load' => {
-        'DISTRIBUTION' => 'BINGOS/Module-Load-0.24.tar.gz',
+        'DISTRIBUTION' => 'BINGOS/Module-Load-0.28.tar.gz',
         'FILES'        => q[cpan/Module-Load],
     },
 

diff --git a/cpan/Module-Load/lib/Module/Load.pm b/cpan/Module-Load/lib/Module/Load.pm
index 6046484..bc788b5 100644 (file)
--- 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 (file)
index 0000000..0c71557
--- /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();
+