summaryrefslogtreecommitdiff
path: root/Master/tlpkg/tlperl/lib/Module
diff options
context:
space:
mode:
authorKarl Berry <karl@freefriends.org>2015-04-26 22:16:26 +0000
committerKarl Berry <karl@freefriends.org>2015-04-26 22:16:26 +0000
commit342e672574c4e67d510e46ab6acd0e21a7d0cf54 (patch)
tree79e04202d08c0404bbd780bd26c1e34710e539b6 /Master/tlpkg/tlperl/lib/Module
parentbe2706af7c57a0ef0f4d4e9f684ca4ef74922a82 (diff)
(tl)perl 5.20.2 for windows, from siep
git-svn-id: svn://tug.org/texlive/trunk@37064 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Master/tlpkg/tlperl/lib/Module')
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build.pm18
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/API.pod2124
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Authoring.pod326
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Base.pm565
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Bundling.pod147
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Compat.pm7
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Config.pm2
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/ConfigData.pm64
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Cookbook.pm2
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Dumper.pm2
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/ModuleInfo.pm2
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Notes.pm20
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/PPMMaker.pm10
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Platform/Amiga.pm34
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Platform/Default.pm2
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Platform/EBCDIC.pm34
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Platform/MPEiX.pm34
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Platform/MacOS.pm2
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Platform/RiscOS.pm34
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Platform/Unix.pm6
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Platform/VMS.pm47
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Platform/VOS.pm2
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Platform/Windows.pm13
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Platform/aix.pm2
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Platform/cygwin.pm2
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Platform/darwin.pm2
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/Platform/os2.pm2
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Build/PodParser.pm6
-rw-r--r--Master/tlpkg/tlperl/lib/Module/CoreList.pm2053
-rw-r--r--Master/tlpkg/tlperl/lib/Module/CoreList.pod251
-rw-r--r--Master/tlpkg/tlperl/lib/Module/CoreList/TieHashDelta.pm6
-rwxr-xr-xMaster/tlpkg/tlperl/lib/Module/CoreList/Utils.pm133
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Load.pm214
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Load/Conditional.pm35
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Metadata.pm125
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Pluggable.pm457
-rw-r--r--Master/tlpkg/tlperl/lib/Module/Pluggable/Object.pm405
37 files changed, 5685 insertions, 1505 deletions
diff --git a/Master/tlpkg/tlperl/lib/Module/Build.pm b/Master/tlpkg/tlperl/lib/Module/Build.pm
index fd835fc0659..aee7b44c1f5 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build.pm
@@ -1,5 +1,7 @@
package Module::Build;
+use if $] >= 5.019, 'deprecate';
+
# This module doesn't do much of anything itself, it inherits from the
# modules that do the real work. The only real thing it has to do is
# figure out which OS-specific module to pull in. Many of the
@@ -16,10 +18,9 @@ use Module::Build::Base;
use vars qw($VERSION @ISA);
@ISA = qw(Module::Build::Base);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
-
# Inserts the given module into the @ISA hierarchy between
# Module::Build and its immediate parent
sub _interpose_module {
@@ -94,10 +95,7 @@ C<ExtUtils::MakeMaker>. Developers may alter the behavior of the
module through subclassing in a much more straightforward way than
with C<MakeMaker>. It also does not require a C<make> on your system
- most of the C<Module::Build> code is pure-perl and written in a very
-cross-platform way. In fact, you don't even need a shell, so even
-platforms like MacOS (traditional) can use it fairly easily. Its only
-prerequisites are modules that are included with perl 5.6.0, and it
-works fine on perl 5.005 if you can install a few additional modules.
+cross-platform way.
See L<"MOTIVATIONS"> for more comparisons between C<ExtUtils::MakeMaker>
and C<Module::Build>.
@@ -379,6 +377,12 @@ C<Config.pm>. You can also supply or override install paths on the
command line by specifying C<install_path> values for the C<binhtml>
and/or C<libhtml> installation targets.
+With an optional C<html_links> argument set to a false value, you can
+skip the search for other documentation to link to, because that can
+waste a lot of time if there aren't any links to generate anyway:
+
+ ./Build html --html_links 0
+
=item install
[version 0.01]
@@ -747,7 +751,7 @@ executed build actions.
When Module::Build starts up, it will look first for a file,
F<$ENV{HOME}/.modulebuildrc>. If it's not found there, it will look
-in the the F<.modulebuildrc> file in the directories referred to by
+in the F<.modulebuildrc> file in the directories referred to by
the environment variables C<HOMEDRIVE> + C<HOMEDIR>, C<USERPROFILE>,
C<APPDATA>, C<WINDIR>, C<SYS$LOGIN>. If the file exists, the options
specified there will be used as defaults, as if they were typed on the
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/API.pod b/Master/tlpkg/tlperl/lib/Module/Build/API.pod
new file mode 100644
index 00000000000..af859e7fe40
--- /dev/null
+++ b/Master/tlpkg/tlperl/lib/Module/Build/API.pod
@@ -0,0 +1,2124 @@
+=head1 NAME
+
+Module::Build::API - API Reference for Module Authors
+
+=for :stopwords apache bsd distdir distsign gpl installdirs lgpl mit mozilla packlists
+
+=head1 DESCRIPTION
+
+I list here some of the most important methods in C<Module::Build>.
+Normally you won't need to deal with these methods unless you want to
+subclass C<Module::Build>. But since one of the reasons I created
+this module in the first place was so that subclassing is possible
+(and easy), I will certainly write more docs as the interface
+stabilizes.
+
+
+=head2 CONSTRUCTORS
+
+=over 4
+
+=item current()
+
+[version 0.20]
+
+This method returns a reasonable facsimile of the currently-executing
+C<Module::Build> object representing the current build. You can use
+this object to query its L</notes()> method, inquire about installed
+modules, and so on. This is a great way to share information between
+different parts of your build process. For instance, you can ask
+the user a question during C<perl Build.PL>, then use their answer
+during a regression test:
+
+ # In Build.PL:
+ my $color = $build->prompt("What is your favorite color?");
+ $build->notes(color => $color);
+
+ # In t/colortest.t:
+ use Module::Build;
+ my $build = Module::Build->current;
+ my $color = $build->notes('color');
+ ...
+
+The way the C<current()> method is currently implemented, there may be
+slight differences between the C<$build> object in Build.PL and the
+one in C<t/colortest.t>. It is our goal to minimize these differences
+in future releases of Module::Build, so please report any anomalies
+you find.
+
+One important caveat: in its current implementation, C<current()> will
+B<NOT> work correctly if you have changed out of the directory that
+C<Module::Build> was invoked from.
+
+=item new()
+
+[version 0.03]
+
+Creates a new Module::Build object. Arguments to the new() method are
+listed below. Most arguments are optional, but you must provide
+either the L</module_name> argument, or L</dist_name> and one of
+L</dist_version> or L</dist_version_from>. In other words, you must
+provide enough information to determine both a distribution name and
+version.
+
+
+=over 4
+
+=item add_to_cleanup
+
+[version 0.19]
+
+An array reference of files to be cleaned up when the C<clean> action
+is performed. See also the L<add_to_cleanup()|/"add_to_cleanup(@files)">
+method.
+
+=item allow_pureperl
+
+[version 0.4005]
+
+A bool indicating the module is still functional without its xs parts.
+When an XS module is build with --pureperl_only, it will otherwise fail.
+
+=item auto_configure_requires
+
+[version 0.34]
+
+This parameter determines whether Module::Build will add itself
+automatically to configure_requires (and build_requires) if Module::Build
+is not already there. The required version will be the last 'major' release,
+as defined by the decimal version truncated to two decimal places (e.g. 0.34,
+instead of 0.3402). The default value is true.
+
+=item auto_features
+
+[version 0.26]
+
+This parameter supports the setting of features (see
+L</feature($name)>) automatically based on a set of prerequisites. For
+instance, for a module that could optionally use either MySQL or
+PostgreSQL databases, you might use C<auto_features> like this:
+
+ my $build = Module::Build->new
+ (
+ ...other stuff here...
+ auto_features => {
+ pg_support => {
+ description => "Interface with Postgres databases",
+ requires => { 'DBD::Pg' => 23.3,
+ 'DateTime::Format::Pg' => 0 },
+ },
+ mysql_support => {
+ description => "Interface with MySQL databases",
+ requires => { 'DBD::mysql' => 17.9,
+ 'DateTime::Format::MySQL' => 0 },
+ },
+ }
+ );
+
+For each feature named, the required prerequisites will be checked, and
+if there are no failures, the feature will be enabled (set to C<1>).
+Otherwise the failures will be displayed to the user and the feature
+will be disabled (set to C<0>).
+
+See the documentation for L</requires> for the details of how
+requirements can be specified.
+
+=item autosplit
+
+[version 0.04]
+
+An optional C<autosplit> argument specifies a file which should be run
+through the L<AutoSplit::autosplit()|AutoSplit/autosplit> function.
+If multiple files should be split, the argument may be given as an
+array of the files to split.
+
+In general I don't consider autosplitting a great idea, because it's
+not always clear that autosplitting achieves its intended performance
+benefits. It may even harm performance in environments like mod_perl,
+where as much as possible of a module's code should be loaded during
+startup.
+
+=item build_class
+
+[version 0.28]
+
+The Module::Build class or subclass to use in the build script.
+Defaults to "Module::Build" or the class name passed to or created by
+a call to L</subclass()>. This property is useful if you're
+writing a custom Module::Build subclass and have a bootstrapping
+problem--that is, your subclass requires modules that may not be
+installed when C<perl Build.PL> is executed, but you've listed in
+L</build_requires> so that they should be available when C<./Build> is
+executed.
+
+=item build_requires
+
+[version 0.07]
+
+Modules listed in this section are necessary to build and install the
+given module, but are not necessary for regular usage of it. This is
+actually an important distinction - it allows for tighter control over
+the body of installed modules, and facilitates correct dependency
+checking on binary/packaged distributions of the module.
+
+See the documentation for L<Module::Build::Authoring/"PREREQUISITES">
+for the details of how requirements can be specified.
+
+=item configure_requires
+
+[version 0.30]
+
+Modules listed in this section must be installed I<before> configuring
+this distribution (i.e. before running the F<Build.PL> script).
+This might be a specific minimum version of C<Module::Build> or any
+other module the F<Build.PL> needs in order to do its stuff. Clients
+like C<CPAN.pm> or C<CPANPLUS> will be expected to pick
+C<configure_requires> out of the F<META.yml> file and install these
+items before running the C<Build.PL>.
+
+Module::Build may automatically add itself to configure_requires.
+See L</auto_configure_requires> for details.
+
+See the documentation for L<Module::Build::Authoring/"PREREQUISITES">
+for the details of how requirements can be specified.
+
+=item test_requires
+
+[version 0.4004]
+
+Modules listed in this section must be installed before testing the distribution.
+
+See the documentation for L<Module::Build::Authoring/"PREREQUISITES">
+for the details of how requirements can be specified.
+
+=item create_packlist
+
+[version 0.28]
+
+If true, this parameter tells Module::Build to create a F<.packlist>
+file during the C<install> action, just like C<ExtUtils::MakeMaker> does.
+The file is created in a subdirectory of the C<arch> installation
+location. It is used by some other tools (CPAN, CPANPLUS, etc.) for
+determining what files are part of an install.
+
+The default value is true. This parameter was introduced in
+Module::Build version 0.2609; previously no packlists were ever
+created by Module::Build.
+
+=item c_source
+
+[version 0.04]
+
+An optional C<c_source> argument specifies a directory which contains
+C source files that the rest of the build may depend on. Any C<.c>
+files in the directory will be compiled to object files. The
+directory will be added to the search path during the compilation and
+linking phases of any C or XS files.
+
+[version 0.3604]
+
+A list of directories can be supplied using an anonymous array
+reference of strings.
+
+=item conflicts
+
+[version 0.07]
+
+Modules listed in this section conflict in some serious way with the
+given module. C<Module::Build> (or some higher-level tool) will
+refuse to install the given module if the given module/version is also
+installed.
+
+See the documentation for L<Module::Build::Authoring/"PREREQUISITES">
+for the details of how requirements can be specified.
+
+=item create_license
+
+[version 0.31]
+
+This parameter tells Module::Build to automatically create a
+F<LICENSE> file at the top level of your distribution, containing the
+full text of the author's chosen license. This requires
+C<Software::License> on the author's machine, and further requires
+that the C<license> parameter specifies a license that it knows about.
+
+=item create_makefile_pl
+
+[version 0.19]
+
+This parameter lets you use C<Module::Build::Compat> during the
+C<distdir> (or C<dist>) action to automatically create a Makefile.PL
+for compatibility with C<ExtUtils::MakeMaker>. The parameter's value
+should be one of the styles named in the L<Module::Build::Compat>
+documentation.
+
+=item create_readme
+
+[version 0.22]
+
+This parameter tells Module::Build to automatically create a F<README>
+file at the top level of your distribution. Currently it will simply
+use C<Pod::Text> (or C<Pod::Readme> if it's installed) on the file
+indicated by C<dist_version_from> and put the result in the F<README>
+file. This is by no means the only recommended style for writing a
+F<README>, but it seems to be one common one used on the CPAN.
+
+If you generate a F<README> in this way, it's probably a good idea to
+create a separate F<INSTALL> file if that information isn't in the
+generated F<README>.
+
+=item dist_abstract
+
+[version 0.20]
+
+This should be a short description of the distribution. This is used when
+generating metadata for F<META.yml> and PPD files. If it is not given
+then C<Module::Build> looks in the POD of the module from which it gets
+the distribution's version. If it finds a POD section marked "=head1
+NAME", then it looks for the first line matching C<\s+-\s+(.+)>,
+and uses the captured text as the abstract.
+
+=item dist_author
+
+[version 0.20]
+
+This should be something like "John Doe <jdoe@example.com>", or if
+there are multiple authors, an anonymous array of strings may be
+specified. This is used when generating metadata for F<META.yml> and
+PPD files. If this is not specified, then C<Module::Build> looks at
+the module from which it gets the distribution's version. If it finds
+a POD section marked "=head1 AUTHOR", then it uses the contents of
+this section.
+
+=item dist_name
+
+[version 0.11]
+
+Specifies the name for this distribution. Most authors won't need to
+set this directly, they can use C<module_name> to set C<dist_name> to
+a reasonable default. However, some agglomerative distributions like
+C<libwww-perl> or C<bioperl> have names that don't correspond directly
+to a module name, so C<dist_name> can be set independently.
+
+=item dist_suffix
+
+[version 0.37]
+
+Specifies an optional suffix to include after the version number
+in the distribution directory (and tarball) name. The only suffix
+currently recognized by PAUSE is 'TRIAL', which indicates that the
+distribution should not be indexed. For example:
+
+ Foo-Bar-1.23-TRIAL.tar.gz
+
+This will automatically do the "right thing" depending on C<dist_version> and
+C<release_status>. When C<dist_version> does not have an underscore and
+C<release_status> is not 'stable', then C<dist_suffix> will default to 'TRIAL'.
+Otherwise it will default to the empty string, disabling the suffix.
+
+In general, authors should only set this if they B<must> override the default
+behavior for some particular purpose.
+
+=item dist_version
+
+[version 0.11]
+
+Specifies a version number for the distribution. See L</module_name>
+or L</dist_version_from> for ways to have this set automatically from a
+C<$VERSION> variable in a module. One way or another, a version
+number needs to be set.
+
+=item dist_version_from
+
+[version 0.11]
+
+Specifies a file to look for the distribution version in. Most
+authors won't need to set this directly, they can use L</module_name>
+to set it to a reasonable default.
+
+The version is extracted from the specified file according to the same
+rules as L<ExtUtils::MakeMaker> and C<CPAN.pm>. It involves finding
+the first line that matches the regular expression
+
+ /([\$*])(([\w\:\']*)\bVERSION)\b.*\=/
+
+eval()-ing that line, then checking the value of the C<$VERSION>
+variable. Quite ugly, really, but all the modules on CPAN depend on
+this process, so there's no real opportunity to change to something
+better.
+
+If the target file of L</dist_version_from> contains more than one package
+declaration, the version returned will be the one matching the configured
+L</module_name>.
+
+=item dynamic_config
+
+[version 0.07]
+
+A boolean flag indicating whether the F<Build.PL> file must be
+executed, or whether this module can be built, tested and installed
+solely from consulting its metadata file. The main reason to set this
+to a true value is that your module performs some dynamic
+configuration as part of its build/install process. If the flag is
+omitted, the F<META.yml> spec says that installation tools should
+treat it as 1 (true), because this is a safer way to behave.
+
+Currently C<Module::Build> doesn't actually do anything with this flag
+- it's up to higher-level tools like C<CPAN.pm> to do something useful
+with it. It can potentially bring lots of security, packaging, and
+convenience improvements.
+
+=item extra_compiler_flags
+
+=item extra_linker_flags
+
+[version 0.19]
+
+These parameters can contain array references (or strings, in which
+case they will be split into arrays) to pass through to the compiler
+and linker phases when compiling/linking C code. For example, to tell
+the compiler that your code is C++, you might do:
+
+ my $build = Module::Build->new
+ (
+ module_name => 'Foo::Bar',
+ extra_compiler_flags => ['-x', 'c++'],
+ );
+
+To link your XS code against glib you might write something like:
+
+ my $build = Module::Build->new
+ (
+ module_name => 'Foo::Bar',
+ dynamic_config => 1,
+ extra_compiler_flags => scalar `glib-config --cflags`,
+ extra_linker_flags => scalar `glib-config --libs`,
+ );
+
+=item extra_manify_args
+
+[version 0.4006]
+
+Any extra arguments to pass to C<< Pod::Man->new() >> when building
+man pages. One common choice might be C<< utf8 => 1 >> to get Unicode
+support.
+
+=item get_options
+
+[version 0.26]
+
+You can pass arbitrary command line options to F<Build.PL> or
+F<Build>, and they will be stored in the Module::Build object and can
+be accessed via the L</args()> method. However, sometimes you want
+more flexibility out of your argument processing than this allows. In
+such cases, use the C<get_options> parameter to pass in a hash
+reference of argument specifications, and the list of arguments to
+F<Build.PL> or F<Build> will be processed according to those
+specifications before they're passed on to C<Module::Build>'s own
+argument processing.
+
+The supported option specification hash keys are:
+
+
+=over 4
+
+=item type
+
+The type of option. The types are those supported by Getopt::Long; consult
+its documentation for a complete list. Typical types are C<=s> for strings,
+C<+> for additive options, and C<!> for negatable options. If the
+type is not specified, it will be considered a boolean, i.e. no
+argument is taken and a value of 1 will be assigned when the option is
+encountered.
+
+=item store
+
+A reference to a scalar in which to store the value passed to the option.
+If not specified, the value will be stored under the option name in the
+hash returned by the C<args()> method.
+
+=item default
+
+A default value for the option. If no default value is specified and no option
+is passed, then the option key will not exist in the hash returned by
+C<args()>.
+
+=back
+
+
+You can combine references to your own variables or subroutines with
+unreferenced specifications, for which the result will also be stored in the
+hash returned by C<args()>. For example:
+
+ my $loud = 0;
+ my $build = Module::Build->new
+ (
+ module_name => 'Foo::Bar',
+ get_options => {
+ Loud => { store => \$loud },
+ Dbd => { type => '=s' },
+ Quantity => { type => '+' },
+ }
+ );
+
+ print STDERR "HEY, ARE YOU LISTENING??\n" if $loud;
+ print "We'll use the ", $build->args('Dbd'), " DBI driver\n";
+ print "Are you sure you want that many?\n"
+ if $build->args('Quantity') > 2;
+
+The arguments for such a specification can be called like so:
+
+ perl Build.PL --Loud --Dbd=DBD::pg --Quantity --Quantity --Quantity
+
+B<WARNING:> Any option specifications that conflict with Module::Build's own
+options (defined by its properties) will throw an exception. Use capitalized
+option names to avoid unintended conflicts with future Module::Build options.
+
+Consult the Getopt::Long documentation for details on its usage.
+
+=item include_dirs
+
+[version 0.24]
+
+Specifies any additional directories in which to search for C header
+files. May be given as a string indicating a single directory, or as
+a list reference indicating multiple directories.
+
+=item install_path
+
+[version 0.19]
+
+You can set paths for individual installable elements by using the
+C<install_path> parameter:
+
+ my $build = Module::Build->new
+ (
+ ...other stuff here...
+ install_path => {
+ lib => '/foo/lib',
+ arch => '/foo/lib/arch',
+ }
+ );
+
+=item installdirs
+
+[version 0.19]
+
+Determines where files are installed within the normal perl hierarchy
+as determined by F<Config.pm>. Valid values are: C<core>, C<site>,
+C<vendor>. The default is C<site>. See
+L<Module::Build/"INSTALL PATHS">
+
+=item license
+
+[version 0.07]
+
+Specifies the licensing terms of your distribution.
+
+As of Module::Build version 0.36_14, you may use a L<Software::License>
+subclass name (e.g. 'Apache_2_0') instead of one of the keys below.
+
+The legacy list of valid license values include:
+
+=over 4
+
+=item apache
+
+The distribution is licensed under the Apache License, Version 2.0
+(L<http://apache.org/licenses/LICENSE-2.0>).
+
+=item apache_1_1
+
+The distribution is licensed under the Apache Software License, Version 1.1
+(L<http://apache.org/licenses/LICENSE-1.1>).
+
+=item artistic
+
+The distribution is licensed under the Artistic License, as specified
+by the F<Artistic> file in the standard Perl distribution.
+
+=item artistic_2
+
+The distribution is licensed under the Artistic 2.0 License
+(L<http://opensource.org/licenses/artistic-license-2.0.php>.)
+
+=item bsd
+
+The distribution is licensed under the BSD License
+(L<http://www.opensource.org/licenses/bsd-license.php>).
+
+=item gpl
+
+The distribution is licensed under the terms of the GNU General
+Public License (L<http://www.opensource.org/licenses/gpl-license.php>).
+
+=item lgpl
+
+The distribution is licensed under the terms of the GNU Lesser
+General Public License
+(L<http://www.opensource.org/licenses/lgpl-license.php>).
+
+=item mit
+
+The distribution is licensed under the MIT License
+(L<http://opensource.org/licenses/mit-license.php>).
+
+=item mozilla
+
+The distribution is licensed under the Mozilla Public
+License. (L<http://opensource.org/licenses/mozilla1.0.php> or
+L<http://opensource.org/licenses/mozilla1.1.php>)
+
+=item open_source
+
+The distribution is licensed under some other Open Source
+Initiative-approved license listed at
+L<http://www.opensource.org/licenses/>.
+
+=item perl
+
+The distribution may be copied and redistributed under the same terms
+as Perl itself (this is by far the most common licensing option for
+modules on CPAN). This is a dual license, in which the user may
+choose between either the GPL or the Artistic license.
+
+=item restrictive
+
+The distribution may not be redistributed without special permission
+from the author and/or copyright holder.
+
+=item unrestricted
+
+The distribution is licensed under a license that is B<not> approved
+by www.opensource.org but that allows distribution without
+restrictions.
+
+=back
+
+Note that you must still include the terms of your license in your
+code and documentation - this field only sets the information that is included
+in distribution metadata to let automated tools figure out your
+licensing restrictions. Humans still need something to read. If you
+choose to provide this field, you should make sure that you keep it in
+sync with your written documentation if you ever change your licensing
+terms.
+
+You may also use a license type of C<unknown> if you don't wish to
+specify your terms in the metadata.
+
+Also see the C<create_license> parameter.
+
+=item meta_add
+
+[version 0.28]
+
+A hash of key/value pairs that should be added to the F<META.yml> file
+during the C<distmeta> action. Any existing entries with the same
+names will be overridden.
+
+See the L</"MODULE METADATA"> section for details.
+
+=item meta_merge
+
+[version 0.28]
+
+A hash of key/value pairs that should be merged into the F<META.yml>
+file during the C<distmeta> action. Any existing entries with the
+same names will be overridden.
+
+The only difference between C<meta_add> and C<meta_merge> is their
+behavior on hash-valued and array-valued entries: C<meta_add> will
+completely blow away the existing hash or array value, but
+C<meta_merge> will merge the supplied data into the existing hash or
+array value.
+
+See the L</"MODULE METADATA"> section for details.
+
+=item module_name
+
+[version 0.03]
+
+The C<module_name> is a shortcut for setting default values of
+C<dist_name> and C<dist_version_from>, reflecting the fact that the
+majority of CPAN distributions are centered around one "main" module.
+For instance, if you set C<module_name> to C<Foo::Bar>, then
+C<dist_name> will default to C<Foo-Bar> and C<dist_version_from> will
+default to C<lib/Foo/Bar.pm>. C<dist_version_from> will in turn be
+used to set C<dist_version>.
+
+Setting C<module_name> won't override a C<dist_*> parameter you
+specify explicitly.
+
+=item needs_compiler
+
+[version 0.36]
+
+The C<needs_compiler> parameter indicates whether a compiler is required to
+build the distribution. The default is false, unless XS files are found or
+the C<c_source> parameter is set, in which case it is true. If true,
+L<ExtUtils::CBuilder> is automatically added to C<build_requires> if needed.
+
+For a distribution where a compiler is I<optional>, e.g. a dual XS/pure-Perl
+distribution, C<needs_compiler> should explicitly be set to a false value.
+
+=item PL_files
+
+[version 0.06]
+
+An optional parameter specifying a set of C<.PL> files in your
+distribution. These will be run as Perl scripts prior to processing
+the rest of the files in your distribution with the name of the file
+they're generating as an argument. They are usually used as templates
+for creating other files dynamically, so that a file like
+C<lib/Foo/Bar.pm.PL> might create the file C<lib/Foo/Bar.pm>.
+
+The files are specified with the C<.PL> files as hash keys, and the
+file(s) they generate as hash values, like so:
+
+ my $build = Module::Build->new
+ (
+ module_name => 'Foo::Bar',
+ ...
+ PL_files => { 'lib/Foo/Bar.pm.PL' => 'lib/Foo/Bar.pm' },
+ );
+
+Note that the path specifications are I<always> given in Unix-like
+format, not in the style of the local system.
+
+If your C<.PL> scripts don't create any files, or if they create files
+with unexpected names, or even if they create multiple files, you can
+indicate that so that Module::Build can properly handle these created
+files:
+
+ PL_files => {
+ 'lib/Foo/Bar.pm.PL' => 'lib/Foo/Bar.pm',
+ 'lib/something.PL' => ['/lib/something', '/lib/else'],
+ 'lib/funny.PL' => [],
+ }
+
+Here's an example of a simple PL file.
+
+ my $output_file = shift;
+ open my $fh, ">", $output_file or die "Can't open $output_file: $!";
+
+ print $fh <<'END';
+ #!/usr/bin/perl
+
+ print "Hello, world!\n";
+ END
+
+PL files are not installed by default, so its safe to put them in
+F<lib/> and F<bin/>.
+
+
+=item pm_files
+
+[version 0.19]
+
+An optional parameter specifying the set of C<.pm> files in this
+distribution, specified as a hash reference whose keys are the files'
+locations in the distributions, and whose values are their logical
+locations based on their package name, i.e. where they would be found
+in a "normal" Module::Build-style distribution. This parameter is
+mainly intended to support alternative layouts of files.
+
+For instance, if you have an old-style C<MakeMaker> distribution for a
+module called C<Foo::Bar> and a F<Bar.pm> file at the top level of the
+distribution, you could specify your layout in your C<Build.PL> like
+this:
+
+ my $build = Module::Build->new
+ (
+ module_name => 'Foo::Bar',
+ ...
+ pm_files => { 'Bar.pm' => 'lib/Foo/Bar.pm' },
+ );
+
+Note that the values should include C<lib/>, because this is where
+they would be found in a "normal" Module::Build-style distribution.
+
+Note also that the path specifications are I<always> given in
+Unix-like format, not in the style of the local system.
+
+=item pod_files
+
+[version 0.19]
+
+Just like C<pm_files>, but used for specifying the set of C<.pod>
+files in your distribution.
+
+=item recommends
+
+[version 0.08]
+
+This is just like the L</requires> argument, except that modules listed
+in this section aren't essential, just a good idea. We'll just print
+a friendly warning if one of these modules aren't found, but we'll
+continue running.
+
+If a module is recommended but not required, all tests should still
+pass if the module isn't installed. This may mean that some tests
+may be skipped if recommended dependencies aren't present.
+
+Automated tools like CPAN.pm should inform the user when recommended
+modules aren't installed, and it should offer to install them if it
+wants to be helpful.
+
+See the documentation for L<Module::Build::Authoring/"PREREQUISITES">
+for the details of how requirements can be specified.
+
+=item recursive_test_files
+
+[version 0.28]
+
+Normally, C<Module::Build> does not search subdirectories when looking
+for tests to run. When this options is set it will search recursively
+in all subdirectories of the standard 't' test directory.
+
+=item release_status
+
+[version 0.37]
+
+The CPAN Meta Spec version 2 adds C<release_status> to allow authors
+to specify how a distribution should be indexed. Consistent with the
+spec, this parameter can only have one three values: 'stable',
+'testing' or 'unstable'.
+
+Unless explicitly set by the author, C<release_status> will default
+to 'stable' unless C<dist_version> contains an underscore, in which
+case it will default to 'testing'.
+
+It is an error to specify a C<release_status> of 'stable' when
+C<dist_version> contains an underscore character.
+
+=item requires
+
+[version 0.07]
+
+An optional C<requires> argument specifies any module prerequisites
+that the current module depends on.
+
+One note: currently C<Module::Build> doesn't actually I<require> the
+user to have dependencies installed, it just strongly urges. In the
+future we may require it. There's also a L</recommends> section for
+things that aren't absolutely required.
+
+Automated tools like CPAN.pm should refuse to install a module if one
+of its dependencies isn't satisfied, unless a "force" command is given
+by the user. If the tools are helpful, they should also offer to
+install the dependencies.
+
+A synonym for C<requires> is C<prereq>, to help succour people
+transitioning from C<ExtUtils::MakeMaker>. The C<requires> term is
+preferred, but the C<prereq> term will remain valid in future
+distributions.
+
+See the documentation for L<Module::Build::Authoring/"PREREQUISITES">
+for the details of how requirements can be specified.
+
+=item script_files
+
+[version 0.18]
+
+An optional parameter specifying a set of files that should be
+installed as executable Perl scripts when the module is installed.
+May be given as an array reference of the files, as a hash reference
+whose keys are the files (and whose values will currently be ignored),
+as a string giving the name of a directory in which to find scripts,
+or as a string giving the name of a single script file.
+
+The default is to install any scripts found in a F<bin> directory at
+the top level of the distribution, minus any keys of L<PL_files>.
+
+For backward compatibility, you may use the parameter C<scripts>
+instead of C<script_files>. Please consider this usage deprecated,
+though it will continue to exist for several version releases.
+
+=item share_dir
+
+[version 0.36]
+
+An optional parameter specifying directories of static data files to
+be installed as read-only files for use with L<File::ShareDir>. The
+C<share_dir> property supports both distribution-level and
+module-level share files.
+
+The simplest use of C<share_dir> is to set it to a directory name or an
+arrayref of directory names containing files to be installed in the
+distribution-level share directory.
+
+ share_dir => 'share'
+
+Alternatively, if C<share_dir> is a hashref, it may have C<dist> or
+C<module> keys providing full flexibility in defining how share
+directories should be installed.
+
+ share_dir => {
+ dist => [ 'examples', 'more_examples' ],
+ module => {
+ Foo::Templates => ['share/html', 'share/text'],
+ Foo::Config => 'share/config',
+ }
+ }
+
+If C<share_dir> is set, then File::ShareDir will automatically be added
+to the C<requires> hash.
+
+=item sign
+
+[version 0.16]
+
+If a true value is specified for this parameter, L<Module::Signature>
+will be used (via the 'distsign' action) to create a SIGNATURE file
+for your distribution during the 'distdir' action, and to add the
+SIGNATURE file to the MANIFEST (therefore, don't add it yourself).
+
+The default value is false. In the future, the default may change to
+true if you have C<Module::Signature> installed on your system.
+
+=item tap_harness_args
+
+[version 0.2808_03]
+
+An optional parameter specifying parameters to be passed to TAP::Harness when
+running tests. Must be given as a hash reference of parameters; see the
+L<TAP::Harness|TAP::Harness> documentation for details. Note that specifying
+this parameter will implicitly set C<use_tap_harness> to a true value. You
+must therefore be sure to add TAP::Harness as a requirement for your module in
+L</build_requires>.
+
+=item test_files
+
+[version 0.23]
+
+An optional parameter specifying a set of files that should be used as
+C<Test::Harness>-style regression tests to be run during the C<test>
+action. May be given as an array reference of the files, or as a hash
+reference whose keys are the files (and whose values will currently be
+ignored). If the argument is given as a single string (not in an
+array reference), that string will be treated as a C<glob()> pattern
+specifying the files to use.
+
+The default is to look for a F<test.pl> script in the top-level
+directory of the distribution, and any files matching the glob pattern
+C<*.t> in the F<t/> subdirectory. If the C<recursive_test_files>
+property is true, then the C<t/> directory will be scanned recursively
+for C<*.t> files.
+
+=item use_tap_harness
+
+[version 0.2808_03]
+
+An optional parameter indicating whether or not to use TAP::Harness for
+testing rather than Test::Harness. Defaults to false. If set to true, you must
+therefore be sure to add TAP::Harness as a requirement for your module in
+L</build_requires>. Implicitly set to a true value if C<tap_harness_args> is
+specified.
+
+=item xs_files
+
+[version 0.19]
+
+Just like C<pm_files>, but used for specifying the set of C<.xs>
+files in your distribution.
+
+=back
+
+
+=item new_from_context(%args)
+
+[version 0.28]
+
+When called from a directory containing a F<Build.PL> script (in other words,
+the base directory of a distribution), this method will run the F<Build.PL> and
+call C<resume()> to return the resulting C<Module::Build> object to the caller.
+Any key-value arguments given to C<new_from_context()> are essentially like
+command line arguments given to the F<Build.PL> script, so for example you
+could pass C<< verbose => 1 >> to this method to turn on verbosity.
+
+=item resume()
+
+[version 0.03]
+
+You'll probably never call this method directly, it's only called from the
+auto-generated C<Build> script (and the C<new_from_context> method). The
+C<new()> method is only called once, when the user runs C<perl Build.PL>.
+Thereafter, when the user runs C<Build test> or another action, the
+C<Module::Build> object is created using the C<resume()> method to
+re-instantiate with the settings given earlier to C<new()>.
+
+=item subclass()
+
+[version 0.06]
+
+This creates a new C<Module::Build> subclass on the fly, as described
+in the L<Module::Build::Authoring/"SUBCLASSING"> section. The caller
+must provide either a C<class> or C<code> parameter, or both. The
+C<class> parameter indicates the name to use for the new subclass, and
+defaults to C<MyModuleBuilder>. The C<code> parameter specifies Perl
+code to use as the body of the subclass.
+
+=item add_property
+
+[version 0.31]
+
+ package 'My::Build';
+ use base 'Module::Build';
+ __PACKAGE__->add_property( 'pedantic' );
+ __PACKAGE__->add_property( answer => 42 );
+ __PACKAGE__->add_property(
+ 'epoch',
+ default => sub { time },
+ check => sub {
+ return 1 if /^\d+$/;
+ shift->property_error( "'$_' is not an epoch time" );
+ return 0;
+ },
+ );
+
+Adds a property to a Module::Build class. Properties are those attributes of a
+Module::Build object which can be passed to the constructor and which have
+accessors to get and set them. All of the core properties, such as
+C<module_name> and C<license>, are defined using this class method.
+
+The first argument to C<add_property()> is always the name of the property.
+The second argument can be either a default value for the property, or a list
+of key/value pairs. The supported keys are:
+
+=over
+
+=item C<default>
+
+The default value. May optionally be specified as a code reference, in which
+case the return value from the execution of the code reference will be used.
+If you need the default to be a code reference, just use a code reference to
+return it, e.g.:
+
+ default => sub { sub { ... } },
+
+=item C<check>
+
+A code reference that checks that a value specified for the property is valid.
+During the execution of the code reference, the new value will be included in
+the C<$_> variable. If the value is correct, the C<check> code reference
+should return true. If the value is not correct, it sends an error message to
+C<property_error()> and returns false.
+
+=back
+
+When this method is called, a new property will be installed in the
+Module::Build class, and an accessor will be built to allow the property to be
+get or set on the build object.
+
+ print $build->pedantic, $/;
+ $build->pedantic(0);
+
+If the default value is a hash reference, this generates a special-case
+accessor method, wherein individual key/value pairs may be set or fetched:
+
+ print "stuff{foo} is: ", $build->stuff( 'foo' ), $/;
+ $build->stuff( foo => 'bar' );
+ print $build->stuff( 'foo' ), $/; # Outputs "bar"
+
+Of course, you can still set the entire hash reference at once, as well:
+
+ $build->stuff( { foo => 'bar', baz => 'yo' } );
+
+In either case, if a C<check> has been specified for the property, it will be
+applied to the entire hash. So the check code reference should look something
+like:
+
+ check => sub {
+ return 1 if defined $_ && exists $_->{foo};
+ shift->property_error(qq{Property "stuff" needs "foo"});
+ return 0;
+ },
+
+=item property_error
+
+[version 0.31]
+
+=back
+
+
+=head2 METHODS
+
+=over 4
+
+=item add_build_element($type)
+
+[version 0.26]
+
+Adds a new type of entry to the build process. Accepts a single
+string specifying its type-name. There must also be a method defined
+to process things of that type, e.g. if you add a build element called
+C<'foo'>, then you must also define a method called
+C<process_foo_files()>.
+
+See also
+L<Module::Build::Cookbook/"Adding new file types to the build process">.
+
+=item add_to_cleanup(@files)
+
+[version 0.03]
+
+You may call C<< $self->add_to_cleanup(@patterns) >> to tell
+C<Module::Build> that certain files should be removed when the user
+performs the C<Build clean> action. The arguments to the method are
+patterns suitable for passing to Perl's C<glob()> function, specified
+in either Unix format or the current machine's native format. It's
+usually convenient to use Unix format when you hard-code the filenames
+(e.g. in F<Build.PL>) and the native format when the names are
+programmatically generated (e.g. in a testing script).
+
+I decided to provide a dynamic method of the C<$build> object, rather
+than just use a static list of files named in the F<Build.PL>, because
+these static lists can get difficult to manage. I usually prefer to
+keep the responsibility for registering temporary files close to the
+code that creates them.
+
+=item args()
+
+[version 0.26]
+
+ my $args_href = $build->args;
+ my %args = $build->args;
+ my $arg_value = $build->args($key);
+ $build->args($key, $value);
+
+This method is the preferred interface for retrieving the arguments passed via
+command line options to F<Build.PL> or F<Build>, minus the Module-Build
+specific options.
+
+When called in a scalar context with no arguments, this method returns a
+reference to the hash storing all of the arguments; in an array context, it
+returns the hash itself. When passed a single argument, it returns the value
+stored in the args hash for that option key. When called with two arguments,
+the second argument is assigned to the args hash under the key passed as the
+first argument.
+
+=item autosplit_file($from, $to)
+
+[version 0.28]
+
+Invokes the L<AutoSplit> module on the C<$from> file, sending the
+output to the C<lib/auto> directory inside C<$to>. C<$to> is
+typically the C<blib/> directory.
+
+=item base_dir()
+
+[version 0.14]
+
+Returns a string containing the root-level directory of this build,
+i.e. where the C<Build.PL> script and the C<lib> directory can be
+found. This is usually the same as the current working directory,
+because the C<Build> script will C<chdir()> into this directory as
+soon as it begins execution.
+
+=item build_requires()
+
+[version 0.21]
+
+Returns a hash reference indicating the C<build_requires>
+prerequisites that were passed to the C<new()> method.
+
+=item can_action( $action )
+
+Returns a reference to the method that defines C<$action>, or false
+otherwise. This is handy for actions defined (or maybe not!) in subclasses.
+
+[version 0.32_xx]
+
+=item cbuilder()
+
+[version 0.2809]
+
+Returns the internal ExtUtils::CBuilder object that can be used for
+compiling & linking C code. If no such object is available (e.g. if
+the system has no compiler installed) an exception will be thrown.
+
+=item check_installed_status($module, $version)
+
+[version 0.11]
+
+This method returns a hash reference indicating whether a version
+dependency on a certain module is satisfied. The C<$module> argument
+is given as a string like C<"Data::Dumper"> or C<"perl">, and the
+C<$version> argument can take any of the forms described in L</requires>
+above. This allows very fine-grained version checking.
+
+The returned hash reference has the following structure:
+
+ {
+ ok => $whether_the_dependency_is_satisfied,
+ have => $version_already_installed,
+ need => $version_requested, # Same as incoming $version argument
+ message => $informative_error_message,
+ }
+
+If no version of C<$module> is currently installed, the C<have> value
+will be the string C<< "<none>" >>. Otherwise the C<have> value will
+simply be the version of the installed module. Note that this means
+that if C<$module> is installed but doesn't define a version number,
+the C<have> value will be C<undef> - this is why we don't use C<undef>
+for the case when C<$module> isn't installed at all.
+
+This method may be called either as an object method
+(C<< $build->check_installed_status($module, $version) >>)
+or as a class method
+(C<< Module::Build->check_installed_status($module, $version) >>).
+
+=item check_installed_version($module, $version)
+
+[version 0.05]
+
+Like L<check_installed_status()|/"check_installed_status($module, $version)">,
+but simply returns true or false depending on whether module
+C<$module> satisfies the dependency C<$version>.
+
+If the check succeeds, the return value is the actual version of
+C<$module> installed on the system. This allows you to do the
+following:
+
+ my $installed = $build->check_installed_version('DBI', '1.15');
+ if ($installed) {
+ print "Congratulations, version $installed of DBI is installed.\n";
+ } else {
+ die "Sorry, you must install DBI.\n";
+ }
+
+If the check fails, we return false and set C<$@> to an informative
+error message.
+
+If C<$version> is any non-true value (notably zero) and any version of
+C<$module> is installed, we return true. In this case, if C<$module>
+doesn't define a version, or if its version is zero, we return the
+special value "0 but true", which is numerically zero, but logically
+true.
+
+In general you might prefer to use C<check_installed_status> if you
+need detailed information, or this method if you just need a yes/no
+answer.
+
+=item compare_versions($v1, $op, $v2)
+
+[version 0.28]
+
+Compares two module versions C<$v1> and C<$v2> using the operator
+C<$op>, which should be one of Perl's numeric operators like C<!=> or
+C<< >= >> or the like. We do at least a halfway-decent job of
+handling versions that aren't strictly numeric, like C<0.27_02>, but
+exotic stuff will likely cause problems.
+
+In the future, the guts of this method might be replaced with a call
+out to C<version.pm>.
+
+=item config($key)
+
+=item config($key, $value)
+
+=item config() [deprecated]
+
+[version 0.22]
+
+With a single argument C<$key>, returns the value associated with that
+key in the C<Config.pm> hash, including any changes the author or user
+has specified.
+
+With C<$key> and C<$value> arguments, sets the value for future
+callers of C<config($key)>.
+
+With no arguments, returns a hash reference containing all such
+key-value pairs. This usage is deprecated, though, because it's a
+resource hog and violates encapsulation.
+
+=item config_data($name)
+
+=item config_data($name => $value)
+
+[version 0.26]
+
+With a single argument, returns the value of the configuration
+variable C<$name>. With two arguments, sets the given configuration
+variable to the given value. The value may be any Perl scalar that's
+serializable with C<Data::Dumper>. For instance, if you write a
+module that can use a MySQL or PostgreSQL back-end, you might create
+configuration variables called C<mysql_connect> and
+C<postgres_connect>, and set each to an array of connection parameters
+for C<< DBI->connect() >>.
+
+Configuration values set in this way using the Module::Build object
+will be available for querying during the build/test process and after
+installation via the generated C<...::ConfigData> module, as
+C<< ...::ConfigData->config($name) >>.
+
+The L<feature()|/"feature($name)"> and C<config_data()> methods represent
+Module::Build's main support for configuration of installed modules.
+See also L<Module::Build::Authoring/"SAVING CONFIGURATION INFORMATION">.
+
+=item conflicts()
+
+[version 0.21]
+
+Returns a hash reference indicating the C<conflicts> prerequisites
+that were passed to the C<new()> method.
+
+=item contains_pod($file) [deprecated]
+
+[version 0.20]
+
+[Deprecated] Please see L<Module::Build::ModuleInfo> instead.
+
+Returns true if the given file appears to contain POD documentation.
+Currently this checks whether the file has a line beginning with
+'=pod', '=head', or '=item', but the exact semantics may change in the
+future.
+
+=item copy_if_modified(%parameters)
+
+[version 0.19]
+
+Takes the file in the C<from> parameter and copies it to the file in
+the C<to> parameter, or the directory in the C<to_dir> parameter, if
+the file has changed since it was last copied (or if it doesn't exist
+in the new location). By default the entire directory structure of
+C<from> will be copied into C<to_dir>; an optional C<flatten>
+parameter will copy into C<to_dir> without doing so.
+
+Returns the path to the destination file, or C<undef> if nothing
+needed to be copied.
+
+Any directories that need to be created in order to perform the
+copying will be automatically created.
+
+The destination file is set to read-only. If the source file has the
+executable bit set, then the destination file will be made executable.
+
+=item create_build_script()
+
+[version 0.05]
+
+Creates an executable script called C<Build> in the current directory
+that will be used to execute further user actions. This script is
+roughly analogous (in function, not in form) to the Makefile created
+by C<ExtUtils::MakeMaker>. This method also creates some temporary
+data in a directory called C<_build/>. Both of these will be removed
+when the C<realclean> action is performed.
+
+Among the files created in C<_build/> is a F<_build/prereqs> file
+containing the set of prerequisites for this distribution, as a hash
+of hashes. This file may be C<eval()>-ed to obtain the authoritative
+set of prerequisites, which might be different from the contents of
+F<META.yml> (because F<Build.PL> might have set them dynamically).
+But fancy developers take heed: do not put any fancy custom runtime
+code in the F<_build/prereqs> file, leave it as a static declaration
+containing only strings and numbers. Similarly, do not alter the
+structure of the internal C<< $self->{properties}{requires} >> (etc.)
+data members, because that's where this data comes from.
+
+=item current_action()
+
+[version 0.28]
+
+Returns the name of the currently-running action, such as "build" or
+"test". This action is not necessarily the action that was originally
+invoked by the user. For example, if the user invoked the "test"
+action, current_action() would initially return "test". However,
+action "test" depends on action "code", so current_action() will
+return "code" while that dependency is being executed. Once that
+action has completed, current_action() will again return "test".
+
+If you need to know the name of the original action invoked by the
+user, see L</invoked_action()> below.
+
+=item depends_on(@actions)
+
+[version 0.28]
+
+Invokes the named action or list of actions in sequence. Using this
+method is preferred to calling the action explicitly because it
+performs some internal record-keeping, and it ensures that the same
+action is not invoked multiple times (note: in future versions of
+Module::Build it's conceivable that this run-only-once mechanism will
+be changed to something more intelligent).
+
+Note that the name of this method is something of a misnomer; it
+should really be called something like
+C<invoke_actions_unless_already_invoked()> or something, but for
+better or worse (perhaps better!) we were still thinking in
+C<make>-like dependency terms when we created this method.
+
+See also L<dispatch()|/"dispatch($action, %args)">. The main
+distinction between the two is that C<depends_on()> is meant to call
+an action from inside another action, whereas C<dispatch()> is meant
+to set the very top action in motion.
+
+=item dir_contains($first_dir, $second_dir)
+
+[version 0.28]
+
+Returns true if the first directory logically contains the second
+directory. This is just a convenience function because C<File::Spec>
+doesn't really provide an easy way to figure this out (but
+C<Path::Class> does...).
+
+=item dispatch($action, %args)
+
+[version 0.03]
+
+Invokes the build action C<$action>. Optionally, a list of options
+and their values can be passed in. This is equivalent to invoking an
+action at the command line, passing in a list of options.
+
+Custom options that have not been registered must be passed in as a
+hash reference in a key named "args":
+
+ $build->dispatch('foo', verbose => 1, args => { my_option => 'value' });
+
+This method is intended to be used to programmatically invoke build
+actions, e.g. by applications controlling Module::Build-based builds
+rather than by subclasses.
+
+See also L<depends_on()|/"depends_on(@actions)">. The main
+distinction between the two is that C<depends_on()> is meant to call
+an action from inside another action, whereas C<dispatch()> is meant
+to set the very top action in motion.
+
+=item dist_dir()
+
+[version 0.28]
+
+Returns the name of the directory that will be created during the
+C<dist> action. The name is derived from the C<dist_name> and
+C<dist_version> properties.
+
+=item dist_name()
+
+[version 0.21]
+
+Returns the name of the current distribution, as passed to the
+C<new()> method in a C<dist_name> or modified C<module_name>
+parameter.
+
+=item dist_version()
+
+[version 0.21]
+
+Returns the version of the current distribution, as determined by the
+C<new()> method from a C<dist_version>, C<dist_version_from>, or
+C<module_name> parameter.
+
+=item do_system($cmd, @args)
+
+[version 0.21]
+
+This is a fairly simple wrapper around Perl's C<system()> built-in
+command. Given a command and an array of optional arguments, this
+method will print the command to C<STDOUT>, and then execute it using
+Perl's C<system()>. It returns true or false to indicate success or
+failure (the opposite of how C<system()> works, but more intuitive).
+
+Note that if you supply a single argument to C<do_system()>, it
+will/may be processed by the system's shell, and any special
+characters will do their special things. If you supply multiple
+arguments, no shell will get involved and the command will be executed
+directly.
+
+=item extra_compiler_flags()
+
+=item extra_compiler_flags(@flags)
+
+[version 0.25]
+
+Set or retrieve the extra compiler flags. Returns an arrayref of flags.
+
+=item extra_linker_flags()
+
+=item extra_linker_flags(@flags)
+
+[version 0.25]
+
+Set or retrieve the extra linker flags. Returns an arrayref of flags.
+
+=item feature($name)
+
+=item feature($name => $value)
+
+[version 0.26]
+
+With a single argument, returns true if the given feature is set.
+With two arguments, sets the given feature to the given boolean value.
+In this context, a "feature" is any optional functionality of an
+installed module. For instance, if you write a module that could
+optionally support a MySQL or PostgreSQL backend, you might create
+features called C<mysql_support> and C<postgres_support>, and set them
+to true/false depending on whether the user has the proper databases
+installed and configured.
+
+Features set in this way using the Module::Build object will be
+available for querying during the build/test process and after
+installation via the generated C<...::ConfigData> module, as
+C<< ...::ConfigData->feature($name) >>.
+
+The C<feature()> and C<config_data()> methods represent
+Module::Build's main support for configuration of installed modules.
+See also L<Module::Build::Authoring/"SAVING CONFIGURATION INFORMATION">.
+
+=item fix_shebang_line(@files)
+
+[version 0.??]
+
+Modify any "shebang" line in the specified files to use the path to the
+perl executable being used for the current build. Files are modified
+in-place. The existing shebang line must have a command that contains
+"C<perl>"; arguments to the command do not count. In particular, this
+means that the use of C<#!/usr/bin/env perl> will not be changed.
+
+For an explanation of shebang lines, see
+L<http://en.wikipedia.org/wiki/Shebang_%28Unix%29>.
+
+=item have_c_compiler()
+
+[version 0.21]
+
+Returns true if the current system seems to have a working C compiler.
+We currently determine this by attempting to compile a simple C source
+file and reporting whether the attempt was successful.
+
+=item install_base_relpaths()
+
+=item install_base_relpaths($type)
+
+=item install_base_relpaths($type => $path)
+
+[version 0.28]
+
+Set or retrieve the relative paths that are appended to
+C<install_base> for any installable element. This is useful if you
+want to set the relative install path for custom build elements.
+
+With no argument, it returns a reference to a hash containing all
+elements and their respective values. This hash should not be modified
+directly; use the multiple argument below form to change values.
+
+The single argument form returns the value associated with the
+element C<$type>.
+
+The multiple argument form allows you to set the paths for element types.
+C<$value> must be a relative path using Unix-like paths. (A series of
+directories separated by slashes, e.g. C<foo/bar>.) The return value is a
+localized path based on C<$value>.
+
+Assigning the value C<undef> to an element causes it to be removed.
+
+=item install_destination($type)
+
+[version 0.28]
+
+Returns the directory in which items of type C<$type> (e.g. C<lib>,
+C<arch>, C<bin>, or anything else returned by the L</install_types()>
+method) will be installed during the C<install> action. Any settings
+for C<install_path>, C<install_base>, and C<prefix> are taken into
+account when determining the return value.
+
+=item install_path()
+
+=item install_path($type)
+
+=item install_path($type => $path)
+
+[version 0.28]
+
+Set or retrieve paths for specific installable elements. This is
+useful when you want to examine any explicit install paths specified
+by the user on the command line, or if you want to set the install
+path for a specific installable element based on another attribute
+like C<install_base()>.
+
+With no argument, it returns a reference to a hash containing all
+elements and their respective values. This hash should not be modified
+directly; use the multiple argument below form to change values.
+
+The single argument form returns the value associated with the
+element C<$type>.
+
+The multiple argument form allows you to set the paths for element types.
+The supplied C<$path> should be an absolute path to install elements
+of C<$type>. The return value is C<$path>.
+
+Assigning the value C<undef> to an element causes it to be removed.
+
+=item install_types()
+
+[version 0.28]
+
+Returns a list of installable types that this build knows about.
+These types each correspond to the name of a directory in F<blib/>,
+and the list usually includes items such as C<lib>, C<arch>, C<bin>,
+C<script>, C<libdoc>, C<bindoc>, and if HTML documentation is to be
+built, C<libhtml> and C<binhtml>. Other user-defined types may also
+exist.
+
+=item invoked_action()
+
+[version 0.28]
+
+This is the name of the original action invoked by the user. This
+value is set when the user invokes F<Build.PL>, the F<Build> script,
+or programmatically through the L<dispatch()|/"dispatch($action, %args)">
+method. It does not change as sub-actions are executed as
+dependencies are evaluated.
+
+To get the name of the currently executing dependency, see
+L</current_action()> above.
+
+=item notes()
+
+=item notes($key)
+
+=item notes($key => $value)
+
+[version 0.20]
+
+The C<notes()> value allows you to store your own persistent
+information about the build, and to share that information among
+different entities involved in the build. See the example in the
+C<current()> method.
+
+The C<notes()> method is essentially a glorified hash access. With no
+arguments, C<notes()> returns the entire hash of notes. With one argument,
+C<notes($key)> returns the value associated with the given key. With two
+arguments, C<notes($key, $value)> sets the value associated with the given key
+to C<$value> and returns the new value.
+
+The lifetime of the C<notes> data is for "a build" - that is, the
+C<notes> hash is created when C<perl Build.PL> is run (or when the
+C<new()> method is run, if the Module::Build Perl API is being used
+instead of called from a shell), and lasts until C<perl Build.PL> is
+run again or the C<clean> action is run.
+
+=item orig_dir()
+
+[version 0.28]
+
+Returns a string containing the working directory that was in effect
+before the F<Build> script chdir()-ed into the C<base_dir>. This
+might be useful for writing wrapper tools that might need to chdir()
+back out.
+
+=item os_type()
+
+[version 0.04]
+
+If you're subclassing Module::Build and some code needs to alter its
+behavior based on the current platform, you may only need to know
+whether you're running on Windows, Unix, MacOS, VMS, etc., and not the
+fine-grained value of Perl's C<$^O> variable. The C<os_type()> method
+will return a string like C<Windows>, C<Unix>, C<MacOS>, C<VMS>, or
+whatever is appropriate. If you're running on an unknown platform, it
+will return C<undef> - there shouldn't be many unknown platforms
+though.
+
+=item is_vmsish()
+
+=item is_windowsish()
+
+=item is_unixish()
+
+Convenience functions that return a boolean value indicating whether
+this platform behaves respectively like VMS, Windows, or Unix. For
+arbitrary reasons other platforms don't get their own such functions,
+at least not yet.
+
+
+=item prefix_relpaths()
+
+=item prefix_relpaths($installdirs)
+
+=item prefix_relpaths($installdirs, $type)
+
+=item prefix_relpaths($installdirs, $type => $path)
+
+[version 0.28]
+
+Set or retrieve the relative paths that are appended to C<prefix> for
+any installable element. This is useful if you want to set the
+relative install path for custom build elements.
+
+With no argument, it returns a reference to a hash containing all
+elements and their respective values as defined by the current
+C<installdirs> setting.
+
+With a single argument, it returns a reference to a hash containing
+all elements and their respective values as defined by
+C<$installdirs>.
+
+The hash returned by the above calls should not be modified directly;
+use the three-argument below form to change values.
+
+The two argument form returns the value associated with the
+element C<$type>.
+
+The multiple argument form allows you to set the paths for element types.
+C<$value> must be a relative path using Unix-like paths. (A series of
+directories separated by slashes, e.g. C<foo/bar>.) The return value is a
+localized path based on C<$value>.
+
+Assigning the value C<undef> to an element causes it to be removed.
+
+=item get_metadata()
+
+[version 0.36]
+
+This method returns a hash reference of metadata that can be used to create a
+YAML datastream. It is provided for authors to override or customize the fields
+of F<META.yml>. E.g.
+
+ package My::Builder;
+ use base 'Module::Build';
+
+ sub get_metadata {
+ my $self, @args = @_;
+ my $data = $self->SUPER::get_metadata(@args);
+ $data->{custom_field} = 'foo';
+ return $data;
+ }
+
+Valid arguments include:
+
+=over
+
+=item *
+
+C<fatal> -- indicates whether missing required
+metadata fields should be a fatal error or not. For META creation, it
+generally should, but for MYMETA creation for end-users, it should not be
+fatal.
+
+=item *
+
+C<auto> -- indicates whether any necessary configure_requires should be
+automatically added. This is used in META creation.
+
+=back
+
+This method is a wrapper around the old prepare_metadata API now that we
+no longer use YAML::Node to hold metadata.
+
+=item prepare_metadata() [deprecated]
+
+[version 0.36]
+
+[Deprecated] As of 0.36, authors should use C<get_metadata> instead. This
+method is preserved for backwards compatibility only.
+
+It takes three positional arguments: a hashref (to which metadata will be
+added), an optional arrayref (to which metadata keys will be added in order if
+the arrayref exists), and a hashref of arguments (as provided to get_metadata).
+The latter argument is new as of 0.36. Earlier versions are always fatal on
+errors.
+
+Prior to version 0.36, this method took a YAML::Node as an argument to hold
+assembled metadata.
+
+=item prereq_failures()
+
+[version 0.11]
+
+Returns a data structure containing information about any failed
+prerequisites (of any of the types described above), or C<undef> if
+all prerequisites are met.
+
+The data structure returned is a hash reference. The top level keys
+are the type of prerequisite failed, one of "requires",
+"build_requires", "conflicts", or "recommends". The associated values
+are hash references whose keys are the names of required (or
+conflicting) modules. The associated values of those are hash
+references indicating some information about the failure. For example:
+
+ {
+ have => '0.42',
+ need => '0.59',
+ message => 'Version 0.42 is installed, but we need version 0.59',
+ }
+
+or
+
+ {
+ have => '<none>',
+ need => '0.59',
+ message => 'Prerequisite Foo isn't installed',
+ }
+
+This hash has the same structure as the hash returned by the
+C<check_installed_status()> method, except that in the case of
+"conflicts" dependencies we change the "need" key to "conflicts" and
+construct a proper message.
+
+Examples:
+
+ # Check a required dependency on Foo::Bar
+ if ( $build->prereq_failures->{requires}{Foo::Bar} ) { ...
+
+ # Check whether there were any failures
+ if ( $build->prereq_failures ) { ...
+
+ # Show messages for all failures
+ my $failures = $build->prereq_failures;
+ while (my ($type, $list) = each %$failures) {
+ while (my ($name, $hash) = each %$list) {
+ print "Failure for $name: $hash->{message}\n";
+ }
+ }
+
+=item prereq_data()
+
+[version 0.32]
+
+Returns a reference to a hash describing all prerequisites. The keys of the
+hash will be the various prerequisite types ('requires', 'build_requires',
+'test_requires', 'configure_requires', 'recommends', or 'conflicts') and the values will be
+references to hashes of module names and version numbers. Only prerequisites
+types that are defined will be included. The C<prereq_data> action is just a
+thin wrapper around the C<prereq_data()> method and dumps the hash as a string
+that can be loaded using C<eval()>.
+
+=item prereq_report()
+
+[version 0.28]
+
+Returns a human-readable (table-form) string showing all
+prerequisites, the versions required, and the versions actually
+installed. This can be useful for reviewing the configuration of your
+system prior to a build, or when compiling data to send for a bug
+report. The C<prereq_report> action is just a thin wrapper around the
+C<prereq_report()> method.
+
+=item prompt($message, $default)
+
+[version 0.12]
+
+Asks the user a question and returns their response as a string. The
+first argument specifies the message to display to the user (for
+example, C<"Where do you keep your money?">). The second argument,
+which is optional, specifies a default answer (for example,
+C<"wallet">). The user will be asked the question once.
+
+If C<prompt()> detects that it is not running interactively and there
+is nothing on STDIN or if the PERL_MM_USE_DEFAULT environment variable
+is set to true, the $default will be used without prompting.
+
+To prevent automated processes from blocking, the user must either set
+PERL_MM_USE_DEFAULT or attach something to STDIN (this can be a
+pipe/file containing a scripted set of answers or /dev/null.)
+
+If no $default is provided an empty string will be used instead. In
+non-interactive mode, the absence of $default is an error (though
+explicitly passing C<undef()> as the default is valid as of 0.27.)
+
+This method may be called as a class or object method.
+
+=item recommends()
+
+[version 0.21]
+
+Returns a hash reference indicating the C<recommends> prerequisites
+that were passed to the C<new()> method.
+
+=item requires()
+
+[version 0.21]
+
+Returns a hash reference indicating the C<requires> prerequisites that
+were passed to the C<new()> method.
+
+=item rscan_dir($dir, $pattern)
+
+[version 0.28]
+
+Uses C<File::Find> to traverse the directory C<$dir>, returning a
+reference to an array of entries matching C<$pattern>. C<$pattern>
+may either be a regular expression (using C<qr//> or just a plain
+string), or a reference to a subroutine that will return true for
+wanted entries. If C<$pattern> is not given, all entries will be
+returned.
+
+Examples:
+
+ # All the *.pm files in lib/
+ $m->rscan_dir('lib', qr/\.pm$/)
+
+ # All the files in blib/ that aren't *.html files
+ $m->rscan_dir('blib', sub {-f $_ and not /\.html$/});
+
+ # All the files in t/
+ $m->rscan_dir('t');
+
+=item runtime_params()
+
+=item runtime_params($key)
+
+[version 0.28]
+
+The C<runtime_params()> method stores the values passed on the command line
+for valid properties (that is, any command line options for which
+C<valid_property()> returns a true value). The value on the command line may
+override the default value for a property, as well as any value specified in a
+call to C<new()>. This allows you to programmatically tell if C<perl Build.PL>
+or any execution of C<./Build> had command line options specified that
+override valid properties.
+
+The C<runtime_params()> method is essentially a glorified read-only hash. With
+no arguments, C<runtime_params()> returns the entire hash of properties
+specified on the command line. With one argument, C<runtime_params($key)>
+returns the value associated with the given key.
+
+The lifetime of the C<runtime_params> data is for "a build" - that is, the
+C<runtime_params> hash is created when C<perl Build.PL> is run (or when the
+C<new()> method is called, if the Module::Build Perl API is being used instead
+of called from a shell), and lasts until C<perl Build.PL> is run again or the
+C<clean> action is run.
+
+=item script_files()
+
+[version 0.18]
+
+Returns a hash reference whose keys are the perl script files to be
+installed, if any. This corresponds to the C<script_files> parameter to the
+C<new()> method. With an optional argument, this parameter may be set
+dynamically.
+
+For backward compatibility, the C<scripts()> method does exactly the
+same thing as C<script_files()>. C<scripts()> is deprecated, but it
+will stay around for several versions to give people time to
+transition.
+
+=item up_to_date($source_file, $derived_file)
+
+=item up_to_date(\@source_files, \@derived_files)
+
+[version 0.20]
+
+This method can be used to compare a set of source files to a set of
+derived files. If any of the source files are newer than any of the
+derived files, it returns false. Additionally, if any of the derived
+files do not exist, it returns false. Otherwise it returns true.
+
+The arguments may be either a scalar or an array reference of file
+names.
+
+=item y_n($message, $default)
+
+[version 0.12]
+
+Asks the user a yes/no question using C<prompt()> and returns true or
+false accordingly. The user will be asked the question repeatedly
+until they give an answer that looks like "yes" or "no".
+
+The first argument specifies the message to display to the user (for
+example, C<"Shall I invest your money for you?">), and the second
+argument specifies the default answer (for example, C<"y">).
+
+Note that the default is specified as a string like C<"y"> or C<"n">,
+and the return value is a Perl boolean value like 1 or 0. I thought
+about this for a while and this seemed like the most useful way to do
+it.
+
+This method may be called as a class or object method.
+
+=back
+
+
+=head2 Autogenerated Accessors
+
+In addition to the aforementioned methods, there are also some get/set
+accessor methods for the following properties:
+
+=over 4
+
+=item PL_files()
+
+=item allow_mb_mismatch()
+
+=item allow_pureperl()
+
+=item auto_configure_requires()
+
+=item autosplit()
+
+=item base_dir()
+
+=item bindoc_dirs()
+
+=item blib()
+
+=item build_bat()
+
+=item build_class()
+
+=item build_elements()
+
+=item build_requires()
+
+=item build_script()
+
+=item bundle_inc()
+
+=item bundle_inc_preload()
+
+=item c_source()
+
+=item config_dir()
+
+=item configure_requires()
+
+=item conflicts()
+
+=item cpan_client()
+
+=item create_license()
+
+=item create_makefile_pl()
+
+=item create_packlist()
+
+=item create_readme()
+
+=item debug()
+
+=item debugger()
+
+=item destdir()
+
+=item dynamic_config()
+
+=item extra_manify_args()
+
+=item get_options()
+
+=item html_css()
+
+=item include_dirs()
+
+=item install_base()
+
+=item installdirs()
+
+=item libdoc_dirs()
+
+=item license()
+
+=item magic_number()
+
+=item mb_version()
+
+=item meta_add()
+
+=item meta_merge()
+
+=item metafile()
+
+=item metafile2()
+
+=item module_name()
+
+=item mymetafile()
+
+=item mymetafile2()
+
+=item needs_compiler()
+
+=item orig_dir()
+
+=item perl()
+
+=item pm_files()
+
+=item pod_files()
+
+=item pollute()
+
+=item prefix()
+
+=item prereq_action_types()
+
+=item program_name()
+
+=item pureperl_only()
+
+=item quiet()
+
+=item recommends()
+
+=item recurse_into()
+
+=item recursive_test_files()
+
+=item requires()
+
+=item scripts()
+
+=item sign()
+
+=item tap_harness_args()
+
+=item test_file_exts()
+
+=item test_requires()
+
+=item use_rcfile()
+
+=item use_tap_harness()
+
+=item verbose()
+
+=item xs_files()
+
+=back
+
+=head1 MODULE METADATA
+
+If you would like to add other useful metadata, C<Module::Build>
+supports this with the C<meta_add> and C<meta_merge> arguments to
+L</new()>. The authoritative list of supported metadata can be found at
+L<CPAN::Meta::Spec> but for convenience - here are a few of the more useful ones:
+
+=over 4
+
+=item keywords
+
+For describing the distribution using keyword (or "tags") in order to
+make CPAN.org indexing and search more efficient and useful.
+
+=item resources
+
+A list of additional resources available for users of the
+distribution. This can include links to a homepage on the web, a
+bug tracker, the repository location, and even a subscription page for the
+distribution mailing list.
+
+=back
+
+
+=head1 AUTHOR
+
+Ken Williams <kwilliams@cpan.org>
+
+
+=head1 COPYRIGHT
+
+Copyright (c) 2001-2006 Ken Williams. All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+
+=head1 SEE ALSO
+
+perl(1), L<Module::Build>(3), L<Module::Build::Authoring>(3),
+L<Module::Build::Cookbook>(3), L<ExtUtils::MakeMaker>(3)
+
+F<META.yml> Specification:
+L<CPAN::Meta::Spec>
+
+=cut
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Authoring.pod b/Master/tlpkg/tlperl/lib/Module/Build/Authoring.pod
new file mode 100644
index 00000000000..a32b31e2e1e
--- /dev/null
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Authoring.pod
@@ -0,0 +1,326 @@
+=head1 NAME
+
+Module::Build::Authoring - Authoring Module::Build modules
+
+=head1 DESCRIPTION
+
+When creating a C<Build.PL> script for a module, something like the
+following code will typically be used:
+
+ use Module::Build;
+ my $build = Module::Build->new
+ (
+ module_name => 'Foo::Bar',
+ license => 'perl',
+ requires => {
+ 'perl' => '5.6.1',
+ 'Some::Module' => '1.23',
+ 'Other::Module' => '>= 1.2, != 1.5, < 2.0',
+ },
+ );
+ $build->create_build_script;
+
+A simple module could get away with something as short as this for its
+C<Build.PL> script:
+
+ use Module::Build;
+ Module::Build->new(
+ module_name => 'Foo::Bar',
+ license => 'perl',
+ )->create_build_script;
+
+The model used by C<Module::Build> is a lot like the C<MakeMaker>
+metaphor, with the following correspondences:
+
+ In Module::Build In ExtUtils::MakeMaker
+ --------------------------- ------------------------
+ Build.PL (initial script) Makefile.PL (initial script)
+ Build (a short perl script) Makefile (a long Makefile)
+ _build/ (saved state info) various config text in the Makefile
+
+Any customization can be done simply by subclassing C<Module::Build>
+and adding a method called (for example) C<ACTION_test>, overriding
+the default 'test' action. You could also add a method called
+C<ACTION_whatever>, and then you could perform the action C<Build
+whatever>.
+
+For information on providing compatibility with
+C<ExtUtils::MakeMaker>, see L<Module::Build::Compat> and
+L<http://www.makemaker.org/wiki/index.cgi?ModuleBuildConversionGuide>.
+
+
+=head1 STRUCTURE
+
+Module::Build creates a class hierarchy conducive to customization.
+Here is the parent-child class hierarchy in classy ASCII art:
+
+ /--------------------\
+ | Your::Parent | (If you subclass Module::Build)
+ \--------------------/
+ |
+ |
+ /--------------------\ (Doesn't define any functionality
+ | Module::Build | of its own - just figures out what
+ \--------------------/ other modules to load.)
+ |
+ |
+ /-----------------------------------\ (Some values of $^O may
+ | Module::Build::Platform::$^O | define specialized functionality.
+ \-----------------------------------/ Otherwise it's ...::Default, a
+ | pass-through class.)
+ |
+ /--------------------------\
+ | Module::Build::Base | (Most of the functionality of
+ \--------------------------/ Module::Build is defined here.)
+
+
+=head1 SUBCLASSING
+
+Right now, there are two ways to subclass Module::Build. The first
+way is to create a regular module (in a C<.pm> file) that inherits
+from Module::Build, and use that module's class instead of using
+Module::Build directly:
+
+ ------ in Build.PL: ----------
+ #!/usr/bin/perl
+
+ use lib q(/nonstandard/library/path);
+ use My::Builder; # Or whatever you want to call it
+
+ my $build = My::Builder->new
+ (
+ module_name => 'Foo::Bar', # All the regular args...
+ license => 'perl',
+ dist_author => 'A N Other <me@here.net.au>',
+ requires => { Carp => 0 }
+ );
+ $build->create_build_script;
+
+This is relatively straightforward, and is the best way to do things
+if your My::Builder class contains lots of code. The
+C<create_build_script()> method will ensure that the current value of
+C<@INC> (including the C</nonstandard/library/path>) is propagated to
+the Build script, so that My::Builder can be found when running build
+actions. If you find that you need to C<chdir> into a different directories
+in your subclass methods or actions, be sure to always return to the original
+directory (available via the C<base_dir()> method) before returning control
+to the parent class. This is important to avoid data serialization problems.
+
+For very small additions, Module::Build provides a C<subclass()>
+method that lets you subclass Module::Build more conveniently, without
+creating a separate file for your module:
+
+ ------ in Build.PL: ----------
+ #!/usr/bin/perl
+
+ use Module::Build;
+ my $class = Module::Build->subclass
+ (
+ class => 'My::Builder',
+ code => q{
+ sub ACTION_foo {
+ print "I'm fooing to death!\n";
+ }
+ },
+ );
+
+ my $build = $class->new
+ (
+ module_name => 'Foo::Bar', # All the regular args...
+ license => 'perl',
+ dist_author => 'A N Other <me@here.net.au>',
+ requires => { Carp => 0 }
+ );
+ $build->create_build_script;
+
+Behind the scenes, this actually does create a C<.pm> file, since the
+code you provide must persist after Build.PL is run if it is to be
+very useful.
+
+See also the documentation for the L<Module::Build::API/"subclass()">
+method.
+
+
+=head1 PREREQUISITES
+
+=head2 Types of prerequisites
+
+To specify what versions of other modules are used by this
+distribution, several types of prerequisites can be defined with the
+following parameters:
+
+=over 3
+
+=item configure_requires
+
+Items that must be installed I<before> configuring this distribution
+(i.e. before running the F<Build.PL> script). This might be a
+specific minimum version of C<Module::Build> or any other module the
+F<Build.PL> needs in order to do its stuff. Clients like C<CPAN.pm>
+or C<CPANPLUS> will be expected to pick C<configure_requires> out of the
+F<META.yml> file and install these items before running the
+C<Build.PL>.
+
+If no configure_requires is specified, the current version of Module::Build
+is automatically added to configure_requires.
+
+=item build_requires
+
+Items that are necessary for building and testing this distribution,
+but aren't necessary after installation. This can help users who only
+want to install these items temporarily. It also helps reduce the
+size of the CPAN dependency graph if everything isn't smooshed into
+C<requires>.
+
+=item requires
+
+Items that are necessary for basic functioning.
+
+=item recommends
+
+Items that are recommended for enhanced functionality, but there are
+ways to use this distribution without having them installed. You
+might also think of this as "can use" or "is aware of" or "changes
+behavior in the presence of".
+
+=item test_requires
+
+Items that are necessary for testing.
+
+=item conflicts
+
+Items that can cause problems with this distribution when installed.
+This is pretty rare.
+
+=back
+
+=head2 Format of prerequisites
+
+The prerequisites are given in a hash reference, where the keys are
+the module names and the values are version specifiers:
+
+ requires => {
+ Foo::Module => '2.4',
+ Bar::Module => 0,
+ Ken::Module => '>= 1.2, != 1.5, < 2.0',
+ perl => '5.6.0'
+ },
+
+The above four version specifiers have different effects. The value
+C<'2.4'> means that B<at least> version 2.4 of C<Foo::Module> must be
+installed. The value C<0> means that B<any> version of C<Bar::Module>
+is acceptable, even if C<Bar::Module> doesn't define a version. The
+more verbose value C<'E<gt>= 1.2, != 1.5, E<lt> 2.0'> means that
+C<Ken::Module>'s version must be B<at least> 1.2, B<less than> 2.0,
+and B<not equal to> 1.5. The list of criteria is separated by commas,
+and all criteria must be satisfied.
+
+A special C<perl> entry lets you specify the versions of the Perl
+interpreter that are supported by your module. The same version
+dependency-checking semantics are available, except that we also
+understand perl's new double-dotted version numbers.
+
+=head2 XS Extensions
+
+Modules which need to compile XS code should list C<ExtUtils::CBuilder>
+as a C<build_requires> element.
+
+
+=head1 SAVING CONFIGURATION INFORMATION
+
+Module::Build provides a very convenient way to save configuration
+information that your installed modules (or your regression tests) can
+access. If your Build process calls the C<feature()> or
+C<config_data()> methods, then a C<Foo::Bar::ConfigData> module will
+automatically be created for you, where C<Foo::Bar> is the
+C<module_name> parameter as passed to C<new()>. This module provides
+access to the data saved by these methods, and a way to update the
+values. There is also a utility script called C<config_data>
+distributed with Module::Build that provides a command line interface
+to this same functionality. See also the generated
+C<Foo::Bar::ConfigData> documentation, and the C<config_data>
+script's documentation, for more information.
+
+
+=head1 STARTING MODULE DEVELOPMENT
+
+When starting development on a new module, it's rarely worth your time
+to create a tree of all the files by hand. Some automatic
+module-creators are available: the oldest is C<h2xs>, which has
+shipped with perl itself for a long time. Its name reflects the fact
+that modules were originally conceived of as a way to wrap up a C
+library (thus the C<h> part) into perl extensions (thus the C<xs>
+part).
+
+These days, C<h2xs> has largely been superseded by modules like
+C<ExtUtils::ModuleMaker>, and C<Module::Starter>. They have varying
+degrees of support for C<Module::Build>.
+
+
+=head1 AUTOMATION
+
+One advantage of Module::Build is that since it's implemented as Perl
+methods, you can invoke these methods directly if you want to install
+a module non-interactively. For instance, the following Perl script
+will invoke the entire build/install procedure:
+
+ my $build = Module::Build->new(module_name => 'MyModule');
+ $build->dispatch('build');
+ $build->dispatch('test');
+ $build->dispatch('install');
+
+If any of these steps encounters an error, it will throw a fatal
+exception.
+
+You can also pass arguments as part of the build process:
+
+ my $build = Module::Build->new(module_name => 'MyModule');
+ $build->dispatch('build');
+ $build->dispatch('test', verbose => 1);
+ $build->dispatch('install', sitelib => '/my/secret/place/');
+
+Building and installing modules in this way skips creating the
+C<Build> script.
+
+
+=head1 MIGRATION
+
+Note that if you want to provide both a F<Makefile.PL> and a
+F<Build.PL> for your distribution, you probably want to add the
+following to C<WriteMakefile> in your F<Makefile.PL> so that C<MakeMaker>
+doesn't try to run your F<Build.PL> as a normal F<.PL> file:
+
+ PL_FILES => {},
+
+You may also be interested in looking at the C<Module::Build::Compat>
+module, which can automatically create various kinds of F<Makefile.PL>
+compatibility layers.
+
+
+=head1 AUTHOR
+
+Ken Williams <kwilliams@cpan.org>
+
+Development questions, bug reports, and patches should be sent to the
+Module-Build mailing list at <module-build@perl.org>.
+
+Bug reports are also welcome at
+<http://rt.cpan.org/NoAuth/Bugs.html?Dist=Module-Build>.
+
+The latest development version is available from the Git
+repository at <https://github.com/Perl-Toolchain-Gang/Module-Build>
+
+
+=head1 SEE ALSO
+
+perl(1), L<Module::Build>(3), L<Module::Build::API>(3),
+L<Module::Build::Cookbook>(3), L<ExtUtils::MakeMaker>(3), L<YAML>(3)
+
+F<META.yml> Specification:
+L<CPAN::Meta::Spec>
+
+L<http://www.dsmit.com/cons/>
+
+L<http://search.cpan.org/dist/PerlBuildSystem/>
+
+=cut
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Base.pm b/Master/tlpkg/tlperl/lib/Module/Build/Base.pm
index cf42cc0b230..84e137fb4f2 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/Base.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Base.pm
@@ -6,7 +6,7 @@ use strict;
use vars qw($VERSION);
use warnings;
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
BEGIN { require 5.006001 }
@@ -19,7 +19,6 @@ use File::Basename ();
use File::Spec 0.82 ();
use File::Compare ();
use Module::Build::Dumper ();
-use IO::File ();
use Text::ParseWords ();
use Module::Build::ModuleInfo;
@@ -757,17 +756,11 @@ sub ACTION_config_data {
}
sub array_properties {
- for (shift->_mb_classes) {
- return @{$additive_properties{$_}->{ARRAY}}
- if exists $additive_properties{$_}->{ARRAY};
- }
+ map { exists $additive_properties{$_}->{ARRAY} ? @{$additive_properties{$_}->{ARRAY}} : () } shift->_mb_classes;
}
sub hash_properties {
- for (shift->_mb_classes) {
- return @{$additive_properties{$_}->{'HASH'}}
- if exists $additive_properties{$_}->{'HASH'};
- }
+ map { exists $additive_properties{$_}->{HASH} ? @{$additive_properties{$_}->{HASH}} : () } shift->_mb_classes;
}
sub add_property {
@@ -798,10 +791,10 @@ sub ACTION_config_data {
return $class;
}
- sub property_error {
- my $self = shift;
- die 'ERROR: ', @_;
- }
+ sub property_error {
+ my $self = shift;
+ die 'ERROR: ', @_;
+ }
sub _set_defaults {
my $self = shift;
@@ -831,7 +824,7 @@ sub ACTION_config_data {
}
}
-} # end closure
+} # end enclosure
########################################################################
sub _make_hash_accessor {
my ($property, $p) = @_;
@@ -922,6 +915,8 @@ __PACKAGE__->add_property(test_file_exts => ['.t']);
__PACKAGE__->add_property(use_tap_harness => 0);
__PACKAGE__->add_property(cpan_client => 'cpan');
__PACKAGE__->add_property(tap_harness_args => {});
+__PACKAGE__->add_property(pureperl_only => 0);
+__PACKAGE__->add_property(allow_pureperl => 0);
__PACKAGE__->add_property(
'installdirs',
default => 'site',
@@ -942,7 +937,7 @@ __PACKAGE__->add_property(
}
{
- my @prereq_action_types = qw(requires build_requires conflicts recommends);
+ my @prereq_action_types = qw(requires build_requires test_requires conflicts recommends);
foreach my $type (@prereq_action_types) {
__PACKAGE__->add_property($type => {});
}
@@ -1005,6 +1000,7 @@ __PACKAGE__->add_property($_) for qw(
verbose
debug
xs_files
+ extra_manify_args
);
sub config {
@@ -1080,7 +1076,7 @@ sub subclass {
File::Path::mkpath($filedir);
die "Can't create directory $filedir: $!" unless -d $filedir;
- my $fh = IO::File->new("> $filename") or die "Can't create $filename: $!";
+ open(my $fh, '>', $filename) or die "Can't create $filename: $!";
print $fh <<EOF;
package $opts{class};
use $pack;
@@ -1127,83 +1123,90 @@ END_WARN
sub dist_name {
my $self = shift;
my $p = $self->{properties};
- return $p->{dist_name} if defined $p->{dist_name};
+ my $me = 'dist_name';
+ return $p->{$me} if defined $p->{$me};
die "Can't determine distribution name, must supply either 'dist_name' or 'module_name' parameter"
unless $self->module_name;
- ($p->{dist_name} = $self->module_name) =~ s/::/-/g;
+ ($p->{$me} = $self->module_name) =~ s/::/-/g;
- return $p->{dist_name};
+ return $p->{$me};
}
sub release_status {
my ($self) = @_;
+ my $me = 'release_status';
my $p = $self->{properties};
- if ( ! defined $p->{release_status} ) {
- $p->{release_status} = $self->_is_dev_version ? 'testing' : 'stable';
+ if ( ! defined $p->{$me} ) {
+ $p->{$me} = $self->_is_dev_version ? 'testing' : 'stable';
}
- unless ( $p->{release_status} =~ qr/\A(?:stable|testing|unstable)\z/ ) {
- die "Illegal value '$p->{release_status}' for release_status\n";
+ unless ( $p->{$me} =~ qr/\A(?:stable|testing|unstable)\z/ ) {
+ die "Illegal value '$p->{$me}' for $me\n";
}
- if ( $p->{release_status} eq 'stable' && $self->_is_dev_version ) {
+ if ( $p->{$me} eq 'stable' && $self->_is_dev_version ) {
my $version = $self->dist_version;
- die "Illegal value '$p->{release_status}' with version '$version'\n";
+ die "Illegal value '$p->{$me}' with version '$version'\n";
}
- return $p->{release_status};
+ return $p->{$me};
}
sub dist_suffix {
my ($self) = @_;
my $p = $self->{properties};
- return $p->{dist_suffix} if defined $p->{dist_suffix};
+ my $me = 'dist_suffix';
+
+ return $p->{$me} if defined $p->{$me};
if ( $self->release_status eq 'stable' ) {
- $p->{dist_suffix} = "";
+ $p->{$me} = "";
}
else {
# non-stable release but non-dev version number needs '-TRIAL' appended
- $p->{dist_suffix} = $self->_is_dev_version ? "" : "TRIAL" ;
+ $p->{$me} = $self->_is_dev_version ? "" : "TRIAL" ;
}
- return $p->{dist_suffix};
+ return $p->{$me};
}
sub dist_version_from {
my ($self) = @_;
my $p = $self->{properties};
+ my $me = 'dist_version_from';
+
if ($self->module_name) {
- $p->{dist_version_from} ||=
+ $p->{$me} ||=
join( '/', 'lib', split(/::/, $self->module_name) ) . '.pm';
}
- return $p->{dist_version_from} || undef;
+ return $p->{$me} || undef;
}
sub dist_version {
my ($self) = @_;
my $p = $self->{properties};
+ my $me = 'dist_version';
- return $p->{dist_version} if defined $p->{dist_version};
+ return $p->{$me} if defined $p->{$me};
if ( my $dist_version_from = $self->dist_version_from ) {
my $version_from = File::Spec->catfile( split( qr{/}, $dist_version_from ) );
my $pm_info = Module::Build::ModuleInfo->new_from_file( $version_from )
or die "Can't find file $version_from to determine version";
- #$p->{dist_version} is undef here
- $p->{dist_version} = $self->normalize_version( $pm_info->version() );
- unless (defined $p->{dist_version}) {
+ #$p->{$me} is undef here
+ $p->{$me} = $self->normalize_version( $pm_info->version() );
+ unless (defined $p->{$me}) {
die "Can't determine distribution version from $version_from";
}
}
die ("Can't determine distribution version, must supply either 'dist_version',\n".
"'dist_version_from', or 'module_name' parameter")
- unless defined $p->{dist_version};
+ unless defined $p->{$me};
- return $p->{dist_version};
+ return $p->{$me};
}
sub _is_dev_version {
@@ -1227,7 +1230,7 @@ sub _pod_parse {
my $docfile = $self->_main_docfile
or return;
- my $fh = IO::File->new($docfile)
+ open(my $fh, '<', $docfile)
or return;
require Module::Build::PodParser;
@@ -1287,13 +1290,13 @@ sub read_config {
my $file = $self->config_file('build_params')
or die "Can't find 'build_params' in " . $self->config_dir;
- my $fh = IO::File->new($file) or die "Can't read '$file': $!";
+ open(my $fh, '<', $file) or die "Can't read '$file': $!";
my $ref = eval do {local $/; <$fh>};
die if $@;
+ close $fh;
my $c;
($self->{args}, $c, $self->{properties}) = @$ref;
$self->{config} = Module::Build::Config->new(values => $c);
- close $fh;
}
sub has_config_data {
@@ -1305,13 +1308,14 @@ sub _write_data {
my ($self, $filename, $data) = @_;
my $file = $self->config_file($filename);
- my $fh = IO::File->new("> $file") or die "Can't create '$file': $!";
+ open(my $fh, '>', $file) or die "Can't create '$file': $!";
unless (ref($data)) { # e.g. magicnum
print $fh $data;
return;
}
print {$fh} Module::Build::Dumper->_data_dump($data);
+ close $fh;
}
sub write_config {
@@ -1509,7 +1513,7 @@ sub auto_require {
my ($self) = @_;
my $p = $self->{properties};
- # If needs_compiler is not explictly set, automatically set it
+ # If needs_compiler is not explicitly set, automatically set it
# If set, we need ExtUtils::CBuilder (and a compiler)
my $xs_files = $self->find_xs_files;
if ( ! defined $p->{needs_compiler} ) {
@@ -1812,7 +1816,7 @@ sub print_build_script {
my @myINC = $self->_added_to_INC;
for (@myINC, values %q) {
- $_ = File::Spec->canonpath( $_ );
+ $_ = File::Spec->canonpath( $_ ) unless $self->is_vmsish;
s/([\\\'])/\\$1/g;
}
@@ -1830,10 +1834,10 @@ use File::Spec;
sub magic_number_matches {
return 0 unless -e '$q{magic_numfile}';
- local *FH;
- open FH, '$q{magic_numfile}' or return 0;
- my \$filenum = <FH>;
- close FH;
+ my \$FH;
+ open \$FH, '<','$q{magic_numfile}' or return 0;
+ my \$filenum = <\$FH>;
+ close \$FH;
return \$filenum == $magic_number;
}
@@ -1886,8 +1890,8 @@ sub create_mymeta {
my ($self) = @_;
my ($meta_obj, $mymeta);
- my @metafiles = ( $self->metafile, $self->metafile2 );
- my @mymetafiles = ( $self->mymetafile, $self->mymetafile2 );
+ my @metafiles = ( $self->metafile2, $self->metafile, );
+ my @mymetafiles = ( $self->mymetafile2, $self->mymetafile, );
# cleanup old MYMETA
for my $f ( @mymetafiles ) {
@@ -1900,52 +1904,29 @@ sub create_mymeta {
if ( $self->try_require("CPAN::Meta", "2.110420") ) {
for my $file ( @metafiles ) {
next unless -f $file;
- $meta_obj = eval { CPAN::Meta->load_file($file) };
+ $meta_obj = eval { CPAN::Meta->load_file($file, { lazy_validation => 0 }) };
last if $meta_obj;
}
}
# maybe get a copy in spec v2 format (regardless of original source)
- $mymeta = $meta_obj->as_struct
- if $meta_obj;
-
- # if we have metadata, just update it
- if ( defined $mymeta ) {
- my $prereqs = $self->_normalize_prereqs;
- # XXX refactor this mapping somewhere
- $mymeta->{prereqs}{runtime}{requires} = $prereqs->{requires};
- $mymeta->{prereqs}{build}{requires} = $prereqs->{build_requires};
- $mymeta->{prereqs}{runtime}{recommends} = $prereqs->{recommends};
- $mymeta->{prereqs}{runtime}{conflicts} = $prereqs->{conflicts};
- # delete empty entries
- for my $phase ( keys %{$mymeta->{prereqs}} ) {
- if ( ref $mymeta->{prereqs}{$phase} eq 'HASH' ) {
- for my $type ( keys %{$mymeta->{prereqs}{$phase}} ) {
- if ( ! defined $mymeta->{prereqs}{$phase}{$type}
- || ! keys %{$mymeta->{prereqs}{$phase}{$type}}
- ) {
- delete $mymeta->{prereqs}{$phase}{$type};
- }
- }
- }
- if ( ! defined $mymeta->{prereqs}{$phase}
- || ! keys %{$mymeta->{prereqs}{$phase}}
- ) {
- delete $mymeta->{prereqs}{$phase};
- }
- }
- $mymeta->{dynamic_config} = 0;
- $mymeta->{generated_by} = "Module::Build version $Module::Build::VERSION";
- eval { $meta_obj = CPAN::Meta->new( $mymeta, { lazy_validation => 1 } ) }
+
+ my $mymeta_obj;
+ if ($meta_obj) {
+ # if we have metadata, just update it
+ my %updated = (
+ %{ $meta_obj->as_struct({ version => 2.0 }) },
+ prereqs => $self->_normalize_prereqs,
+ dynamic_config => 0,
+ generated_by => "Module::Build version $Module::Build::VERSION",
+ );
+ $mymeta_obj = CPAN::Meta->new( \%updated, { lazy_validation => 0 } );
}
- # or generate from scratch, ignoring errors if META doesn't exist
else {
- $meta_obj = $self->_get_meta_object(
- quiet => 0, dynamic => 0, fatal => 0, auto => 0
- );
+ $mymeta_obj = $self->_get_meta_object(quiet => 0, dynamic => 0, fatal => 1, auto => 0);
}
- my @created = $self->_write_meta_files( $meta_obj, 'MYMETA' );
+ my @created = $self->_write_meta_files( $mymeta_obj, 'MYMETA' );
$self->log_warn("Could not create MYMETA files\n")
unless @created;
@@ -1969,7 +1950,7 @@ sub create_build_script {
$self->log_info("Creating new '$build_script' script for ",
"'$dist_name' version '$dist_version'\n");
- my $fh = IO::File->new(">$build_script") or die "Can't create '$build_script': $!";
+ open(my $fh, '>', $build_script) or die "Can't create '$build_script': $!";
$self->print_build_script($fh);
close $fh;
@@ -2119,6 +2100,8 @@ sub _translate_option {
use_tap_harness
tap_harness_args
cpan_client
+ pureperl_only
+ allow_pureperl
); # normalize only selected option names
return $opt;
@@ -2159,6 +2142,8 @@ sub _optional_arg {
debug
sign
use_tap_harness
+ pureperl_only
+ allow_pureperl
);
# inverted boolean options; eg --noverbose or --no-verbose
@@ -2333,7 +2318,7 @@ sub read_modulebuildrc {
return () unless $modulebuildrc;
}
- my $fh = IO::File->new( $modulebuildrc )
+ open(my $fh, '<', $modulebuildrc )
or die "Can't open $modulebuildrc: $!";
my %options; my $buffer = '';
@@ -2454,7 +2439,7 @@ sub get_action_docs {
(my $file = $class) =~ s{::}{/}g;
# NOTE: silently skipping relative paths if any chdir() happened
$file = $INC{$file . '.pm'} or next;
- my $fh = IO::File->new("< $file") or next;
+ open(my $fh, '<', $file) or next;
$files_found++;
# Code below modified from /usr/bin/perldoc
@@ -2593,8 +2578,8 @@ sub ACTION_help {
print <<EOF;
- Usage: $0 <action> arg1=value arg2=value ...
- Example: $0 test verbose=1
+ Usage: $0 <action> --arg1=value --arg2=value ...
+ Example: $0 test --verbose=1
Actions defined:
EOF
@@ -2751,26 +2736,9 @@ sub run_tap_harness {
sub run_test_harness {
my ($self, $tests) = @_;
require Test::Harness;
- my $p = $self->{properties};
- my @harness_switches = $self->harness_switches;
- # Work around a Test::Harness bug that loses the particular perl
- # we're running under. $self->perl is trustworthy, but $^X isn't.
- local $^X = $self->perl;
-
- # Do everything in our power to work with all versions of Test::Harness
- local $Test::Harness::switches = join ' ', grep defined, $Test::Harness::switches, @harness_switches;
- local $Test::Harness::Switches = join ' ', grep defined, $Test::Harness::Switches, @harness_switches;
- local $ENV{HARNESS_PERL_SWITCHES} = join ' ', grep defined, $ENV{HARNESS_PERL_SWITCHES}, @harness_switches;
-
- $Test::Harness::switches = undef unless length $Test::Harness::switches;
- $Test::Harness::Switches = undef unless length $Test::Harness::Switches;
- delete $ENV{HARNESS_PERL_SWITCHES} unless length $ENV{HARNESS_PERL_SWITCHES};
-
- local ($Test::Harness::verbose,
- $Test::Harness::Verbose,
- $ENV{TEST_VERBOSE},
- $ENV{HARNESS_VERBOSE}) = ($p->{verbose} || 0) x 4;
+ local $Test::Harness::verbose = $self->verbose || 0;
+ local $Test::Harness::switches = join ' ', $self->harness_switches;
Test::Harness::runtests(@$tests);
}
@@ -2968,7 +2936,9 @@ sub process_PL_files {
sub process_xs_files {
my $self = shift;
+ return if $self->pureperl_only && $self->allow_pureperl;
my $files = $self->find_xs_files;
+ croak 'Can\'t build xs files under --pureperl-only' if %$files && $self->pureperl_only;
while (my ($from, $to) = each %$files) {
unless ($from eq $to) {
$self->add_to_cleanup($to);
@@ -3095,10 +3065,10 @@ sub fix_shebang_line { # Adapted from fixin() in ExtUtils::MM_Unix 1.35
my ($does_shbang) = $c->get('sharpbang') =~ /^\s*\#\!/;
for my $file (@files) {
- my $FIXIN = IO::File->new($file) or die "Can't process '$file': $!";
+ open(my $FIXIN, '<', $file) or die "Can't process '$file': $!";
local $/ = "\n";
chomp(my $line = <$FIXIN>);
- next unless $line =~ s/^\s*\#!\s*//; # Not a shbang file.
+ next unless $line =~ s/^\s*\#!\s*//; # Not a shebang file.
my ($cmd, $arg) = (split(' ', $line, 2), '');
next unless $cmd =~ /perl/i;
@@ -3115,7 +3085,7 @@ eval 'exec $interpreter $arg -S \$0 \${1+"\$\@"}'
if 0; # not running under some shell
} unless $self->is_windowsish; # this won't work on win32, so don't
- my $FIXOUT = IO::File->new(">$file.new")
+ open(my $FIXOUT, '>', "$file.new")
or die "Can't create new $file: $!\n";
# Print out the new #! line (or equivalent).
@@ -3228,6 +3198,8 @@ sub ACTION_manpages {
$self->depends_on('code');
+ my %extra_manify_args = $self->{properties}{'extra_manify_args'} ? %{ $self->{properties}{'extra_manify_args'} } : ();
+
foreach my $type ( qw(bin lib) ) {
next unless ( $self->invoked_action eq 'manpages' || $self->_is_default_installable("${type}doc"));
my $files = $self->_find_pods( $self->{properties}{"${type}doc_dirs"},
@@ -3235,12 +3207,13 @@ sub ACTION_manpages {
next unless %$files;
my $sub = $self->can("manify_${type}_pods");
- $self->$sub() if defined( $sub );
+ $self->$sub( %extra_manify_args ) if defined( $sub );
}
}
sub manify_bin_pods {
my $self = shift;
+ my %podman_args = (section => 1, @_); # binaries go in section 1
my $files = $self->_find_pods( $self->{properties}{bindoc_dirs},
exclude => [ $self->file_qr('\.bat$') ] );
@@ -3253,7 +3226,7 @@ sub manify_bin_pods {
foreach my $file (keys %$files) {
# Pod::Simple based parsers only support one document per instance.
# This is expected to change in a future version (Pod::Simple > 3.03).
- my $parser = Pod::Man->new( section => 1 ); # binaries go in section 1
+ my $parser = Pod::Man->new( %podman_args );
my $manpage = $self->man1page_name( $file ) . '.' .
$self->config( 'man1ext' );
my $outfile = File::Spec->catfile($mandir, $manpage);
@@ -3267,6 +3240,7 @@ sub manify_bin_pods {
sub manify_lib_pods {
my $self = shift;
+ my %podman_args = (section => 3, @_); # libraries go in section 3
my $files = $self->_find_pods($self->{properties}{libdoc_dirs});
return unless keys %$files;
@@ -3278,7 +3252,7 @@ sub manify_lib_pods {
while (my ($file, $relfile) = each %$files) {
# Pod::Simple based parsers only support one document per instance.
# This is expected to change in a future version (Pod::Simple > 3.03).
- my $parser = Pod::Man->new( section => 3 ); # libraries go in section 3
+ my $parser = Pod::Man->new( %podman_args );
my $manpage = $self->man3page_name( $relfile ) . '.' .
$self->config( 'man3ext' );
my $outfile = File::Spec->catfile( $mandir, $manpage);
@@ -3301,6 +3275,7 @@ sub _find_pods {
foreach my $regexp ( @{ $args{exclude} } ) {
next FILE if $file =~ $regexp;
}
+ $file = $self->localize_file_path($file);
$files{$file} = File::Spec->abs2rel($file, $dir) if $self->contains_pod( $file )
}
}
@@ -3311,7 +3286,7 @@ sub contains_pod {
my ($self, $file) = @_;
return '' unless -T $file; # Only look at text files
- my $fh = IO::File->new( $file ) or die "Can't open $file: $!";
+ open(my $fh, '<', $file ) or die "Can't open $file: $!";
while (my $line = <$fh>) {
return 1 if $line =~ /^\=(?:head|pod|item)/;
}
@@ -3358,15 +3333,18 @@ sub htmlify_pods {
: $self->original_prefix('core');
my $htmlroot = $self->install_sets('core')->{libhtml};
- my @podpath = (map { File::Spec->abs2rel($_ ,$podroot) } grep { -d }
- ( $self->install_sets('core', 'lib'), # lib
- $self->install_sets('core', 'bin'), # bin
- $self->install_sets('site', 'lib'), # site/lib
- ) ), File::Spec->rel2abs($self->blib);
+ my $podpath;
+ unless (defined $self->args('html_links') and !$self->args('html_links')) {
+ my @podpath = ( (map { File::Spec->abs2rel($_ ,$podroot) } grep { -d }
+ ( $self->install_sets('core', 'lib'), # lib
+ $self->install_sets('core', 'bin'), # bin
+ $self->install_sets('site', 'lib'), # site/lib
+ ) ), File::Spec->rel2abs($self->blib) );
- my $podpath = $ENV{PERL_CORE}
- ? File::Spec->catdir($podroot, 'lib')
- : join(":", map { tr,:\\,|/,; $_ } @podpath);
+ $podpath = $ENV{PERL_CORE}
+ ? File::Spec->catdir($podroot, 'lib')
+ : join(":", map { tr,:\\,|/,; $_ } @podpath);
+ }
my $blibdir = join('/', File::Spec->splitdir(
(File::Spec->splitpath(File::Spec->rel2abs($htmldir),1))[1]),''
@@ -3416,7 +3394,7 @@ sub htmlify_pods {
my $depth = @rootdirs + @dirs;
my %opts = ( infile => $infile,
outfile => $tmpfile,
- podpath => $podpath,
+ ( defined($podpath) ? (podpath => $podpath) : ()),
podroot => $podroot,
index => 1,
depth => $depth,
@@ -3427,8 +3405,8 @@ sub htmlify_pods {
} or $self->log_warn("[$htmltool] pod2html (" .
join(", ", map { "q{$_} => q{$opts{$_}}" } (keys %opts)) . ") failed: $@");
} else {
- my $path2root = join( '/', ('..') x (@rootdirs+@dirs) );
- my $fh = IO::File->new($infile) or die "Can't read $infile: $!";
+ my $path2root = File::Spec->catdir((File::Spec->updir) x @dirs);
+ open(my $fh, '<', $infile) or die "Can't read $infile: $!";
my $abstract = Module::Build::PodParser->new(fh => $fh)->get_abstract();
my $title = join( '::', (@dirs, $name) );
@@ -3436,11 +3414,11 @@ sub htmlify_pods {
my @opts = (
"--title=$title",
- "--podpath=$podpath",
+ ( defined($podpath) ? "--podpath=$podpath" : ()),
"--infile=$infile",
"--outfile=$tmpfile",
"--podroot=$podroot",
- "--htmlroot=$path2root",
+ ($path2root ? "--htmlroot=$path2root" : ()),
);
unless ( eval{Pod::Html->VERSION(1.12)} ) {
@@ -3467,9 +3445,9 @@ sub htmlify_pods {
$errors++;
next POD;
}
- my $fh = IO::File->new($tmpfile) or die "Can't read $tmpfile: $!";
+ open(my $fh, '<', $tmpfile) or die "Can't read $tmpfile: $!";
my $html = join('',<$fh>);
- $fh->close;
+ close $fh;
if (!$self->_is_ActivePerl) {
# These fixups are already done by AP::DT:P:pod2html
# The output from pod2html is NOT XHTML!
@@ -3484,9 +3462,9 @@ sub htmlify_pods {
# Fixup links that point to our temp blib
$html =~ s/\Q$blibdir\E//g;
- $fh = IO::File->new(">$outfile") or die "Can't write $outfile: $!";
+ open($fh, '>', $outfile) or die "Can't write $outfile: $!";
print $fh $html;
- $fh->close;
+ close $fh;
unlink($tmpfile);
}
@@ -3574,7 +3552,7 @@ sub ACTION_install {
my ($self) = @_;
require ExtUtils::Install;
$self->depends_on('build');
- # RT#63003 suggest that odd cirmstances that we might wind up
+ # RT#63003 suggest that odd circumstances that we might wind up
# in a different directory than we started, so wrap with _do_in_dir to
# ensure we get back to where we started; hope this fixes it!
$self->_do_in_dir( ".", sub {
@@ -3685,10 +3663,6 @@ sub ACTION_installdeps {
}
}
- if ( ! -x $command ) {
- die "cpan_client '$command' is not executable\n";
- }
-
$self->do_system($command, @opts, @install);
}
@@ -3859,12 +3833,12 @@ sub _add_to_manifest {
my $mode = (stat $manifest)[2];
chmod($mode | oct(222), $manifest) or die "Can't make $manifest writable: $!";
- my $fh = IO::File->new("< $manifest") or die "Can't read $manifest: $!";
+ open(my $fh, '<', $manifest) or die "Can't read $manifest: $!";
my $last_line = (<$fh>)[-1] || "\n";
my $has_newline = $last_line =~ /\n$/;
- $fh->close;
+ close $fh;
- $fh = IO::File->new(">> $manifest") or die "Can't write to $manifest: $!";
+ open($fh, '>>', $manifest) or die "Can't write to $manifest: $!";
print $fh "\n" unless $has_newline;
print $fh map "$_\n", @$lines;
close $fh;
@@ -3960,7 +3934,7 @@ HERE
$self->delete_filetree('LICENSE');
- my $fh = IO::File->new('> LICENSE')
+ open(my $fh, '>', 'LICENSE')
or die "Can't write LICENSE file: $!";
print $fh $license->fulltext;
close $fh;
@@ -3992,8 +3966,7 @@ EOF
} elsif ( eval {require Pod::Text; 1} ) {
$self->log_info("Creating README using Pod::Text\n");
- my $fh = IO::File->new('> README');
- if ( defined($fh) ) {
+ if ( open(my $fh, '>', 'README') ) {
local $^W = 0;
no strict "refs";
@@ -4014,7 +3987,7 @@ EOF
Pod::Text::pod2text( $docfile, $fh );
- $fh->close;
+ close $fh;
} else {
$self->log_warn(
"Cannot create 'README' file: Can't open file for writing\n" );
@@ -4094,9 +4067,9 @@ sub ACTION_disttest {
$self->run_perl_script('Build.PL') # XXX Should this be run w/ --nouse-rcfile
or die "Error executing 'Build.PL' in dist directory: $!";
- $self->run_perl_script('Build')
- or die "Error executing 'Build' in dist directory: $!";
- $self->run_perl_script('Build', [], ['test'])
+ $self->run_perl_script($self->build_script)
+ or die "Error executing $self->build_script in dist directory: $!";
+ $self->run_perl_script($self->build_script, [], ['test'])
or die "Error executing 'Build test' in dist directory";
});
}
@@ -4110,9 +4083,9 @@ sub ACTION_distinstall {
sub {
$self->run_perl_script('Build.PL')
or die "Error executing 'Build.PL' in dist directory: $!";
- $self->run_perl_script('Build')
- or die "Error executing 'Build' in dist directory: $!";
- $self->run_perl_script('Build', [], ['install'])
+ $self->run_perl_script($self->build_script)
+ or die "Error executing $self->build_script in dist directory: $!";
+ $self->run_perl_script($self->build_script, [], ['install'])
or die "Error executing 'Build install' in dist directory";
}
);
@@ -4208,17 +4181,17 @@ sub _append_maniskip {
my $skip = shift;
my $file = shift || 'MANIFEST.SKIP';
return unless defined $skip && length $skip;
- my $fh = IO::File->new(">> $file")
+ open(my $fh, '>>', $file)
or die "Can't open $file: $!";
print $fh "$skip\n";
- $fh->close();
+ close $fh;
}
sub _write_default_maniskip {
my $self = shift;
my $file = shift || 'MANIFEST.SKIP';
- my $fh = IO::File->new("> $file")
+ open(my $fh, '>', $file)
or die "Can't open $file: $!";
my $content = $self->_eumanifest_has_include ? "#!include_default\n"
@@ -4244,6 +4217,8 @@ EOF
$content .= '\b'.$self->dist_name.'-[\d\.\_]+'."\n";
print $fh $content;
+
+ close $fh;
return;
}
@@ -4413,8 +4388,8 @@ BEGIN { *scripts = \&script_files; }
perl => 'Perl_5',
apache => 'Apache_2_0',
apache_1_1 => 'Apache_1_1',
- artistic => 'Artistic_1_0',
- artistic_2 => 'Artistic_2_0',
+ artistic => 'Artistic_1',
+ artistic_2 => 'Artistic_2',
lgpl => 'LGPL_2_1',
lgpl2 => 'LGPL_2_1',
lgpl3 => 'LGPL_3_0',
@@ -4424,9 +4399,9 @@ BEGIN { *scripts = \&script_files; }
gpl3 => 'GPL_3',
mit => 'MIT',
mozilla => 'Mozilla_1_1',
+ restrictive => 'Restricted',
open_source => undef,
unrestricted => undef,
- restrictive => undef,
unknown => undef,
);
@@ -4447,9 +4422,9 @@ BEGIN { *scripts = \&script_files; }
gpl3 => 'http://opensource.org/licenses/gpl-3.0.html',
mit => 'http://opensource.org/licenses/mit-license.php',
mozilla => 'http://opensource.org/licenses/mozilla1.1.php',
+ restrictive => undef,
open_source => undef,
unrestricted => undef,
- restrictive => undef,
unknown => undef,
);
sub valid_licenses {
@@ -4460,21 +4435,30 @@ BEGIN { *scripts = \&script_files; }
}
}
-# use mapping or license name directly
-sub _software_license_object {
- my ($self) = @_;
- return unless defined( my $license = $self->license );
-
- my $class;
+sub _software_license_class {
+ my ($self, $license) = @_;
+ if ($self->valid_licenses->{$license} && eval { require Software::LicenseUtils; Software::LicenseUtils->VERSION(0.103009) }) {
+ my ($class) = Software::LicenseUtils->guess_license_from_meta_key($license, 1);
+ eval "require $class";
+ #die $class;
+ return $class;
+ }
LICENSE: for my $l ( $self->valid_licenses->{ $license }, $license ) {
next unless defined $l;
my $trial = "Software::License::" . $l;
if ( eval "require Software::License; Software::License->VERSION(0.014); require $trial; 1" ) {
- $class = $trial;
- last LICENSE;
+ return $trial;
}
}
- return unless defined $class;
+ return;
+}
+
+# use mapping or license name directly
+sub _software_license_object {
+ my ($self) = @_;
+ return unless defined( my $license = $self->license );
+
+ my $class = $self->_software_license_class($license) or return;
# Software::License requires a 'holder' argument
my $author = join( " & ", @{ $self->dist_author }) || 'unknown';
@@ -4568,7 +4552,7 @@ sub _get_meta_object {
auto => $args{auto},
);
$data->{dynamic_config} = $args{dynamic} if defined $args{dynamic};
- $meta = CPAN::Meta->create( $data );
+ $meta = CPAN::Meta->create($data);
};
if ($@ && ! $args{quiet}) {
$self->log_warn(
@@ -4624,6 +4608,16 @@ sub normalize_version {
return $version;
}
+my %prereq_map = (
+ requires => [ qw/runtime requires/],
+ configure_requires => [qw/configure requires/],
+ build_requires => [ qw/build requires/ ],
+ test_requires => [ qw/test requires/ ],
+ test_recommends => [ qw/test recommends/ ],
+ recommends => [ qw/runtime recommends/ ],
+ conflicts => [ qw/runtime conflicts/ ],
+);
+
sub _normalize_prereqs {
my ($self) = @_;
my $p = $self->{properties};
@@ -4631,46 +4625,98 @@ sub _normalize_prereqs {
# copy prereq data structures so we can modify them before writing to META
my %prereq_types;
for my $type ( 'configure_requires', @{$self->prereq_action_types} ) {
- if (exists $p->{$type}) {
+ if (exists $p->{$type} and keys %{ $p->{$type} }) {
+ my ($phase, $relation) = @{ $prereq_map{$type} };
for my $mod ( keys %{ $p->{$type} } ) {
- $prereq_types{$type}{$mod} =
- $self->normalize_version($p->{$type}{$mod});
+ $prereq_types{$phase}{$relation}{$mod} = $self->normalize_version($p->{$type}{$mod});
}
}
}
return \%prereq_types;
}
-# wrapper around old prepare_metadata API;
-sub get_metadata {
- my ($self, %args) = @_;
- my $metadata = {};
- $self->prepare_metadata( $metadata, undef, \%args );
- return $metadata;
+sub _get_license {
+ my $self = shift;
+
+ my $license = $self->license;
+ my ($meta_license, $meta_license_url);
+
+ my $valid_licenses = $self->valid_licenses();
+ if ( my $sl = $self->_software_license_object ) {
+ $meta_license = $sl->meta2_name;
+ $meta_license_url = $sl->url;
+ }
+ elsif ( exists $valid_licenses->{$license} ) {
+ $meta_license = $valid_licenses->{$license} ? lc $valid_licenses->{$license} : $license;
+ $meta_license_url = $self->_license_url( $license );
+ }
+ else {
+ $self->log_warn( "Can not determine license type for '" . $self->license
+ . "'\nSetting META license field to 'unknown'.\n");
+ $meta_license = 'unknown';
+ }
+ return ($meta_license, $meta_license_url);
}
-# To preserve compatibility with old API, $node *must* be a hashref
-# passed in to prepare_metadata. $keys is an arrayref holding a
-# list of keys -- it's use is optional and generally no longer needed
-# but kept for back compatibility. $args is an optional parameter to
-# support the new 'fatal' toggle
+my %keep = map { $_ => 1 } qw/keywords dynamic_config provides no_index name version abstract/;
+my %ignore = map { $_ => 1 } qw/distribution_type/;
+my %reject = map { $_ => 1 } qw/private author license requires recommends build_requires configure_requires conflicts/;
-sub prepare_metadata {
- my ($self, $node, $keys, $args) = @_;
- unless ( ref $node eq 'HASH' ) {
- croak "prepare_metadata() requires a hashref argument to hold output\n";
+sub _upconvert_resources {
+ my ($input) = @_;
+ my %output;
+ for my $key (keys %{$input}) {
+ my $out_key = $key =~ /^\p{Lu}/ ? "x_\l$key" : $key;
+ if ($key eq 'repository') {
+ my $name = $input->{$key} =~ m{ \A http s? :// .* (<! \.git ) \z }xms ? 'web' : 'url';
+ $output{$out_key} = { $name => $input->{$key} };
+ }
+ elsif ($key eq 'bugtracker') {
+ $output{$out_key} = { web => $input->{$key} }
+ }
+ else {
+ $output{$out_key} = $input->{$key};
+ }
}
- my $fatal = $args->{fatal} || 0;
- my $p = $self->{properties};
+ return \%output
+}
+my %custom = (
+ resources => \&_upconvert_resources,
+);
- $self->auto_config_requires if $args->{auto};
+sub _upconvert_metapiece {
+ my ($input, $type) = @_;
+ return $input if exists $input->{'meta-spec'} && $input->{'meta-spec'}{version} == 2;
- # A little helper sub
- my $add_node = sub {
- my ($name, $val) = @_;
- $node->{$name} = $val;
- push @$keys, $name if $keys;
- };
+ my %ret;
+ for my $key (keys %{$input}) {
+ if ($keep{$key}) {
+ $ret{$key} = $input->{$key};
+ }
+ elsif ($ignore{$key}) {
+ next;
+ }
+ elsif ($reject{$key}) {
+ croak "Can't $type $key, please use another mechanism";
+ }
+ elsif (my $converter = $custom{$key}) {
+ $ret{$key} = $converter->($input->{$key});
+ }
+ else {
+ my $out_key = $key =~ / \A x_ /xi ? $key : "x_$key";
+ $ret{$out_key} = $input->{$key};
+ }
+ }
+ return \%ret;
+}
+
+sub get_metadata {
+ my ($self, %args) = @_;
+
+ my $fatal = $args{fatal} || 0;
+ my $p = $self->{properties};
+
+ $self->auto_config_requires if $args{auto};
# validate required fields
foreach my $f (qw(dist_name dist_version dist_author dist_abstract license)) {
@@ -4686,80 +4732,61 @@ sub prepare_metadata {
}
}
+ my %metadata = (
+ name => $self->dist_name,
+ version => $self->normalize_version($self->dist_version),
+ author => $self->dist_author,
+ abstract => $self->dist_abstract,
+ generated_by => "Module::Build version $Module::Build::VERSION",
+ 'meta-spec' => {
+ version => '2',
+ url => 'http://search.cpan.org/perldoc?CPAN::Meta::Spec',
+ },
+ dynamic_config => exists $p->{dynamic_config} ? $p->{dynamic_config} : 1,
+ release_status => $self->release_status,
+ );
- # add dist_* fields
- foreach my $f (qw(dist_name dist_version dist_author dist_abstract)) {
- (my $name = $f) =~ s/^dist_//;
- $add_node->($name, $self->$f());
- }
-
- # normalize version
- $node->{version} = $self->normalize_version($node->{version});
-
- # validate license information
- my $license = $self->license;
- my ($meta_license, $meta_license_url);
-
- # XXX this is still meta spec version 1 stuff
-
- # if Software::License::* exists, then we can use it to get normalized name
- # for META files
-
- if ( my $sl = $self->_software_license_object ) {
- $meta_license = $sl->meta_name;
- $meta_license_url = $sl->url;
- }
- elsif ( exists $self->valid_licenses()->{$license} ) {
- $meta_license = $license;
- $meta_license_url = $self->_license_url( $license );
- }
- else {
- # if we didn't find a license from a Software::License class,
- # then treat it as unknown
- $self->log_warn( "Can not determine license type for '" . $self->license
- . "'\nSetting META license field to 'unknown'.\n");
- $meta_license = 'unknown';
- }
-
- $node->{license} = $meta_license;
- $node->{resources}{license} = $meta_license_url if defined $meta_license_url;
+ my ($meta_license, $meta_license_url) = $self->_get_license;
+ $metadata{license} = [ $meta_license ];
+ $metadata{resources}{license} = [ $meta_license_url ] if defined $meta_license_url;
- # add prerequisite data
- my $prereqs = $self->_normalize_prereqs;
- for my $t ( keys %$prereqs ) {
- $add_node->($t, $prereqs->{$t});
- }
+ $metadata{prereqs} = $self->_normalize_prereqs;
- if (exists $p->{dynamic_config}) {
- $add_node->('dynamic_config', $p->{dynamic_config});
- }
- my $pkgs = eval { $self->find_dist_packages };
- if ($@) {
+ if (exists $p->{no_index}) {
+ $metadata{no_index} = $p->{no_index};
+ } elsif (my $pkgs = eval { $self->find_dist_packages }) {
+ $metadata{provides} = $pkgs if %$pkgs;
+ } else {
$self->log_warn("$@\nWARNING: Possible missing or corrupt 'MANIFEST' file.\n" .
"Nothing to enter for 'provides' field in metafile.\n");
- } else {
- $node->{provides} = $pkgs if %$pkgs;
}
-;
- if (exists $p->{no_index}) {
- $add_node->('no_index', $p->{no_index});
+
+ my $meta_add = _upconvert_metapiece($self->meta_add, 'add');
+ while (my($k, $v) = each %{$meta_add} ) {
+ $metadata{$k} = $v;
}
- $add_node->('generated_by', "Module::Build version $Module::Build::VERSION");
+ my $meta_merge = _upconvert_metapiece($self->meta_merge, 'merge');
+ while (my($k, $v) = each %{$meta_merge} ) {
+ $self->_hash_merge(\%metadata, $k, $v);
+ }
- $add_node->('meta-spec',
- {version => '1.4',
- url => 'http://module-build.sourceforge.net/META-spec-v1.4.html',
- });
+ return \%metadata;
+}
- while (my($k, $v) = each %{$self->meta_add}) {
- $add_node->($k, $v);
- }
+# To preserve compatibility with old API, $node *must* be a hashref
+# passed in to prepare_metadata. $keys is an arrayref holding a
+# list of keys -- it's use is optional and generally no longer needed
+# but kept for back compatibility. $args is an optional parameter to
+# support the new 'fatal' toggle
- while (my($k, $v) = each %{$self->meta_merge}) {
- $self->_hash_merge($node, $k, $v);
+sub prepare_metadata {
+ my ($self, $node, $keys, $args) = @_;
+ unless ( ref $node eq 'HASH' ) {
+ croak "prepare_metadata() requires a hashref argument to hold output\n";
}
-
+ croak 'Keys argument to prepare_metadata is no longer supported' if $keys;
+ %{$node} = %{ $self->get_meta(%{$args}) };
return $node;
}
@@ -5321,7 +5348,7 @@ sub have_c_compiler {
return $p->{_have_c_compiler} if defined $p->{_have_c_compiler};
$self->log_verbose("Checking if compiler tools configured... ");
- my $b = eval { $self->cbuilder };
+ my $b = $self->cbuilder;
my $have = $b && eval { $b->have_compiler };
$self->log_verbose($have ? "ok.\n" : "failed.\n");
return $p->{_have_c_compiler} = $have;
@@ -5407,7 +5434,7 @@ sub compile_xs {
@typemaps, $file);
$self->log_info("@command\n");
- my $fh = IO::File->new("> $args{outfile}") or die "Couldn't write $args{outfile}: $!";
+ open(my $fh, '>', $args{outfile}) or die "Couldn't write $args{outfile}: $!";
print {$fh} $self->_backticks(@command);
close $fh;
}
@@ -5493,17 +5520,19 @@ sub _infer_xs_spec {
$spec{archdir} = File::Spec->catdir($self->blib, 'arch', 'auto',
@d, $file_base);
- $spec{bs_file} = File::Spec->catfile($spec{archdir}, "${file_base}.bs");
-
- $spec{lib_file} = File::Spec->catfile($spec{archdir},
- "${file_base}.".$cf->get('dlext'));
-
$spec{c_file} = File::Spec->catfile( $spec{src_dir},
"${file_base}.c" );
$spec{obj_file} = File::Spec->catfile( $spec{src_dir},
"${file_base}".$cf->get('obj_ext') );
+ require DynaLoader;
+ my $modfname = defined &DynaLoader::mod2fname ? DynaLoader::mod2fname([@d, $file_base]) : $file_base;
+
+ $spec{bs_file} = File::Spec->catfile($spec{archdir}, "$modfname.bs");
+
+ $spec{lib_file} = File::Spec->catfile($spec{archdir}, "$modfname.".$cf->get('dlext'));
+
return \%spec;
}
@@ -5536,7 +5565,7 @@ sub process_xs {
require ExtUtils::Mkbootstrap;
$self->log_info("ExtUtils::Mkbootstrap::Mkbootstrap('$spec->{bs_file}')\n");
ExtUtils::Mkbootstrap::Mkbootstrap($spec->{bs_file}); # Original had $BSLOADLIBS - what's that?
- {my $fh = IO::File->new(">> $spec->{bs_file}")} # create
+ open(my $fh, '>>', $spec->{bs_file}); # create
utime((time)x2, $spec->{bs_file}); # touch
}
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Bundling.pod b/Master/tlpkg/tlperl/lib/Module/Build/Bundling.pod
new file mode 100644
index 00000000000..5e7b9f98075
--- /dev/null
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Bundling.pod
@@ -0,0 +1,147 @@
+=head1 NAME
+
+Module::Build::Bundling - How to bundle Module::Build with a distribution
+
+=head1 SYNOPSIS
+
+ # Build.PL
+ use inc::latest 'Module::Build';
+
+ Module::Build->new(
+ module_name => 'Foo::Bar',
+ license => 'perl',
+ )->create_build_script;
+
+=head1 DESCRIPTION
+
+B<WARNING -- THIS IS AN EXPERIMENTAL FEATURE>
+
+In order to install a distribution using Module::Build, users must
+have Module::Build available on their systems. There are two ways
+to do this. The first way is to include Module::Build in the
+C<configure_requires> metadata field. This field is supported by
+recent versions L<CPAN> and L<CPANPLUS> and is a standard feature
+in the Perl core as of Perl 5.10.1. Module::Build now adds itself
+to C<configure_requires> by default.
+
+The second way supports older Perls that have not upgraded CPAN or
+CPANPLUS and involves bundling an entire copy of Module::Build
+into the distribution's C<inc/> directory. This is the same approach
+used by L<Module::Install>, a modern wrapper around ExtUtils::MakeMaker
+for Makefile.PL based distributions.
+
+The "trick" to making this work for Module::Build is making sure the
+highest version Module::Build is used, whether this is in C<inc/> or
+already installed on the user's system. This ensures that all necessary
+features are available as well as any new bug fixes. This is done using
+the new L<inc::latest> module.
+
+A "normal" Build.PL looks like this (with only the minimum required
+fields):
+
+ use Module::Build;
+
+ Module::Build->new(
+ module_name => 'Foo::Bar',
+ license => 'perl',
+ )->create_build_script;
+
+A "bundling" Build.PL replaces the initial "use" line with a nearly
+transparent replacement:
+
+ use inc::latest 'Module::Build';
+
+ Module::Build->new(
+ module_name => 'Foo::Bar',
+ license => 'perl',
+ )->create_build_script;
+
+For I<authors>, when "Build dist" is run, Module::Build will be
+automatically bundled into C<inc> according to the rules for
+L<inc::latest>.
+
+For I<users>, inc::latest will load the latest Module::Build, whether
+installed or bundled in C<inc/>.
+
+=head1 BUNDLING OTHER CONFIGURATION DEPENDENCIES
+
+The same approach works for other configuration dependencies -- modules
+that I<must> be available for Build.PL to run. All other dependencies can
+be specified as usual in the Build.PL and CPAN or CPANPLUS will install
+them after Build.PL finishes.
+
+For example, to bundle the L<Devel::AssertOS::Unix> module (which ensures a
+"Unix-like" operating system), one could do this:
+
+ use inc::latest 'Devel::AssertOS::Unix';
+ use inc::latest 'Module::Build';
+
+ Module::Build->new(
+ module_name => 'Foo::Bar',
+ license => 'perl',
+ )->create_build_script;
+
+The C<inc::latest> module creates bundled directories based on the packlist
+file of an installed distribution. Even though C<inc::latest> takes module
+name arguments, it is better to think of it as bundling and making
+available entire I<distributions>. When a module is loaded through
+C<inc::latest>, it looks in all bundled distributions in C<inc/> for a
+newer module than can be found in the existing C<@INC> array.
+
+Thus, the module-name provided should usually be the "top-level" module
+name of a distribution, though this is not strictly required. For example,
+L<Module::Build> has a number of heuristics to map module names to
+packlists, allowing users to do things like this:
+
+ use inc::latest 'Devel::AssertOS::Unix';
+
+even though Devel::AssertOS::Unix is contained within the Devel-CheckOS
+distribution.
+
+At the current time, packlists are required. Thus, bundling dual-core
+modules, I<including Module::Build>, may require a 'forced install' over
+versions in the latest version of perl in order to create the necessary
+packlist for bundling. This limitation will hopefully be addressed in a
+future version of Module::Build.
+
+=head2 WARNING -- How to Manage Dependency Chains
+
+Before bundling a distribution you must ensure that all prerequisites are
+also bundled and load in the correct order. For Module::Build itself, this
+should not be necessary, but it is necessary for any other distribution.
+(A future release of Module::Build will hopefully address this deficiency.)
+
+For example, if you need C<Wibble>, but C<Wibble> depends on C<Wobble>,
+your Build.PL might look like this:
+
+ use inc::latest 'Wobble';
+ use inc::latest 'Wibble';
+ use inc::latest 'Module::Build';
+
+ Module::Build->new(
+ module_name => 'Foo::Bar',
+ license => 'perl',
+ )->create_build_script;
+
+Authors are strongly suggested to limit the bundling of additional
+dependencies if at all possible and to carefully test their distribution
+tarballs on older versions of Perl before uploading to CPAN.
+
+=head1 AUTHOR
+
+David Golden <dagolden@cpan.org>
+
+Development questions, bug reports, and patches should be sent to the
+Module-Build mailing list at <module-build@perl.org>.
+
+Bug reports are also welcome at
+<http://rt.cpan.org/NoAuth/Bugs.html?Dist=Module-Build>.
+
+=head1 SEE ALSO
+
+perl(1), L<inc::latest>, L<Module::Build>(3), L<Module::Build::API>(3),
+L<Module::Build::Cookbook>(3),
+
+=cut
+
+# vim: tw=75
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Compat.pm b/Master/tlpkg/tlperl/lib/Module/Build/Compat.pm
index 79499a6efd9..11bbf11b4a9 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/Compat.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Compat.pm
@@ -2,11 +2,10 @@ package Module::Build::Compat;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
use File::Basename ();
use File::Spec;
-use IO::File;
use Config;
use Module::Build;
use Module::Build::ModuleInfo;
@@ -123,7 +122,7 @@ HERE
$args{file} ||= 'Makefile.PL';
local $build->{properties}{quiet} = 1;
$build->delete_filetree($args{file});
- $fh = IO::File->new("> $args{file}") or die "Can't write $args{file}: $!";
+ open($fh, '>', "$args{file}") or die "Can't write $args{file}: $!";
}
print {$fh} "# Note: this file was auto-generated by ", __PACKAGE__, " version $VERSION\n";
@@ -406,7 +405,7 @@ EOF
sub fake_prereqs {
my $file = File::Spec->catfile('_build', 'prereqs');
- my $fh = IO::File->new("< $file") or die "Can't read $file: $!";
+ open(my $fh, '<', "$file") or die "Can't read $file: $!";
my $prereqs = eval do {local $/; <$fh>};
close $fh;
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Config.pm b/Master/tlpkg/tlperl/lib/Module/Build/Config.pm
index 88a3ff31579..69bec80543a 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/Config.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Config.pm
@@ -2,7 +2,7 @@ package Module::Build::Config;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
use Config;
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/ConfigData.pm b/Master/tlpkg/tlperl/lib/Module/Build/ConfigData.pm
index 85fa28d869b..ec72359cd08 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/ConfigData.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/ConfigData.pm
@@ -21,7 +21,6 @@ sub config_names { keys %$config }
sub write {
my $me = __FILE__;
- require IO::File;
# Can't use Module::Build::Dumper here because M::B is only a
# build-time prereq of this module
@@ -29,7 +28,7 @@ sub write {
my $mode_orig = (stat $me)[2] & 07777;
chmod($mode_orig | 0222, $me); # Make it writeable
- my $fh = IO::File->new($me, 'r+') or die "Can't rewrite $me: $!";
+ open(my $fh, '+<', $me) or die "Can't rewrite $me: $!";
seek($fh, 0, 0);
while (<$fh>) {
last if /^__DATA__$/;
@@ -38,11 +37,11 @@ sub write {
seek($fh, tell($fh), 0);
my $data = [$config, $features, $auto_features];
- $fh->print( 'do{ my '
+ print($fh 'do{ my '
. Data::Dumper->new([$data],['x'])->Purity(1)->Dump()
. '$x; }' );
truncate($fh, tell($fh));
- $fh->close;
+ close $fh;
chmod($mode_orig, $me)
or warn "Couldn't restore permissions on $me: $!";
@@ -168,47 +167,44 @@ do{ my $x = [
{},
{},
{
- 'license_creation' => {
- 'requires' => {
- 'Software::License' => 0
- },
- 'description' => 'Create licenses automatically in distributions'
- },
- 'inc_bundling_support' => {
- 'requires' => {
- 'ExtUtils::Installed' => '1.999',
- 'ExtUtils::Install' => '1.54'
- },
- 'description' => 'Bundle Module::Build in inc/'
- },
- 'manpage_support' => {
- 'requires' => {
- 'Pod::Man' => 0
- },
- 'description' => 'Create Unix man pages'
- },
- 'PPM_support' => {
- 'requires' => {
- 'IO::File' => '1.13'
- },
- 'description' => 'Generate PPM files for distributions'
- },
'dist_authoring' => {
'requires' => {
'Archive::Tar' => '1.09'
},
+ 'description' => 'Create new distributions',
'recommends' => {
- 'Module::Signature' => '0.21',
- 'Pod::Readme' => '0.04'
- },
- 'description' => 'Create new distributions'
+ 'Pod::Readme' => '0.04',
+ 'Module::Signature' => '0.21'
+ }
},
'HTML_support' => {
'requires' => {
'Pod::Html' => 0
},
'description' => 'Create HTML documentation'
- }
+ },
+ 'manpage_support' => {
+ 'requires' => {
+ 'Pod::Man' => 0
+ },
+ 'description' => 'Create Unix man pages'
+ },
+ 'license_creation' => {
+ 'requires' => {
+ 'Software::License' => '0.103009'
+ },
+ 'description' => 'Create licenses automatically in distributions'
+ },
+ 'PPM_support' => {
+ 'description' => 'Generate PPM files for distributions'
+ },
+ 'inc_bundling_support' => {
+ 'requires' => {
+ 'ExtUtils::Installed' => '1.999',
+ 'ExtUtils::Install' => '1.54'
+ },
+ 'description' => 'Bundle Module::Build in inc/'
+ }
}
];
$x; } \ No newline at end of file
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Cookbook.pm b/Master/tlpkg/tlperl/lib/Module/Build/Cookbook.pm
index e66020cf826..08d10b3ceb2 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/Cookbook.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Cookbook.pm
@@ -1,7 +1,7 @@
package Module::Build::Cookbook;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
=head1 NAME
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Dumper.pm b/Master/tlpkg/tlperl/lib/Module/Build/Dumper.pm
index 73839c79e4d..d70a38e5ae5 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/Dumper.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Dumper.pm
@@ -1,7 +1,7 @@
package Module::Build::Dumper;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
# This is just a split-out of a wrapper function to do Data::Dumper
# stuff "the right way". See:
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/ModuleInfo.pm b/Master/tlpkg/tlperl/lib/Module/Build/ModuleInfo.pm
index b36cc388c3d..2e1483154dc 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/ModuleInfo.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/ModuleInfo.pm
@@ -4,7 +4,7 @@ package Module::Build::ModuleInfo;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
require Module::Metadata;
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Notes.pm b/Master/tlpkg/tlperl/lib/Module/Build/Notes.pm
index 04773229932..bd4a2491b2a 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/Notes.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Notes.pm
@@ -4,10 +4,9 @@ package Module::Build::Notes;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
use Data::Dumper;
-use IO::File;
use Module::Build::Dumper;
sub new {
@@ -24,9 +23,10 @@ sub new {
sub restore {
my $self = shift;
- my $fh = IO::File->new("< $self->{file}") or die "Can't read $self->{file}: $!";
+ open(my $fh, '<', $self->{file}) or die "Can't read $self->{file}: $!";
$self->{disk} = eval do {local $/; <$fh>};
die $@ if $@;
+ close $fh;
$self->{new} = {};
}
@@ -107,8 +107,9 @@ sub write {
sub _dump {
my ($self, $file, $data) = @_;
- my $fh = IO::File->new("> $file") or die "Can't create '$file': $!";
+ open(my $fh, '>', $file) or die "Can't create '$file': $!";
print {$fh} Module::Build::Dumper->_data_dump($data);
+ close $fh;
}
my $orig_template = do { local $/; <DATA> };
@@ -127,11 +128,11 @@ sub write_config_data {
# recognized for *this* source file
$template =~ s{$_\n}{} for '=begin private', '=end private';
- my $fh = IO::File->new("> $args{file}") or die "Can't create '$args{file}': $!";
+ open(my $fh, '>', $args{file}) or die "Can't create '$args{file}': $!";
print {$fh} $template;
print {$fh} "\n__DATA__\n";
print {$fh} Module::Build::Dumper->_data_dump([$args{config_data}, $args{feature}, $args{auto_features}]);
-
+ close $fh;
}
1;
@@ -188,7 +189,6 @@ sub config_names { keys %$config }
sub write {
my $me = __FILE__;
- require IO::File;
# Can't use Module::Build::Dumper here because M::B is only a
# build-time prereq of this module
@@ -196,7 +196,7 @@ sub write {
my $mode_orig = (stat $me)[2] & 07777;
chmod($mode_orig | 0222, $me); # Make it writeable
- my $fh = IO::File->new($me, 'r+') or die "Can't rewrite $me: $!";
+ open(my $fh, '+<', $me) or die "Can't rewrite $me: $!";
seek($fh, 0, 0);
while (<$fh>) {
last if /^__DATA__$/;
@@ -205,11 +205,11 @@ sub write {
seek($fh, tell($fh), 0);
my $data = [$config, $features, $auto_features];
- $fh->print( 'do{ my '
+ print($fh 'do{ my '
. Data::Dumper->new([$data],['x'])->Purity(1)->Dump()
. '$x; }' );
truncate($fh, tell($fh));
- $fh->close;
+ close $fh;
chmod($mode_orig, $me)
or warn "Couldn't restore permissions on $me: $!";
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/PPMMaker.pm b/Master/tlpkg/tlperl/lib/Module/Build/PPMMaker.pm
index 34f549576af..3ffa32ef329 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/PPMMaker.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/PPMMaker.pm
@@ -3,9 +3,8 @@ package Module::Build::PPMMaker;
use strict;
use Config;
use vars qw($VERSION);
-use IO::File;
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
# This code is mostly borrowed from ExtUtils::MM_Unix 6.10_03, with a
@@ -100,12 +99,11 @@ EOF
EOF
my $ppd_file = "$dist{name}.ppd";
- my $fh = IO::File->new(">$ppd_file")
+ open(my $fh, '>', $ppd_file)
or die "Cannot write to $ppd_file: $!";
- my $io_file_ok = eval { IO::File->VERSION(1.13); 1 };
- $fh->binmode(":utf8")
- if $io_file_ok && $fh->can('binmode') && $] >= 5.008 && $Config{useperlio};
+ binmode($fh, ":utf8")
+ if $] >= 5.008 && $Config{useperlio};
print $fh $ppd;
close $fh;
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Platform/Amiga.pm b/Master/tlpkg/tlperl/lib/Module/Build/Platform/Amiga.pm
deleted file mode 100644
index 0be3dde62ec..00000000000
--- a/Master/tlpkg/tlperl/lib/Module/Build/Platform/Amiga.pm
+++ /dev/null
@@ -1,34 +0,0 @@
-package Module::Build::Platform::Amiga;
-
-use strict;
-use vars qw($VERSION);
-$VERSION = '0.4003';
-$VERSION = eval $VERSION;
-use Module::Build::Base;
-
-use vars qw(@ISA);
-@ISA = qw(Module::Build::Base);
-
-
-1;
-__END__
-
-
-=head1 NAME
-
-Module::Build::Platform::Amiga - Builder class for Amiga platforms
-
-=head1 DESCRIPTION
-
-The sole purpose of this module is to inherit from
-C<Module::Build::Base>. Please see the L<Module::Build> for the docs.
-
-=head1 AUTHOR
-
-Ken Williams <kwilliams@cpan.org>
-
-=head1 SEE ALSO
-
-perl(1), Module::Build(3), ExtUtils::MakeMaker(3)
-
-=cut
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Platform/Default.pm b/Master/tlpkg/tlperl/lib/Module/Build/Platform/Default.pm
index 53bffc05940..8a9cf8b0a75 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/Platform/Default.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Platform/Default.pm
@@ -2,7 +2,7 @@ package Module::Build::Platform::Default;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
use Module::Build::Base;
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Platform/EBCDIC.pm b/Master/tlpkg/tlperl/lib/Module/Build/Platform/EBCDIC.pm
deleted file mode 100644
index 8c4349b5f6c..00000000000
--- a/Master/tlpkg/tlperl/lib/Module/Build/Platform/EBCDIC.pm
+++ /dev/null
@@ -1,34 +0,0 @@
-package Module::Build::Platform::EBCDIC;
-
-use strict;
-use vars qw($VERSION);
-$VERSION = '0.4003';
-$VERSION = eval $VERSION;
-use Module::Build::Base;
-
-use vars qw(@ISA);
-@ISA = qw(Module::Build::Base);
-
-
-1;
-__END__
-
-
-=head1 NAME
-
-Module::Build::Platform::EBCDIC - Builder class for EBCDIC platforms
-
-=head1 DESCRIPTION
-
-The sole purpose of this module is to inherit from
-C<Module::Build::Base>. Please see the L<Module::Build> for the docs.
-
-=head1 AUTHOR
-
-Ken Williams <kwilliams@cpan.org>
-
-=head1 SEE ALSO
-
-perl(1), Module::Build(3), ExtUtils::MakeMaker(3)
-
-=cut
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Platform/MPEiX.pm b/Master/tlpkg/tlperl/lib/Module/Build/Platform/MPEiX.pm
deleted file mode 100644
index 5688a99329d..00000000000
--- a/Master/tlpkg/tlperl/lib/Module/Build/Platform/MPEiX.pm
+++ /dev/null
@@ -1,34 +0,0 @@
-package Module::Build::Platform::MPEiX;
-
-use strict;
-use vars qw($VERSION);
-$VERSION = '0.4003';
-$VERSION = eval $VERSION;
-use Module::Build::Base;
-
-use vars qw(@ISA);
-@ISA = qw(Module::Build::Base);
-
-
-1;
-__END__
-
-
-=head1 NAME
-
-Module::Build::Platform::MPEiX - Builder class for MPEiX platforms
-
-=head1 DESCRIPTION
-
-The sole purpose of this module is to inherit from
-C<Module::Build::Base>. Please see the L<Module::Build> for the docs.
-
-=head1 AUTHOR
-
-Ken Williams <kwilliams@cpan.org>
-
-=head1 SEE ALSO
-
-perl(1), Module::Build(3), ExtUtils::MakeMaker(3)
-
-=cut
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Platform/MacOS.pm b/Master/tlpkg/tlperl/lib/Module/Build/Platform/MacOS.pm
index 8b567668529..7e12ca12fa2 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/Platform/MacOS.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Platform/MacOS.pm
@@ -2,7 +2,7 @@ package Module::Build::Platform::MacOS;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
use Module::Build::Base;
use vars qw(@ISA);
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Platform/RiscOS.pm b/Master/tlpkg/tlperl/lib/Module/Build/Platform/RiscOS.pm
deleted file mode 100644
index 6ed9d3d1c37..00000000000
--- a/Master/tlpkg/tlperl/lib/Module/Build/Platform/RiscOS.pm
+++ /dev/null
@@ -1,34 +0,0 @@
-package Module::Build::Platform::RiscOS;
-
-use strict;
-use vars qw($VERSION);
-$VERSION = '0.4003';
-$VERSION = eval $VERSION;
-use Module::Build::Base;
-
-use vars qw(@ISA);
-@ISA = qw(Module::Build::Base);
-
-
-1;
-__END__
-
-
-=head1 NAME
-
-Module::Build::Platform::RiscOS - Builder class for RiscOS platforms
-
-=head1 DESCRIPTION
-
-The sole purpose of this module is to inherit from
-C<Module::Build::Base>. Please see the L<Module::Build> for the docs.
-
-=head1 AUTHOR
-
-Ken Williams <kwilliams@cpan.org>
-
-=head1 SEE ALSO
-
-perl(1), Module::Build(3), ExtUtils::MakeMaker(3)
-
-=cut
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Platform/Unix.pm b/Master/tlpkg/tlperl/lib/Module/Build/Platform/Unix.pm
index e3d7ff5b224..ec13ebea9be 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/Platform/Unix.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Platform/Unix.pm
@@ -2,7 +2,7 @@ package Module::Build::Platform::Unix;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
use Module::Build::Base;
@@ -43,8 +43,8 @@ sub _detildefy {
my ($self, $value) = @_;
$value =~ s[^~([^/]+)?(?=/|$)] # tilde with optional username
[$1 ?
- ((getpwnam $1)[7] || "~$1") :
- ($ENV{HOME} || (getpwuid $>)[7])
+ (eval{(getpwnam $1)[7]} || "~$1") :
+ ($ENV{HOME} || eval{(getpwuid $>)[7]} || glob("~"))
]ex;
return $value;
}
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Platform/VMS.pm b/Master/tlpkg/tlperl/lib/Module/Build/Platform/VMS.pm
index 7ff7e056bdc..5b06baa5f87 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/Platform/VMS.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Platform/VMS.pm
@@ -2,7 +2,7 @@ package Module::Build::Platform::VMS;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
use Module::Build::Base;
use Config;
@@ -279,30 +279,6 @@ sub oneliner {
return "MCR $^X $oneliner";
}
-=item _infer_xs_spec
-
-Inherit the standard version but tweak the library file name to be
-something Dynaloader can find.
-
-=cut
-
-sub _infer_xs_spec {
- my $self = shift;
- my $file = shift;
-
- my $spec = $self->SUPER::_infer_xs_spec($file);
-
- # Need to create with the same name as DynaLoader will load with.
- if (defined &DynaLoader::mod2fname) {
- my $file = $$spec{module_name} . '.' . $self->{config}->get('dlext');
- $file =~ tr/:/_/;
- $file = DynaLoader::mod2fname([$file]);
- $$spec{lib_file} = File::Spec->catfile($$spec{archdir}, $file);
- }
-
- return $spec;
-}
-
=item rscan_dir
Inherit the standard version but remove dots at end of name.
@@ -427,26 +403,15 @@ sub _detildefy {
my @hdirs = File::Spec::Unix->splitdir($hdir);
my @dirs = File::Spec::Unix->splitdir($dir);
- my $newdirs;
-
- # Two cases of tilde handling
- if ($arg =~ m#^~/#) {
-
- # Simple case, just merge together
- $newdirs = File::Spec::Unix->catdir(@hdirs, @dirs);
-
- } else {
-
- # Complex case, need to add an updir - No delimiters
- my @backup = File::Spec::Unix->splitdir(File::Spec::Unix->updir);
-
- $newdirs = File::Spec::Unix->catdir(@hdirs, @backup, @dirs);
+ unless ($arg =~ m#^~/#) {
+ # There is a home directory after the tilde, but it will already
+ # be present in in @hdirs so we need to remove it by from @dirs.
+ shift @dirs;
}
+ my $newdirs = File::Spec::Unix->catdir(@hdirs, @dirs);
- # Now put the two cases back together
$arg = File::Spec::Unix->catpath($hvol, $newdirs, $file);
-
}
return $arg;
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Platform/VOS.pm b/Master/tlpkg/tlperl/lib/Module/Build/Platform/VOS.pm
index 2578e31b3be..19dfceeaf0e 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/Platform/VOS.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Platform/VOS.pm
@@ -2,7 +2,7 @@ package Module::Build::Platform::VOS;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
use Module::Build::Base;
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Platform/Windows.pm b/Master/tlpkg/tlperl/lib/Module/Build/Platform/Windows.pm
index e35e28f707f..77441774507 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/Platform/Windows.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Platform/Windows.pm
@@ -2,13 +2,12 @@ package Module::Build::Platform::Windows;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
use Config;
use File::Basename;
use File::Spec;
-use IO::File;
use Module::Build::Base;
@@ -49,7 +48,7 @@ sub ACTION_realclean {
my $null_arg = (Win32::IsWinNT()) ? '""' : '';
my $cmd = qq(start $null_arg /min "\%comspec\%" /c del "$full_progname");
- my $fh = IO::File->new(">> $basename.bat")
+ open(my $fh, '>>', "$basename.bat")
or die "Can't create $basename.bat: $!";
print $fh $cmd;
close $fh ;
@@ -137,9 +136,9 @@ EOT
my $start = $Config{startperl};
$start = "#!perl" unless $start =~ /^#!.*perl/;
- my $in = IO::File->new("< $opts{in}") or die "Can't open $opts{in}: $!";
+ open(my $in, '<', "$opts{in}") or die "Can't open $opts{in}: $!";
my @file = <$in>;
- $in->close;
+ close($in);
foreach my $line ( @file ) {
$linenum++;
@@ -164,13 +163,13 @@ EOT
}
}
- my $out = IO::File->new("> $opts{out}") or die "Can't open $opts{out}: $!";
+ open(my $out, '>', "$opts{out}") or die "Can't open $opts{out}: $!";
print $out $head;
print $out $start, ( $opts{usewarnings} ? " -w" : "" ),
"\n#line ", ($headlines+1), "\n" unless $linedone;
print $out @file[$skiplines..$#file];
print $out $tail unless $taildone;
- $out->close;
+ close($out);
return $opts{out};
}
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Platform/aix.pm b/Master/tlpkg/tlperl/lib/Module/Build/Platform/aix.pm
index 3833ceb9761..c51e1002e6b 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/Platform/aix.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Platform/aix.pm
@@ -2,7 +2,7 @@ package Module::Build::Platform::aix;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
use Module::Build::Platform::Unix;
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Platform/cygwin.pm b/Master/tlpkg/tlperl/lib/Module/Build/Platform/cygwin.pm
index 15d3e818412..19bd50db8bf 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/Platform/cygwin.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Platform/cygwin.pm
@@ -2,7 +2,7 @@ package Module::Build::Platform::cygwin;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
use Module::Build::Platform::Unix;
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Platform/darwin.pm b/Master/tlpkg/tlperl/lib/Module/Build/Platform/darwin.pm
index 45d68fdcd0a..c7e690241c2 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/Platform/darwin.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Platform/darwin.pm
@@ -2,7 +2,7 @@ package Module::Build::Platform::darwin;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
use Module::Build::Platform::Unix;
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/Platform/os2.pm b/Master/tlpkg/tlperl/lib/Module/Build/Platform/os2.pm
index 52d6e173d87..5f9ad187db8 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/Platform/os2.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/Platform/os2.pm
@@ -2,7 +2,7 @@ package Module::Build::Platform::os2;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
use Module::Build::Platform::Unix;
diff --git a/Master/tlpkg/tlperl/lib/Module/Build/PodParser.pm b/Master/tlpkg/tlperl/lib/Module/Build/PodParser.pm
index 6605fd47272..c7e83a837d3 100644
--- a/Master/tlpkg/tlperl/lib/Module/Build/PodParser.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Build/PodParser.pm
@@ -2,7 +2,7 @@ package Module::Build::PodParser;
use strict;
use vars qw($VERSION);
-$VERSION = '0.4003';
+$VERSION = '0.4205';
$VERSION = eval $VERSION;
use vars qw(@ISA);
@@ -16,7 +16,7 @@ sub new {
unless ($self->{fh}) {
die "No 'file' or 'fh' parameter given" unless $self->{file};
- $self->{fh} = IO::File->new($self->{file}) or die "Couldn't open $self->{file}: $!";
+ open($self->{fh}, '<', $self->{file}) or die "Couldn't open $self->{file}: $!";
}
return $self;
@@ -29,7 +29,7 @@ sub parse_from_filehandle {
while (<$fh>) {
next unless /^=(?!cut)/ .. /^=cut/; # in POD
# Accept Name - abstract or C<Name> - abstract
- last if ($self->{abstract}) = /^ (?: [a-z0-9:]+ | [BCIF] < [a-z0-9:]+ > ) \s+ - \s+ (.*\S) /ix;
+ last if ($self->{abstract}) = /^ (?: [a-z_0-9:]+ | [BCIF] < [a-z_0-9:]+ > ) \s+ - \s+ (.*\S) /ix;
}
my @author;
diff --git a/Master/tlpkg/tlperl/lib/Module/CoreList.pm b/Master/tlpkg/tlperl/lib/Module/CoreList.pm
index 702cfd69490..54725c87fc4 100644
--- a/Master/tlpkg/tlperl/lib/Module/CoreList.pm
+++ b/Master/tlpkg/tlperl/lib/Module/CoreList.pm
@@ -3,7 +3,8 @@ use strict;
use vars qw/$VERSION %released %version %families %upstream
%bug_tracker %deprecated %delta/;
use Module::CoreList::TieHashDelta;
-$VERSION = '3.03';
+use version;
+$VERSION = '5.20150214';
my $dumpinc = 0;
sub import {
@@ -27,7 +28,7 @@ sub first_release_raw {
my $version = shift;
my @perls = $version
- ? grep { exists $version{$_}{ $module } &&
+ ? grep { defined $version{$_}{ $module } &&
$version{$_}{ $module } ge $version } keys %version
: grep { exists $version{$_}{ $module } } keys %version;
@@ -242,7 +243,25 @@ sub changes_between {
5.019005 => '2013-10-20',
5.019006 => '2013-11-20',
5.019007 => '2013-12-20',
- 5.018002 => '2014-01-09',
+ 5.018002 => '2014-01-06',
+ 5.018003 => '2014-10-01',
+ 5.018004 => '2014-10-01',
+ 5.019008 => '2014-01-20',
+ 5.019009 => '2014-02-20',
+ 5.01901 => '2014-03-20',
+ 5.019011 => '2014-04-20',
+ 5.020000 => '2014-05-27',
+ 5.021000 => '2014-05-27',
+ 5.021001 => '2014-06-20',
+ 5.021002 => '2014-07-20',
+ 5.021003 => '2014-08-20',
+ 5.020001 => '2014-09-14',
+ 5.021004 => '2014-09-20',
+ 5.021005 => '2014-10-20',
+ 5.021006 => '2014-11-20',
+ 5.021007 => '2014-12-20',
+ 5.021008 => '2015-01-20',
+ 5.020002 => '2015-02-14',
);
for my $version ( sort { $a <=> $b } keys %released ) {
@@ -1703,6 +1722,7 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'Time::HiRes' => '1.59',
'Unicode' => '4.0.1',
'Unicode::UCD' => '0.22',
+ 'Win32' => '0.23',
'base' => '2.05',
'bigint' => '0.05',
'bignum' => '0.15',
@@ -1926,11 +1946,6 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'JPL::AutoLoader' => 1,
'JPL::Class' => 1,
'JPL::Compile' => 1,
- 'OS2::DLL' => 1,
- 'OS2::ExtAttr' => 1,
- 'OS2::PrfDB' => 1,
- 'OS2::Process' => 1,
- 'OS2::REXX' => 1,
}
},
5.008008 => {
@@ -2023,6 +2038,9 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'Math::Trig' => '1.03',
'NDBM_File' => '1.06',
'ODBM_File' => '1.06',
+ 'OS2::PrfDB' => '0.04',
+ 'OS2::Process' => '1.02',
+ 'OS2::REXX' => '1.03',
'Opcode' => '1.06',
'POSIX' => '1.09',
'PerlIO' => '1.04',
@@ -2274,6 +2292,8 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'Net::SMTP' => '2.31',
'O' => '1.01',
'ODBM_File' => '1.07',
+ 'OS2::DLL' => '1.03',
+ 'OS2::Process' => '1.03',
'Opcode' => '1.0601',
'POSIX' => '1.15',
'PerlIO' => '1.05',
@@ -3073,6 +3093,7 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'Net::POP3' => '2.29',
'Net::SMTP' => '2.31',
'ODBM_File' => '1.07',
+ 'OS2::DLL' => '1.03',
'Object::Accessor' => '0.32',
'Opcode' => '1.09',
'POSIX' => '1.13',
@@ -3627,6 +3648,8 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'NEXT' => '0.64',
'Net::Ping' => '2.36',
'O' => '1.01',
+ 'OS2::Process' => '1.03',
+ 'OS2::REXX' => '1.04',
'Object::Accessor' => '0.34',
'POSIX' => '1.17',
'Package::Constants' => '0.02',
@@ -3933,6 +3956,8 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'File::Path' => '2.08',
'IO' => '1.25_02',
'Module::CoreList' => '2.21',
+ 'OS2::DLL' => '1.04',
+ 'OS2::Process' => '1.04',
'Object::Accessor' => '0.36',
'Opcode' => '1.15',
'POSIX' => '1.18',
@@ -5243,6 +5268,7 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'Module::Load::Conditional'=> '0.40',
'Module::Metadata' => '1.000003',
'Net::Ping' => '2.38',
+ 'OS2::Process' => '1.05',
'Object::Accessor' => '0.38',
'POSIX' => '1.24',
'Params::Check' => '0.28',
@@ -5353,6 +5379,7 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'Module::CoreList' => '2.45',
'Module::Load::Conditional'=> '0.44',
'Module::Metadata' => '1.000004',
+ 'OS2::Process' => '1.06',
'Parse::CPAN::Meta' => '1.4401',
'Pod::Html' => '1.1',
'Socket' => '1.94',
@@ -5609,7 +5636,6 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'Module::CoreList' => '2.49_02',
'PerlIO::scalar' => '0.11_01',
'Time::Piece::Seconds' => undef,
- 'XSLoader::XSLoader' => '0.13',
},
removed => {
}
@@ -5848,6 +5874,7 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'Math::Complex' => '1.58',
'Math::Trig' => '1.22',
'Module::CoreList' => '2.54',
+ 'OS2::Process' => '1.07',
'Pod::Perldoc' => '3.15_06',
'Pod::Simple' => '3.18',
'Pod::Simple::BlackBox' => '3.18',
@@ -6589,7 +6616,6 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'Pod::Checker' => '1.51',
'Pod::Find' => '1.51',
'Pod::Functions' => '1.05',
- 'Pod::Functions::Functions'=> '1.05',
'Pod::Html' => '1.14',
'Pod::InputObjects' => '1.51',
'Pod::ParseUtils' => '1.51',
@@ -6812,7 +6838,6 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'IO::Socket' => '1.34',
'Module::CoreList' => '2.67',
'Pod::Functions' => '1.06',
- 'Pod::Functions::Functions'=> '1.06',
'Storable' => '2.35',
'XS::APItest' => '0.39',
'diagnostics' => '1.29',
@@ -7733,6 +7758,9 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'Module::Load' => '0.24',
'Module::Pluggable' => '4.6',
'Module::Pluggable::Object'=> '4.6',
+ 'OS2::DLL' => '1.05',
+ 'OS2::ExtAttr' => '0.03',
+ 'OS2::Process' => '1.08',
'Object::Accessor' => '0.46',
'PerlIO::scalar' => '0.16',
'Pod::Checker' => '1.60',
@@ -8059,6 +8087,22 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'Module::CoreList::Utils'=> '3.03',
},
},
+ 5.018003 => {
+ delta_from => 5.018002,
+ changed => {
+ 'Module::CoreList' => '3.12',
+ 'Module::CoreList::TieHashDelta'=> '3.12',
+ 'Module::CoreList::Utils'=> '3.12',
+ },
+ },
+ 5.018004 => {
+ delta_from => 5.018003,
+ changed => {
+ 'Module::CoreList' => '3.13',
+ 'Module::CoreList::TieHashDelta'=> '3.13',
+ 'Module::CoreList::Utils'=> '3.13',
+ },
+ },
5.019000 => {
delta_from => 5.018000,
changed => {
@@ -8307,6 +8351,7 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'Module::CoreList::Utils'=> '2.92',
'Module::Metadata' => '1.000014',
'Net::Ping' => '2.42',
+ 'OS2::Process' => '1.09',
'POSIX' => '1.33',
'Pod::Find' => '1.61',
'Pod::Html' => '1.19',
@@ -8461,7 +8506,6 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'Params::Check' => '0.38',
'Parse::CPAN::Meta' => '1.4405',
'Pod::Functions' => '1.07',
- 'Pod::Functions::Functions'=> '1.07',
'Pod::Html' => '1.2',
'Safe' => '2.37',
'Socket' => '2.010',
@@ -8627,7 +8671,6 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'Net::SMTP' => '2.32',
'PerlIO' => '1.08',
'Pod::Functions' => '1.08',
- 'Pod::Functions::Functions'=> '1.08',
'Scalar::Util' => '1.31',
'Socket' => '2.011',
'Storable' => '2.46',
@@ -9248,7 +9291,6 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'Module::CoreList::TieHashDelta'=> '3.02',
'Module::CoreList::Utils'=> '3.02',
'POSIX' => '1.37',
- 'PathTools::Cwd' => '3.45',
'PerlIO::encoding' => '0.17',
'PerlIO::via' => '0.14',
'SDBM_File' => '1.11',
@@ -9266,6 +9308,1787 @@ for my $version ( sort { $a <=> $b } keys %released ) {
removed => {
}
},
+ 5.019008 => {
+ delta_from => 5.019007,
+ changed => {
+ 'Config' => '5.019008',
+ 'DynaLoader' => '1.24',
+ 'Encode' => '2.57',
+ 'Errno' => '1.20_02',
+ 'ExtUtils::CBuilder' => '0.280213',
+ 'ExtUtils::CBuilder::Base'=> '0.280213',
+ 'ExtUtils::CBuilder::Platform::Unix'=> '0.280213',
+ 'ExtUtils::CBuilder::Platform::VMS'=> '0.280213',
+ 'ExtUtils::CBuilder::Platform::Windows'=> '0.280213',
+ 'ExtUtils::CBuilder::Platform::Windows::BCC'=> '0.280213',
+ 'ExtUtils::CBuilder::Platform::Windows::GCC'=> '0.280213',
+ 'ExtUtils::CBuilder::Platform::Windows::MSVC'=> '0.280213',
+ 'ExtUtils::CBuilder::Platform::aix'=> '0.280213',
+ 'ExtUtils::CBuilder::Platform::cygwin'=> '0.280213',
+ 'ExtUtils::CBuilder::Platform::darwin'=> '0.280213',
+ 'ExtUtils::CBuilder::Platform::dec_osf'=> '0.280213',
+ 'ExtUtils::CBuilder::Platform::os2'=> '0.280213',
+ 'ExtUtils::Command::MM' => '6.86',
+ 'ExtUtils::Liblist' => '6.86',
+ 'ExtUtils::Liblist::Kid'=> '6.86',
+ 'ExtUtils::MM' => '6.86',
+ 'ExtUtils::MM_AIX' => '6.86',
+ 'ExtUtils::MM_Any' => '6.86',
+ 'ExtUtils::MM_BeOS' => '6.86',
+ 'ExtUtils::MM_Cygwin' => '6.86',
+ 'ExtUtils::MM_DOS' => '6.86',
+ 'ExtUtils::MM_Darwin' => '6.86',
+ 'ExtUtils::MM_MacOS' => '6.86',
+ 'ExtUtils::MM_NW5' => '6.86',
+ 'ExtUtils::MM_OS2' => '6.86',
+ 'ExtUtils::MM_QNX' => '6.86',
+ 'ExtUtils::MM_UWIN' => '6.86',
+ 'ExtUtils::MM_Unix' => '6.86',
+ 'ExtUtils::MM_VMS' => '6.86',
+ 'ExtUtils::MM_VOS' => '6.86',
+ 'ExtUtils::MM_Win32' => '6.86',
+ 'ExtUtils::MM_Win95' => '6.86',
+ 'ExtUtils::MY' => '6.86',
+ 'ExtUtils::MakeMaker' => '6.86',
+ 'ExtUtils::MakeMaker::Config'=> '6.86',
+ 'ExtUtils::Mkbootstrap' => '6.86',
+ 'ExtUtils::Mksymlists' => '6.86',
+ 'ExtUtils::testlib' => '6.86',
+ 'File::Copy' => '2.29',
+ 'Hash::Util::FieldHash' => '1.14',
+ 'IO::Socket::IP' => '0.26',
+ 'IO::Socket::UNIX' => '1.26',
+ 'List::Util' => '1.36',
+ 'List::Util::XS' => '1.36',
+ 'Module::Build' => '0.4204',
+ 'Module::Build::Base' => '0.4204',
+ 'Module::Build::Compat' => '0.4204',
+ 'Module::Build::Config' => '0.4204',
+ 'Module::Build::Cookbook'=> '0.4204',
+ 'Module::Build::Dumper' => '0.4204',
+ 'Module::Build::ModuleInfo'=> '0.4204',
+ 'Module::Build::Notes' => '0.4204',
+ 'Module::Build::PPMMaker'=> '0.4204',
+ 'Module::Build::Platform::Default'=> '0.4204',
+ 'Module::Build::Platform::MacOS'=> '0.4204',
+ 'Module::Build::Platform::Unix'=> '0.4204',
+ 'Module::Build::Platform::VMS'=> '0.4204',
+ 'Module::Build::Platform::VOS'=> '0.4204',
+ 'Module::Build::Platform::Windows'=> '0.4204',
+ 'Module::Build::Platform::aix'=> '0.4204',
+ 'Module::Build::Platform::cygwin'=> '0.4204',
+ 'Module::Build::Platform::darwin'=> '0.4204',
+ 'Module::Build::Platform::os2'=> '0.4204',
+ 'Module::Build::PodParser'=> '0.4204',
+ 'Module::CoreList' => '3.04',
+ 'Module::CoreList::TieHashDelta'=> '3.04',
+ 'Module::CoreList::Utils'=> '3.04',
+ 'Module::Load' => '0.28',
+ 'Module::Load::Conditional'=> '0.60',
+ 'Net::Config' => '1.13',
+ 'Net::FTP::A' => '1.19',
+ 'POSIX' => '1.38_01',
+ 'Perl::OSType' => '1.007',
+ 'PerlIO::encoding' => '0.18',
+ 'Pod::Perldoc' => '3.21',
+ 'Pod::Perldoc::BaseTo' => '3.21',
+ 'Pod::Perldoc::GetOptsOO'=> '3.21',
+ 'Pod::Perldoc::ToANSI' => '3.21',
+ 'Pod::Perldoc::ToChecker'=> '3.21',
+ 'Pod::Perldoc::ToMan' => '3.21',
+ 'Pod::Perldoc::ToNroff' => '3.21',
+ 'Pod::Perldoc::ToPod' => '3.21',
+ 'Pod::Perldoc::ToRtf' => '3.21',
+ 'Pod::Perldoc::ToTerm' => '3.21',
+ 'Pod::Perldoc::ToText' => '3.21',
+ 'Pod::Perldoc::ToTk' => '3.21',
+ 'Pod::Perldoc::ToXml' => '3.21',
+ 'Scalar::Util' => '1.36',
+ 'Time::Piece' => '1.27',
+ 'Time::Seconds' => '1.27',
+ 'Unicode::UCD' => '0.57',
+ 'XS::APItest' => '0.59',
+ 'XSLoader' => '0.17',
+ 'base' => '2.21',
+ 'constant' => '1.31',
+ 'inc::latest' => '0.4204',
+ 'threads::shared' => '1.46',
+ 'version' => '0.9907',
+ 'version::regex' => '0.9907',
+ 'version::vpp' => '0.9907',
+ 'warnings' => '1.21',
+ },
+ removed => {
+ }
+ },
+ 5.019009 => {
+ delta_from => 5.019008,
+ changed => {
+ 'B' => '1.48',
+ 'B::Concise' => '0.992',
+ 'B::Deparse' => '1.25',
+ 'CGI' => '3.65',
+ 'CPAN::Meta::YAML' => '0.011',
+ 'Compress::Raw::Bzip2' => '2.064',
+ 'Compress::Raw::Zlib' => '2.065',
+ 'Compress::Zlib' => '2.064',
+ 'Config' => '5.019009',
+ 'Config::Perl::V' => '0.20',
+ 'Cwd' => '3.47',
+ 'Devel::Peek' => '1.16',
+ 'Digest::SHA' => '5.87',
+ 'DynaLoader' => '1.25',
+ 'English' => '1.09',
+ 'ExtUtils::CBuilder' => '0.280216',
+ 'ExtUtils::CBuilder::Base'=> '0.280216',
+ 'ExtUtils::CBuilder::Platform::Unix'=> '0.280216',
+ 'ExtUtils::CBuilder::Platform::VMS'=> '0.280216',
+ 'ExtUtils::CBuilder::Platform::Windows'=> '0.280216',
+ 'ExtUtils::CBuilder::Platform::Windows::BCC'=> '0.280216',
+ 'ExtUtils::CBuilder::Platform::Windows::GCC'=> '0.280216',
+ 'ExtUtils::CBuilder::Platform::Windows::MSVC'=> '0.280216',
+ 'ExtUtils::CBuilder::Platform::aix'=> '0.280216',
+ 'ExtUtils::CBuilder::Platform::android'=> '0.280216',
+ 'ExtUtils::CBuilder::Platform::cygwin'=> '0.280216',
+ 'ExtUtils::CBuilder::Platform::darwin'=> '0.280216',
+ 'ExtUtils::CBuilder::Platform::dec_osf'=> '0.280216',
+ 'ExtUtils::CBuilder::Platform::os2'=> '0.280216',
+ 'ExtUtils::Command::MM' => '6.88',
+ 'ExtUtils::Embed' => '1.32',
+ 'ExtUtils::Install' => '1.62',
+ 'ExtUtils::Installed' => '1.999004',
+ 'ExtUtils::Liblist' => '6.88',
+ 'ExtUtils::Liblist::Kid'=> '6.88',
+ 'ExtUtils::MM' => '6.88',
+ 'ExtUtils::MM_AIX' => '6.88',
+ 'ExtUtils::MM_Any' => '6.88',
+ 'ExtUtils::MM_BeOS' => '6.88',
+ 'ExtUtils::MM_Cygwin' => '6.88',
+ 'ExtUtils::MM_DOS' => '6.88',
+ 'ExtUtils::MM_Darwin' => '6.88',
+ 'ExtUtils::MM_MacOS' => '6.88',
+ 'ExtUtils::MM_NW5' => '6.88',
+ 'ExtUtils::MM_OS2' => '6.88',
+ 'ExtUtils::MM_QNX' => '6.88',
+ 'ExtUtils::MM_UWIN' => '6.88',
+ 'ExtUtils::MM_Unix' => '6.88',
+ 'ExtUtils::MM_VMS' => '6.88',
+ 'ExtUtils::MM_VOS' => '6.88',
+ 'ExtUtils::MM_Win32' => '6.88',
+ 'ExtUtils::MM_Win95' => '6.88',
+ 'ExtUtils::MY' => '6.88',
+ 'ExtUtils::MakeMaker' => '6.88',
+ 'ExtUtils::MakeMaker::Config'=> '6.88',
+ 'ExtUtils::Mkbootstrap' => '6.88',
+ 'ExtUtils::Mksymlists' => '6.88',
+ 'ExtUtils::Packlist' => '1.47',
+ 'ExtUtils::testlib' => '6.88',
+ 'Fatal' => '2.23',
+ 'File::Fetch' => '0.48',
+ 'File::Spec' => '3.47',
+ 'File::Spec::Cygwin' => '3.47',
+ 'File::Spec::Epoc' => '3.47',
+ 'File::Spec::Functions' => '3.47',
+ 'File::Spec::Mac' => '3.47',
+ 'File::Spec::OS2' => '3.47',
+ 'File::Spec::Unix' => '3.47',
+ 'File::Spec::VMS' => '3.47',
+ 'File::Spec::Win32' => '3.47',
+ 'HTTP::Tiny' => '0.042',
+ 'IO::Compress::Adapter::Bzip2'=> '2.064',
+ 'IO::Compress::Adapter::Deflate'=> '2.064',
+ 'IO::Compress::Adapter::Identity'=> '2.064',
+ 'IO::Compress::Base' => '2.064',
+ 'IO::Compress::Base::Common'=> '2.064',
+ 'IO::Compress::Bzip2' => '2.064',
+ 'IO::Compress::Deflate' => '2.064',
+ 'IO::Compress::Gzip' => '2.064',
+ 'IO::Compress::Gzip::Constants'=> '2.064',
+ 'IO::Compress::RawDeflate'=> '2.064',
+ 'IO::Compress::Zip' => '2.064',
+ 'IO::Compress::Zip::Constants'=> '2.064',
+ 'IO::Compress::Zlib::Constants'=> '2.064',
+ 'IO::Compress::Zlib::Extra'=> '2.064',
+ 'IO::Socket::INET' => '1.35',
+ 'IO::Socket::IP' => '0.28',
+ 'IO::Uncompress::Adapter::Bunzip2'=> '2.064',
+ 'IO::Uncompress::Adapter::Identity'=> '2.064',
+ 'IO::Uncompress::Adapter::Inflate'=> '2.064',
+ 'IO::Uncompress::AnyInflate'=> '2.064',
+ 'IO::Uncompress::AnyUncompress'=> '2.064',
+ 'IO::Uncompress::Base' => '2.064',
+ 'IO::Uncompress::Bunzip2'=> '2.064',
+ 'IO::Uncompress::Gunzip'=> '2.064',
+ 'IO::Uncompress::Inflate'=> '2.064',
+ 'IO::Uncompress::RawInflate'=> '2.064',
+ 'IO::Uncompress::Unzip' => '2.064',
+ 'IPC::Cmd' => '0.92',
+ 'List::Util' => '1.38',
+ 'List::Util::XS' => '1.38',
+ 'Locale::Codes' => '3.29',
+ 'Locale::Codes::Constants'=> '3.29',
+ 'Locale::Codes::Country'=> '3.29',
+ 'Locale::Codes::Country_Codes'=> '3.29',
+ 'Locale::Codes::Country_Retired'=> '3.29',
+ 'Locale::Codes::Currency'=> '3.29',
+ 'Locale::Codes::Currency_Codes'=> '3.29',
+ 'Locale::Codes::Currency_Retired'=> '3.29',
+ 'Locale::Codes::LangExt'=> '3.29',
+ 'Locale::Codes::LangExt_Codes'=> '3.29',
+ 'Locale::Codes::LangExt_Retired'=> '3.29',
+ 'Locale::Codes::LangFam'=> '3.29',
+ 'Locale::Codes::LangFam_Codes'=> '3.29',
+ 'Locale::Codes::LangFam_Retired'=> '3.29',
+ 'Locale::Codes::LangVar'=> '3.29',
+ 'Locale::Codes::LangVar_Codes'=> '3.29',
+ 'Locale::Codes::LangVar_Retired'=> '3.29',
+ 'Locale::Codes::Language'=> '3.29',
+ 'Locale::Codes::Language_Codes'=> '3.29',
+ 'Locale::Codes::Language_Retired'=> '3.29',
+ 'Locale::Codes::Script' => '3.29',
+ 'Locale::Codes::Script_Codes'=> '3.29',
+ 'Locale::Codes::Script_Retired'=> '3.29',
+ 'Locale::Country' => '3.29',
+ 'Locale::Currency' => '3.29',
+ 'Locale::Language' => '3.29',
+ 'Locale::Script' => '3.29',
+ 'Module::Build' => '0.4205',
+ 'Module::Build::Base' => '0.4205',
+ 'Module::Build::Compat' => '0.4205',
+ 'Module::Build::Config' => '0.4205',
+ 'Module::Build::Cookbook'=> '0.4205',
+ 'Module::Build::Dumper' => '0.4205',
+ 'Module::Build::ModuleInfo'=> '0.4205',
+ 'Module::Build::Notes' => '0.4205',
+ 'Module::Build::PPMMaker'=> '0.4205',
+ 'Module::Build::Platform::Default'=> '0.4205',
+ 'Module::Build::Platform::MacOS'=> '0.4205',
+ 'Module::Build::Platform::Unix'=> '0.4205',
+ 'Module::Build::Platform::VMS'=> '0.4205',
+ 'Module::Build::Platform::VOS'=> '0.4205',
+ 'Module::Build::Platform::Windows'=> '0.4205',
+ 'Module::Build::Platform::aix'=> '0.4205',
+ 'Module::Build::Platform::cygwin'=> '0.4205',
+ 'Module::Build::Platform::darwin'=> '0.4205',
+ 'Module::Build::Platform::os2'=> '0.4205',
+ 'Module::Build::PodParser'=> '0.4205',
+ 'Module::CoreList' => '3.06',
+ 'Module::CoreList::TieHashDelta'=> '3.06',
+ 'Module::CoreList::Utils'=> '3.06',
+ 'Module::Load' => '0.30',
+ 'Module::Load::Conditional'=> '0.62',
+ 'Net::Domain' => '2.23',
+ 'Net::FTP' => '2.79',
+ 'Net::NNTP' => '2.26',
+ 'Net::POP3' => '2.31',
+ 'Net::Ping' => '2.43',
+ 'Net::SMTP' => '2.33',
+ 'POSIX' => '1.38_02',
+ 'Parse::CPAN::Meta' => '1.4413',
+ 'Pod::Escapes' => '1.06',
+ 'Pod::Find' => '1.62',
+ 'Pod::InputObjects' => '1.62',
+ 'Pod::ParseUtils' => '1.62',
+ 'Pod::Parser' => '1.62',
+ 'Pod::Select' => '1.62',
+ 'Scalar::Util' => '1.38',
+ 'autodie' => '2.23',
+ 'autodie::exception' => '2.23',
+ 'autodie::exception::system'=> '2.23',
+ 'autodie::hints' => '2.23',
+ 'autodie::skip' => '2.23',
+ 'diagnostics' => '1.34',
+ 'feature' => '1.35',
+ 'inc::latest' => '0.4205',
+ 'locale' => '1.03',
+ 'mro' => '1.15',
+ 'threads' => '1.92',
+ 'version' => '0.9908',
+ 'version::regex' => '0.9908',
+ 'version::vpp' => '0.9908',
+ 'warnings' => '1.22',
+ },
+ removed => {
+ }
+ },
+ 5.01901 => {
+ delta_from => 5.019009,
+ changed => {
+ 'App::Cpan' => '1.62',
+ 'Attribute::Handlers' => '0.96',
+ 'B::Deparse' => '1.26',
+ 'CPAN' => '2.04',
+ 'CPAN::Bundle' => '5.5001',
+ 'CPAN::Complete' => '5.5001',
+ 'CPAN::Distribution' => '2.01',
+ 'CPAN::Distroprefs' => '6.0001',
+ 'CPAN::FirstTime' => '5.5305',
+ 'CPAN::Meta' => '2.140640',
+ 'CPAN::Meta::Converter' => '2.140640',
+ 'CPAN::Meta::Feature' => '2.140640',
+ 'CPAN::Meta::History' => '2.140640',
+ 'CPAN::Meta::Prereqs' => '2.140640',
+ 'CPAN::Meta::Spec' => '2.140640',
+ 'CPAN::Meta::Validator' => '2.140640',
+ 'CPAN::Meta::YAML' => '0.012',
+ 'CPAN::Queue' => '5.5002',
+ 'CPAN::Shell' => '5.5003',
+ 'CPAN::Tarzip' => '5.5012',
+ 'CPAN::Version' => '5.5003',
+ 'Carp' => '1.33',
+ 'Carp::Heavy' => '1.33',
+ 'Config' => '5.019010',
+ 'Data::Dumper' => '2.151',
+ 'Devel::PPPort' => '3.22',
+ 'Digest::SHA' => '5.88',
+ 'ExtUtils::Command::MM' => '6.92',
+ 'ExtUtils::Install' => '1.63',
+ 'ExtUtils::Installed' => '1.999005',
+ 'ExtUtils::Liblist' => '6.92',
+ 'ExtUtils::Liblist::Kid'=> '6.92',
+ 'ExtUtils::MM' => '6.92',
+ 'ExtUtils::MM_AIX' => '6.92',
+ 'ExtUtils::MM_Any' => '6.92',
+ 'ExtUtils::MM_BeOS' => '6.92',
+ 'ExtUtils::MM_Cygwin' => '6.92',
+ 'ExtUtils::MM_DOS' => '6.92',
+ 'ExtUtils::MM_Darwin' => '6.92',
+ 'ExtUtils::MM_MacOS' => '6.92',
+ 'ExtUtils::MM_NW5' => '6.92',
+ 'ExtUtils::MM_OS2' => '6.92',
+ 'ExtUtils::MM_QNX' => '6.92',
+ 'ExtUtils::MM_UWIN' => '6.92',
+ 'ExtUtils::MM_Unix' => '6.92',
+ 'ExtUtils::MM_VMS' => '6.92',
+ 'ExtUtils::MM_VOS' => '6.92',
+ 'ExtUtils::MM_Win32' => '6.92',
+ 'ExtUtils::MM_Win95' => '6.92',
+ 'ExtUtils::MY' => '6.92',
+ 'ExtUtils::MakeMaker' => '6.92',
+ 'ExtUtils::MakeMaker::Config'=> '6.92',
+ 'ExtUtils::Mkbootstrap' => '6.92',
+ 'ExtUtils::Mksymlists' => '6.92',
+ 'ExtUtils::Packlist' => '1.48',
+ 'ExtUtils::ParseXS' => '3.24',
+ 'ExtUtils::ParseXS::Constants'=> '3.24',
+ 'ExtUtils::ParseXS::CountLines'=> '3.24',
+ 'ExtUtils::ParseXS::Eval'=> '3.24',
+ 'ExtUtils::ParseXS::Utilities'=> '3.24',
+ 'ExtUtils::Typemaps' => '3.24',
+ 'ExtUtils::Typemaps::Cmd'=> '3.24',
+ 'ExtUtils::Typemaps::InputMap'=> '3.24',
+ 'ExtUtils::Typemaps::OutputMap'=> '3.24',
+ 'ExtUtils::Typemaps::Type'=> '3.24',
+ 'ExtUtils::testlib' => '6.92',
+ 'File::Find' => '1.27',
+ 'Filter::Simple' => '0.91',
+ 'HTTP::Tiny' => '0.043',
+ 'Hash::Util::FieldHash' => '1.15',
+ 'IO' => '1.31',
+ 'IO::Socket::IP' => '0.29',
+ 'Locale::Codes' => '3.30',
+ 'Locale::Codes::Constants'=> '3.30',
+ 'Locale::Codes::Country'=> '3.30',
+ 'Locale::Codes::Country_Codes'=> '3.30',
+ 'Locale::Codes::Country_Retired'=> '3.30',
+ 'Locale::Codes::Currency'=> '3.30',
+ 'Locale::Codes::Currency_Codes'=> '3.30',
+ 'Locale::Codes::Currency_Retired'=> '3.30',
+ 'Locale::Codes::LangExt'=> '3.30',
+ 'Locale::Codes::LangExt_Codes'=> '3.30',
+ 'Locale::Codes::LangExt_Retired'=> '3.30',
+ 'Locale::Codes::LangFam'=> '3.30',
+ 'Locale::Codes::LangFam_Codes'=> '3.30',
+ 'Locale::Codes::LangFam_Retired'=> '3.30',
+ 'Locale::Codes::LangVar'=> '3.30',
+ 'Locale::Codes::LangVar_Codes'=> '3.30',
+ 'Locale::Codes::LangVar_Retired'=> '3.30',
+ 'Locale::Codes::Language'=> '3.30',
+ 'Locale::Codes::Language_Codes'=> '3.30',
+ 'Locale::Codes::Language_Retired'=> '3.30',
+ 'Locale::Codes::Script' => '3.30',
+ 'Locale::Codes::Script_Codes'=> '3.30',
+ 'Locale::Codes::Script_Retired'=> '3.30',
+ 'Locale::Country' => '3.30',
+ 'Locale::Currency' => '3.30',
+ 'Locale::Language' => '3.30',
+ 'Locale::Script' => '3.30',
+ 'Module::CoreList' => '3.09',
+ 'Module::CoreList::TieHashDelta'=> '3.09',
+ 'Module::CoreList::Utils'=> '3.09',
+ 'Module::Load' => '0.32',
+ 'POSIX' => '1.38_03',
+ 'Parse::CPAN::Meta' => '1.4414',
+ 'Pod::Perldoc' => '3.23',
+ 'Pod::Perldoc::BaseTo' => '3.23',
+ 'Pod::Perldoc::GetOptsOO'=> '3.23',
+ 'Pod::Perldoc::ToANSI' => '3.23',
+ 'Pod::Perldoc::ToChecker'=> '3.23',
+ 'Pod::Perldoc::ToMan' => '3.23',
+ 'Pod::Perldoc::ToNroff' => '3.23',
+ 'Pod::Perldoc::ToPod' => '3.23',
+ 'Pod::Perldoc::ToRtf' => '3.23',
+ 'Pod::Perldoc::ToTerm' => '3.23',
+ 'Pod::Perldoc::ToText' => '3.23',
+ 'Pod::Perldoc::ToTk' => '3.23',
+ 'Pod::Perldoc::ToXml' => '3.23',
+ 'Thread::Queue' => '3.05',
+ 'XS::APItest' => '0.60',
+ 'XS::Typemap' => '0.13',
+ 'autouse' => '1.08',
+ 'base' => '2.22',
+ 'charnames' => '1.40',
+ 'feature' => '1.36',
+ 'mro' => '1.16',
+ 'threads' => '1.93',
+ 'warnings' => '1.23',
+ 'warnings::register' => '1.03',
+ },
+ removed => {
+ }
+ },
+ 5.019011 => {
+ delta_from => 5.01901,
+ changed => {
+ 'CPAN' => '2.05',
+ 'CPAN::Distribution' => '2.02',
+ 'CPAN::FirstTime' => '5.5306',
+ 'CPAN::Shell' => '5.5004',
+ 'Carp' => '1.3301',
+ 'Carp::Heavy' => '1.3301',
+ 'Config' => '5.019011',
+ 'ExtUtils::Command::MM' => '6.94',
+ 'ExtUtils::Install' => '1.67',
+ 'ExtUtils::Liblist' => '6.94',
+ 'ExtUtils::Liblist::Kid'=> '6.94',
+ 'ExtUtils::MM' => '6.94',
+ 'ExtUtils::MM_AIX' => '6.94',
+ 'ExtUtils::MM_Any' => '6.94',
+ 'ExtUtils::MM_BeOS' => '6.94',
+ 'ExtUtils::MM_Cygwin' => '6.94',
+ 'ExtUtils::MM_DOS' => '6.94',
+ 'ExtUtils::MM_Darwin' => '6.94',
+ 'ExtUtils::MM_MacOS' => '6.94',
+ 'ExtUtils::MM_NW5' => '6.94',
+ 'ExtUtils::MM_OS2' => '6.94',
+ 'ExtUtils::MM_QNX' => '6.94',
+ 'ExtUtils::MM_UWIN' => '6.94',
+ 'ExtUtils::MM_Unix' => '6.94',
+ 'ExtUtils::MM_VMS' => '6.94',
+ 'ExtUtils::MM_VOS' => '6.94',
+ 'ExtUtils::MM_Win32' => '6.94',
+ 'ExtUtils::MM_Win95' => '6.94',
+ 'ExtUtils::MY' => '6.94',
+ 'ExtUtils::MakeMaker' => '6.94',
+ 'ExtUtils::MakeMaker::Config'=> '6.94',
+ 'ExtUtils::Mkbootstrap' => '6.94',
+ 'ExtUtils::Mksymlists' => '6.94',
+ 'ExtUtils::testlib' => '6.94',
+ 'Module::CoreList' => '3.10',
+ 'Module::CoreList::TieHashDelta'=> '3.10',
+ 'Module::CoreList::Utils'=> '3.10',
+ 'PerlIO' => '1.09',
+ 'Storable' => '2.49',
+ 'Win32' => '0.49',
+ 'experimental' => '0.007',
+ },
+ removed => {
+ }
+ },
+ 5.020000 => {
+ delta_from => 5.019011,
+ changed => {
+ 'Config' => '5.02',
+ 'Devel::PPPort' => '3.21',
+ 'Encode' => '2.60',
+ 'Errno' => '1.20_03',
+ 'ExtUtils::Command::MM' => '6.98',
+ 'ExtUtils::Liblist' => '6.98',
+ 'ExtUtils::Liblist::Kid'=> '6.98',
+ 'ExtUtils::MM' => '6.98',
+ 'ExtUtils::MM_AIX' => '6.98',
+ 'ExtUtils::MM_Any' => '6.98',
+ 'ExtUtils::MM_BeOS' => '6.98',
+ 'ExtUtils::MM_Cygwin' => '6.98',
+ 'ExtUtils::MM_DOS' => '6.98',
+ 'ExtUtils::MM_Darwin' => '6.98',
+ 'ExtUtils::MM_MacOS' => '6.98',
+ 'ExtUtils::MM_NW5' => '6.98',
+ 'ExtUtils::MM_OS2' => '6.98',
+ 'ExtUtils::MM_QNX' => '6.98',
+ 'ExtUtils::MM_UWIN' => '6.98',
+ 'ExtUtils::MM_Unix' => '6.98',
+ 'ExtUtils::MM_VMS' => '6.98',
+ 'ExtUtils::MM_VOS' => '6.98',
+ 'ExtUtils::MM_Win32' => '6.98',
+ 'ExtUtils::MM_Win95' => '6.98',
+ 'ExtUtils::MY' => '6.98',
+ 'ExtUtils::MakeMaker' => '6.98',
+ 'ExtUtils::MakeMaker::Config'=> '6.98',
+ 'ExtUtils::Miniperl' => '1.01',
+ 'ExtUtils::Mkbootstrap' => '6.98',
+ 'ExtUtils::Mksymlists' => '6.98',
+ 'ExtUtils::testlib' => '6.98',
+ 'Pod::Functions::Functions'=> '1.08',
+ },
+ removed => {
+ }
+ },
+ 5.021000 => {
+ delta_from => 5.020000,
+ changed => {
+ 'Module::CoreList' => '5.021001',
+ 'Module::CoreList::TieHashDelta'=> '5.021001',
+ 'Module::CoreList::Utils'=> '5.021001',
+ 'feature' => '1.37',
+ },
+ removed => {
+ 'CGI' => 1,
+ 'CGI::Apache' => 1,
+ 'CGI::Carp' => 1,
+ 'CGI::Cookie' => 1,
+ 'CGI::Fast' => 1,
+ 'CGI::Pretty' => 1,
+ 'CGI::Push' => 1,
+ 'CGI::Switch' => 1,
+ 'CGI::Util' => 1,
+ 'Module::Build' => 1,
+ 'Module::Build::Base' => 1,
+ 'Module::Build::Compat' => 1,
+ 'Module::Build::Config' => 1,
+ 'Module::Build::ConfigData'=> 1,
+ 'Module::Build::Cookbook'=> 1,
+ 'Module::Build::Dumper' => 1,
+ 'Module::Build::ModuleInfo'=> 1,
+ 'Module::Build::Notes' => 1,
+ 'Module::Build::PPMMaker'=> 1,
+ 'Module::Build::Platform::Default'=> 1,
+ 'Module::Build::Platform::MacOS'=> 1,
+ 'Module::Build::Platform::Unix'=> 1,
+ 'Module::Build::Platform::VMS'=> 1,
+ 'Module::Build::Platform::VOS'=> 1,
+ 'Module::Build::Platform::Windows'=> 1,
+ 'Module::Build::Platform::aix'=> 1,
+ 'Module::Build::Platform::cygwin'=> 1,
+ 'Module::Build::Platform::darwin'=> 1,
+ 'Module::Build::Platform::os2'=> 1,
+ 'Module::Build::PodParser'=> 1,
+ 'Module::Build::Version'=> 1,
+ 'Module::Build::YAML' => 1,
+ 'Package::Constants' => 1,
+ 'Simple' => 1,
+ 'inc::latest' => 1,
+ }
+ },
+ 5.021001 => {
+ delta_from => 5.021000,
+ changed => {
+ 'App::Prove' => '3.32',
+ 'App::Prove::State' => '3.32',
+ 'App::Prove::State::Result'=> '3.32',
+ 'App::Prove::State::Result::Test'=> '3.32',
+ 'Archive::Tar' => '2.00',
+ 'Archive::Tar::Constant'=> '2.00',
+ 'Archive::Tar::File' => '2.00',
+ 'B' => '1.49',
+ 'B::Deparse' => '1.27',
+ 'Benchmark' => '1.19',
+ 'CPAN::Meta' => '2.141520',
+ 'CPAN::Meta::Converter' => '2.141520',
+ 'CPAN::Meta::Feature' => '2.141520',
+ 'CPAN::Meta::History' => '2.141520',
+ 'CPAN::Meta::Prereqs' => '2.141520',
+ 'CPAN::Meta::Spec' => '2.141520',
+ 'CPAN::Meta::Validator' => '2.141520',
+ 'Carp' => '1.34',
+ 'Carp::Heavy' => '1.34',
+ 'Config' => '5.021001',
+ 'Cwd' => '3.48',
+ 'Data::Dumper' => '2.152',
+ 'Devel::PPPort' => '3.24',
+ 'Devel::Peek' => '1.17',
+ 'Digest::SHA' => '5.92',
+ 'DynaLoader' => '1.26',
+ 'Encode' => '2.62',
+ 'Errno' => '1.20_04',
+ 'Exporter' => '5.71',
+ 'Exporter::Heavy' => '5.71',
+ 'ExtUtils::Install' => '1.68',
+ 'ExtUtils::Miniperl' => '1.02',
+ 'ExtUtils::ParseXS' => '3.25',
+ 'ExtUtils::ParseXS::Constants'=> '3.25',
+ 'ExtUtils::ParseXS::CountLines'=> '3.25',
+ 'ExtUtils::ParseXS::Eval'=> '3.25',
+ 'ExtUtils::ParseXS::Utilities'=> '3.25',
+ 'ExtUtils::Typemaps' => '3.25',
+ 'ExtUtils::Typemaps::Cmd'=> '3.25',
+ 'ExtUtils::Typemaps::InputMap'=> '3.25',
+ 'ExtUtils::Typemaps::OutputMap'=> '3.25',
+ 'ExtUtils::Typemaps::Type'=> '3.25',
+ 'Fatal' => '2.25',
+ 'File::Spec' => '3.48',
+ 'File::Spec::Cygwin' => '3.48',
+ 'File::Spec::Epoc' => '3.48',
+ 'File::Spec::Functions' => '3.48',
+ 'File::Spec::Mac' => '3.48',
+ 'File::Spec::OS2' => '3.48',
+ 'File::Spec::Unix' => '3.48',
+ 'File::Spec::VMS' => '3.48',
+ 'File::Spec::Win32' => '3.48',
+ 'Hash::Util' => '0.17',
+ 'IO' => '1.32',
+ 'List::Util' => '1.39',
+ 'List::Util::XS' => '1.39',
+ 'Locale::Codes' => '3.31',
+ 'Locale::Codes::Constants'=> '3.31',
+ 'Locale::Codes::Country'=> '3.31',
+ 'Locale::Codes::Country_Codes'=> '3.31',
+ 'Locale::Codes::Country_Retired'=> '3.31',
+ 'Locale::Codes::Currency'=> '3.31',
+ 'Locale::Codes::Currency_Codes'=> '3.31',
+ 'Locale::Codes::Currency_Retired'=> '3.31',
+ 'Locale::Codes::LangExt'=> '3.31',
+ 'Locale::Codes::LangExt_Codes'=> '3.31',
+ 'Locale::Codes::LangExt_Retired'=> '3.31',
+ 'Locale::Codes::LangFam'=> '3.31',
+ 'Locale::Codes::LangFam_Codes'=> '3.31',
+ 'Locale::Codes::LangFam_Retired'=> '3.31',
+ 'Locale::Codes::LangVar'=> '3.31',
+ 'Locale::Codes::LangVar_Codes'=> '3.31',
+ 'Locale::Codes::LangVar_Retired'=> '3.31',
+ 'Locale::Codes::Language'=> '3.31',
+ 'Locale::Codes::Language_Codes'=> '3.31',
+ 'Locale::Codes::Language_Retired'=> '3.31',
+ 'Locale::Codes::Script' => '3.31',
+ 'Locale::Codes::Script_Codes'=> '3.31',
+ 'Locale::Codes::Script_Retired'=> '3.31',
+ 'Locale::Country' => '3.31',
+ 'Locale::Currency' => '3.31',
+ 'Locale::Language' => '3.31',
+ 'Locale::Script' => '3.31',
+ 'Math::BigFloat' => '1.9994',
+ 'Math::BigInt' => '1.9995',
+ 'Math::BigInt::Calc' => '1.9994',
+ 'Math::BigInt::CalcEmu' => '1.9994',
+ 'Math::BigRat' => '0.2608',
+ 'Module::CoreList' => '5.021001_01',
+ 'Module::CoreList::TieHashDelta'=> '5.021001_01',
+ 'Module::CoreList::Utils'=> '5.021001_01',
+ 'Module::Metadata' => '1.000024',
+ 'Module::Metadata::corpus::BOMTest::UTF16BE'=> undef,
+ 'Module::Metadata::corpus::BOMTest::UTF16LE'=> undef,
+ 'Module::Metadata::corpus::BOMTest::UTF8'=> '1',
+ 'NDBM_File' => '1.13',
+ 'Net::Config' => '1.14',
+ 'Net::SMTP' => '2.34',
+ 'Net::Time' => '2.11',
+ 'OS2::Process' => '1.10',
+ 'POSIX' => '1.40',
+ 'PerlIO::encoding' => '0.19',
+ 'PerlIO::mmap' => '0.013',
+ 'PerlIO::scalar' => '0.19',
+ 'PerlIO::via' => '0.15',
+ 'Pod::Html' => '1.22',
+ 'Scalar::Util' => '1.39',
+ 'SelfLoader' => '1.22',
+ 'Socket' => '2.014',
+ 'Storable' => '2.51',
+ 'TAP::Base' => '3.32',
+ 'TAP::Formatter::Base' => '3.32',
+ 'TAP::Formatter::Color' => '3.32',
+ 'TAP::Formatter::Console'=> '3.32',
+ 'TAP::Formatter::Console::ParallelSession'=> '3.32',
+ 'TAP::Formatter::Console::Session'=> '3.32',
+ 'TAP::Formatter::File' => '3.32',
+ 'TAP::Formatter::File::Session'=> '3.32',
+ 'TAP::Formatter::Session'=> '3.32',
+ 'TAP::Harness' => '3.32',
+ 'TAP::Harness::Env' => '3.32',
+ 'TAP::Object' => '3.32',
+ 'TAP::Parser' => '3.32',
+ 'TAP::Parser::Aggregator'=> '3.32',
+ 'TAP::Parser::Grammar' => '3.32',
+ 'TAP::Parser::Iterator' => '3.32',
+ 'TAP::Parser::Iterator::Array'=> '3.32',
+ 'TAP::Parser::Iterator::Process'=> '3.32',
+ 'TAP::Parser::Iterator::Stream'=> '3.32',
+ 'TAP::Parser::IteratorFactory'=> '3.32',
+ 'TAP::Parser::Multiplexer'=> '3.32',
+ 'TAP::Parser::Result' => '3.32',
+ 'TAP::Parser::Result::Bailout'=> '3.32',
+ 'TAP::Parser::Result::Comment'=> '3.32',
+ 'TAP::Parser::Result::Plan'=> '3.32',
+ 'TAP::Parser::Result::Pragma'=> '3.32',
+ 'TAP::Parser::Result::Test'=> '3.32',
+ 'TAP::Parser::Result::Unknown'=> '3.32',
+ 'TAP::Parser::Result::Version'=> '3.32',
+ 'TAP::Parser::Result::YAML'=> '3.32',
+ 'TAP::Parser::ResultFactory'=> '3.32',
+ 'TAP::Parser::Scheduler'=> '3.32',
+ 'TAP::Parser::Scheduler::Job'=> '3.32',
+ 'TAP::Parser::Scheduler::Spinner'=> '3.32',
+ 'TAP::Parser::Source' => '3.32',
+ 'TAP::Parser::SourceHandler'=> '3.32',
+ 'TAP::Parser::SourceHandler::Executable'=> '3.32',
+ 'TAP::Parser::SourceHandler::File'=> '3.32',
+ 'TAP::Parser::SourceHandler::Handle'=> '3.32',
+ 'TAP::Parser::SourceHandler::Perl'=> '3.32',
+ 'TAP::Parser::SourceHandler::RawTAP'=> '3.32',
+ 'TAP::Parser::YAMLish::Reader'=> '3.32',
+ 'TAP::Parser::YAMLish::Writer'=> '3.32',
+ 'Term::ANSIColor' => '4.03',
+ 'Test::Builder' => '1.001003',
+ 'Test::Builder::Module' => '1.001003',
+ 'Test::Builder::Tester' => '1.23_003',
+ 'Test::Harness' => '3.32',
+ 'Test::More' => '1.001003',
+ 'Test::Simple' => '1.001003',
+ 'Tie::File' => '1.01',
+ 'Unicode' => '7.0.0',
+ 'Unicode::Collate' => '1.07',
+ 'Unicode::Normalize' => '1.18',
+ 'Unicode::UCD' => '0.58',
+ 'XS::APItest' => '0.61',
+ '_charnames' => '1.41',
+ 'autodie' => '2.25',
+ 'autodie::Scope::Guard' => '2.25',
+ 'autodie::Scope::GuardStack'=> '2.25',
+ 'autodie::ScopeUtil' => '2.25',
+ 'autodie::exception' => '2.25',
+ 'autodie::exception::system'=> '2.25',
+ 'autodie::hints' => '2.25',
+ 'autodie::skip' => '2.25',
+ 'charnames' => '1.41',
+ 'locale' => '1.04',
+ 'threads' => '1.94',
+ 'utf8' => '1.14',
+ 'warnings' => '1.24',
+ },
+ removed => {
+ }
+ },
+ 5.021002 => {
+ delta_from => 5.021001,
+ changed => {
+ 'B' => '1.50',
+ 'Config' => '5.021002',
+ 'Cwd' => '3.49',
+ 'Devel::Peek' => '1.18',
+ 'ExtUtils::Manifest' => '1.64',
+ 'File::Copy' => '2.30',
+ 'File::Spec' => '3.49',
+ 'File::Spec::Cygwin' => '3.49',
+ 'File::Spec::Epoc' => '3.49',
+ 'File::Spec::Functions' => '3.49',
+ 'File::Spec::Mac' => '3.49',
+ 'File::Spec::OS2' => '3.49',
+ 'File::Spec::Unix' => '3.49',
+ 'File::Spec::VMS' => '3.49',
+ 'File::Spec::Win32' => '3.49',
+ 'Filter::Simple' => '0.92',
+ 'Hash::Util' => '0.18',
+ 'IO' => '1.33',
+ 'IO::Socket::IP' => '0.31',
+ 'IPC::Open3' => '1.17',
+ 'Math::BigFloat' => '1.9996',
+ 'Math::BigInt' => '1.9996',
+ 'Math::BigInt::Calc' => '1.9996',
+ 'Math::BigInt::CalcEmu' => '1.9996',
+ 'Module::CoreList' => '5.021002',
+ 'Module::CoreList::TieHashDelta'=> '5.021002',
+ 'Module::CoreList::Utils'=> '5.021002',
+ 'POSIX' => '1.41',
+ 'Pod::Usage' => '1.64',
+ 'XS::APItest' => '0.62',
+ 'arybase' => '0.08',
+ 'experimental' => '0.008',
+ 'threads' => '1.95',
+ 'warnings' => '1.26',
+ },
+ removed => {
+ }
+ },
+ 5.021003 => {
+ delta_from => 5.021002,
+ changed => {
+ 'B::Debug' => '1.21',
+ 'CPAN::Meta' => '2.142060',
+ 'CPAN::Meta::Converter' => '2.142060',
+ 'CPAN::Meta::Feature' => '2.142060',
+ 'CPAN::Meta::History' => '2.142060',
+ 'CPAN::Meta::Merge' => '2.142060',
+ 'CPAN::Meta::Prereqs' => '2.142060',
+ 'CPAN::Meta::Requirements'=> '2.126',
+ 'CPAN::Meta::Spec' => '2.142060',
+ 'CPAN::Meta::Validator' => '2.142060',
+ 'Config' => '5.021003',
+ 'Config::Perl::V' => '0.22',
+ 'ExtUtils::CBuilder' => '0.280217',
+ 'ExtUtils::CBuilder::Base'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::Unix'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::VMS'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::Windows'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::Windows::BCC'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::Windows::GCC'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::Windows::MSVC'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::aix'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::android'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::cygwin'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::darwin'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::dec_osf'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::os2'=> '0.280217',
+ 'ExtUtils::Manifest' => '1.65',
+ 'HTTP::Tiny' => '0.047',
+ 'IPC::Open3' => '1.18',
+ 'Module::CoreList' => '5.021003',
+ 'Module::CoreList::TieHashDelta'=> '5.021003',
+ 'Module::CoreList::Utils'=> '5.021003',
+ 'Opcode' => '1.28',
+ 'POSIX' => '1.42',
+ 'Safe' => '2.38',
+ 'Socket' => '2.015',
+ 'Sys::Hostname' => '1.19',
+ 'UNIVERSAL' => '1.12',
+ 'XS::APItest' => '0.63',
+ 'perlfaq' => '5.0150045',
+ },
+ removed => {
+ }
+ },
+ 5.020001 => {
+ delta_from => 5.020000,
+ changed => {
+ 'Config' => '5.020001',
+ 'Config::Perl::V' => '0.22',
+ 'Cwd' => '3.48',
+ 'Exporter' => '5.71',
+ 'Exporter::Heavy' => '5.71',
+ 'ExtUtils::CBuilder' => '0.280217',
+ 'ExtUtils::CBuilder::Base'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::Unix'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::VMS'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::Windows'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::Windows::BCC'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::Windows::GCC'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::Windows::MSVC'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::aix'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::android'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::cygwin'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::darwin'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::dec_osf'=> '0.280217',
+ 'ExtUtils::CBuilder::Platform::os2'=> '0.280217',
+ 'File::Copy' => '2.30',
+ 'File::Spec' => '3.48',
+ 'File::Spec::Cygwin' => '3.48',
+ 'File::Spec::Epoc' => '3.48',
+ 'File::Spec::Functions' => '3.48',
+ 'File::Spec::Mac' => '3.48',
+ 'File::Spec::OS2' => '3.48',
+ 'File::Spec::Unix' => '3.48',
+ 'File::Spec::VMS' => '3.48',
+ 'File::Spec::Win32' => '3.48',
+ 'Module::CoreList' => '5.020001',
+ 'Module::CoreList::TieHashDelta'=> '5.020001',
+ 'Module::CoreList::Utils'=> '5.020001',
+ 'PerlIO::via' => '0.15',
+ 'Unicode::UCD' => '0.58',
+ 'XS::APItest' => '0.60_01',
+ 'utf8' => '1.13_01',
+ 'version' => '0.9909',
+ 'version::regex' => '0.9909',
+ 'version::vpp' => '0.9909',
+ },
+ removed => {
+ }
+ },
+ 5.021004 => {
+ delta_from => 5.021003,
+ changed => {
+ 'App::Prove' => '3.33',
+ 'App::Prove::State' => '3.33',
+ 'App::Prove::State::Result'=> '3.33',
+ 'App::Prove::State::Result::Test'=> '3.33',
+ 'Archive::Tar' => '2.02',
+ 'Archive::Tar::Constant'=> '2.02',
+ 'Archive::Tar::File' => '2.02',
+ 'Attribute::Handlers' => '0.97',
+ 'B' => '1.51',
+ 'B::Concise' => '0.993',
+ 'B::Deparse' => '1.28',
+ 'B::Op_private' => '5.021004',
+ 'CPAN::Meta::Requirements'=> '2.128',
+ 'Config' => '5.021004',
+ 'Cwd' => '3.50',
+ 'Data::Dumper' => '2.154',
+ 'ExtUtils::CBuilder' => '0.280219',
+ 'ExtUtils::CBuilder::Base'=> '0.280219',
+ 'ExtUtils::CBuilder::Platform::Unix'=> '0.280219',
+ 'ExtUtils::CBuilder::Platform::VMS'=> '0.280219',
+ 'ExtUtils::CBuilder::Platform::Windows'=> '0.280219',
+ 'ExtUtils::CBuilder::Platform::Windows::BCC'=> '0.280219',
+ 'ExtUtils::CBuilder::Platform::Windows::GCC'=> '0.280219',
+ 'ExtUtils::CBuilder::Platform::Windows::MSVC'=> '0.280219',
+ 'ExtUtils::CBuilder::Platform::aix'=> '0.280219',
+ 'ExtUtils::CBuilder::Platform::android'=> '0.280219',
+ 'ExtUtils::CBuilder::Platform::cygwin'=> '0.280219',
+ 'ExtUtils::CBuilder::Platform::darwin'=> '0.280219',
+ 'ExtUtils::CBuilder::Platform::dec_osf'=> '0.280219',
+ 'ExtUtils::CBuilder::Platform::os2'=> '0.280219',
+ 'ExtUtils::Install' => '2.04',
+ 'ExtUtils::Installed' => '2.04',
+ 'ExtUtils::Liblist::Kid'=> '6.98_01',
+ 'ExtUtils::Manifest' => '1.68',
+ 'ExtUtils::Packlist' => '2.04',
+ 'File::Find' => '1.28',
+ 'File::Spec' => '3.50',
+ 'File::Spec::Cygwin' => '3.50',
+ 'File::Spec::Epoc' => '3.50',
+ 'File::Spec::Functions' => '3.50',
+ 'File::Spec::Mac' => '3.50',
+ 'File::Spec::OS2' => '3.50',
+ 'File::Spec::Unix' => '3.50',
+ 'File::Spec::VMS' => '3.50',
+ 'File::Spec::Win32' => '3.50',
+ 'Getopt::Std' => '1.11',
+ 'HTTP::Tiny' => '0.049',
+ 'IO' => '1.34',
+ 'IO::Socket::IP' => '0.32',
+ 'List::Util' => '1.41',
+ 'List::Util::XS' => '1.41',
+ 'Locale::Codes' => '3.32',
+ 'Locale::Codes::Constants'=> '3.32',
+ 'Locale::Codes::Country'=> '3.32',
+ 'Locale::Codes::Country_Codes'=> '3.32',
+ 'Locale::Codes::Country_Retired'=> '3.32',
+ 'Locale::Codes::Currency'=> '3.32',
+ 'Locale::Codes::Currency_Codes'=> '3.32',
+ 'Locale::Codes::Currency_Retired'=> '3.32',
+ 'Locale::Codes::LangExt'=> '3.32',
+ 'Locale::Codes::LangExt_Codes'=> '3.32',
+ 'Locale::Codes::LangExt_Retired'=> '3.32',
+ 'Locale::Codes::LangFam'=> '3.32',
+ 'Locale::Codes::LangFam_Codes'=> '3.32',
+ 'Locale::Codes::LangFam_Retired'=> '3.32',
+ 'Locale::Codes::LangVar'=> '3.32',
+ 'Locale::Codes::LangVar_Codes'=> '3.32',
+ 'Locale::Codes::LangVar_Retired'=> '3.32',
+ 'Locale::Codes::Language'=> '3.32',
+ 'Locale::Codes::Language_Codes'=> '3.32',
+ 'Locale::Codes::Language_Retired'=> '3.32',
+ 'Locale::Codes::Script' => '3.32',
+ 'Locale::Codes::Script_Codes'=> '3.32',
+ 'Locale::Codes::Script_Retired'=> '3.32',
+ 'Locale::Country' => '3.32',
+ 'Locale::Currency' => '3.32',
+ 'Locale::Language' => '3.32',
+ 'Locale::Script' => '3.32',
+ 'Math::BigFloat' => '1.9997',
+ 'Math::BigInt' => '1.9997',
+ 'Math::BigInt::Calc' => '1.9997',
+ 'Math::BigInt::CalcEmu' => '1.9997',
+ 'Module::CoreList' => '5.20140920',
+ 'Module::CoreList::TieHashDelta'=> '5.20140920',
+ 'Module::CoreList::Utils'=> '5.20140920',
+ 'POSIX' => '1.43',
+ 'Pod::Perldoc' => '3.24',
+ 'Pod::Perldoc::BaseTo' => '3.24',
+ 'Pod::Perldoc::GetOptsOO'=> '3.24',
+ 'Pod::Perldoc::ToANSI' => '3.24',
+ 'Pod::Perldoc::ToChecker'=> '3.24',
+ 'Pod::Perldoc::ToMan' => '3.24',
+ 'Pod::Perldoc::ToNroff' => '3.24',
+ 'Pod::Perldoc::ToPod' => '3.24',
+ 'Pod::Perldoc::ToRtf' => '3.24',
+ 'Pod::Perldoc::ToTerm' => '3.24',
+ 'Pod::Perldoc::ToText' => '3.24',
+ 'Pod::Perldoc::ToTk' => '3.24',
+ 'Pod::Perldoc::ToXml' => '3.24',
+ 'Scalar::Util' => '1.41',
+ 'Sub::Util' => '1.41',
+ 'TAP::Base' => '3.33',
+ 'TAP::Formatter::Base' => '3.33',
+ 'TAP::Formatter::Color' => '3.33',
+ 'TAP::Formatter::Console'=> '3.33',
+ 'TAP::Formatter::Console::ParallelSession'=> '3.33',
+ 'TAP::Formatter::Console::Session'=> '3.33',
+ 'TAP::Formatter::File' => '3.33',
+ 'TAP::Formatter::File::Session'=> '3.33',
+ 'TAP::Formatter::Session'=> '3.33',
+ 'TAP::Harness' => '3.33',
+ 'TAP::Harness::Env' => '3.33',
+ 'TAP::Object' => '3.33',
+ 'TAP::Parser' => '3.33',
+ 'TAP::Parser::Aggregator'=> '3.33',
+ 'TAP::Parser::Grammar' => '3.33',
+ 'TAP::Parser::Iterator' => '3.33',
+ 'TAP::Parser::Iterator::Array'=> '3.33',
+ 'TAP::Parser::Iterator::Process'=> '3.33',
+ 'TAP::Parser::Iterator::Stream'=> '3.33',
+ 'TAP::Parser::IteratorFactory'=> '3.33',
+ 'TAP::Parser::Multiplexer'=> '3.33',
+ 'TAP::Parser::Result' => '3.33',
+ 'TAP::Parser::Result::Bailout'=> '3.33',
+ 'TAP::Parser::Result::Comment'=> '3.33',
+ 'TAP::Parser::Result::Plan'=> '3.33',
+ 'TAP::Parser::Result::Pragma'=> '3.33',
+ 'TAP::Parser::Result::Test'=> '3.33',
+ 'TAP::Parser::Result::Unknown'=> '3.33',
+ 'TAP::Parser::Result::Version'=> '3.33',
+ 'TAP::Parser::Result::YAML'=> '3.33',
+ 'TAP::Parser::ResultFactory'=> '3.33',
+ 'TAP::Parser::Scheduler'=> '3.33',
+ 'TAP::Parser::Scheduler::Job'=> '3.33',
+ 'TAP::Parser::Scheduler::Spinner'=> '3.33',
+ 'TAP::Parser::Source' => '3.33',
+ 'TAP::Parser::SourceHandler'=> '3.33',
+ 'TAP::Parser::SourceHandler::Executable'=> '3.33',
+ 'TAP::Parser::SourceHandler::File'=> '3.33',
+ 'TAP::Parser::SourceHandler::Handle'=> '3.33',
+ 'TAP::Parser::SourceHandler::Perl'=> '3.33',
+ 'TAP::Parser::SourceHandler::RawTAP'=> '3.33',
+ 'TAP::Parser::YAMLish::Reader'=> '3.33',
+ 'TAP::Parser::YAMLish::Writer'=> '3.33',
+ 'Term::ReadLine' => '1.15',
+ 'Test::Builder' => '1.001006',
+ 'Test::Builder::Module' => '1.001006',
+ 'Test::Builder::Tester' => '1.24',
+ 'Test::Builder::Tester::Color'=> '1.24',
+ 'Test::Harness' => '3.33',
+ 'Test::More' => '1.001006',
+ 'Test::Simple' => '1.001006',
+ 'Time::Piece' => '1.29',
+ 'Time::Seconds' => '1.29',
+ 'XS::APItest' => '0.64',
+ '_charnames' => '1.42',
+ 'attributes' => '0.23',
+ 'bigint' => '0.37',
+ 'bignum' => '0.38',
+ 'bigrat' => '0.37',
+ 'constant' => '1.32',
+ 'experimental' => '0.010',
+ 'overload' => '1.23',
+ 'threads' => '1.96',
+ 'version' => '0.9909',
+ 'version::regex' => '0.9909',
+ 'version::vpp' => '0.9909',
+ },
+ removed => {
+ }
+ },
+ 5.021005 => {
+ delta_from => 5.021004,
+ changed => {
+ 'B' => '1.52',
+ 'B::Concise' => '0.994',
+ 'B::Debug' => '1.22',
+ 'B::Deparse' => '1.29',
+ 'B::Op_private' => '5.021005',
+ 'CPAN::Meta' => '2.142690',
+ 'CPAN::Meta::Converter' => '2.142690',
+ 'CPAN::Meta::Feature' => '2.142690',
+ 'CPAN::Meta::History' => '2.142690',
+ 'CPAN::Meta::Merge' => '2.142690',
+ 'CPAN::Meta::Prereqs' => '2.142690',
+ 'CPAN::Meta::Spec' => '2.142690',
+ 'CPAN::Meta::Validator' => '2.142690',
+ 'Compress::Raw::Bzip2' => '2.066',
+ 'Compress::Raw::Zlib' => '2.066',
+ 'Compress::Zlib' => '2.066',
+ 'Config' => '5.021005',
+ 'Cwd' => '3.51',
+ 'DynaLoader' => '1.27',
+ 'Errno' => '1.21',
+ 'ExtUtils::CBuilder' => '0.280220',
+ 'ExtUtils::CBuilder::Base'=> '0.280220',
+ 'ExtUtils::CBuilder::Platform::Unix'=> '0.280220',
+ 'ExtUtils::CBuilder::Platform::VMS'=> '0.280220',
+ 'ExtUtils::CBuilder::Platform::Windows'=> '0.280220',
+ 'ExtUtils::CBuilder::Platform::Windows::BCC'=> '0.280220',
+ 'ExtUtils::CBuilder::Platform::Windows::GCC'=> '0.280220',
+ 'ExtUtils::CBuilder::Platform::Windows::MSVC'=> '0.280220',
+ 'ExtUtils::CBuilder::Platform::aix'=> '0.280220',
+ 'ExtUtils::CBuilder::Platform::android'=> '0.280220',
+ 'ExtUtils::CBuilder::Platform::cygwin'=> '0.280220',
+ 'ExtUtils::CBuilder::Platform::darwin'=> '0.280220',
+ 'ExtUtils::CBuilder::Platform::dec_osf'=> '0.280220',
+ 'ExtUtils::CBuilder::Platform::os2'=> '0.280220',
+ 'ExtUtils::Miniperl' => '1.03',
+ 'Fcntl' => '1.13',
+ 'File::Find' => '1.29',
+ 'File::Spec' => '3.51',
+ 'File::Spec::Cygwin' => '3.51',
+ 'File::Spec::Epoc' => '3.51',
+ 'File::Spec::Functions' => '3.51',
+ 'File::Spec::Mac' => '3.51',
+ 'File::Spec::OS2' => '3.51',
+ 'File::Spec::Unix' => '3.51',
+ 'File::Spec::VMS' => '3.51',
+ 'File::Spec::Win32' => '3.51',
+ 'HTTP::Tiny' => '0.050',
+ 'IO::Compress::Adapter::Bzip2'=> '2.066',
+ 'IO::Compress::Adapter::Deflate'=> '2.066',
+ 'IO::Compress::Adapter::Identity'=> '2.066',
+ 'IO::Compress::Base' => '2.066',
+ 'IO::Compress::Base::Common'=> '2.066',
+ 'IO::Compress::Bzip2' => '2.066',
+ 'IO::Compress::Deflate' => '2.066',
+ 'IO::Compress::Gzip' => '2.066',
+ 'IO::Compress::Gzip::Constants'=> '2.066',
+ 'IO::Compress::RawDeflate'=> '2.066',
+ 'IO::Compress::Zip' => '2.066',
+ 'IO::Compress::Zip::Constants'=> '2.066',
+ 'IO::Compress::Zlib::Constants'=> '2.066',
+ 'IO::Compress::Zlib::Extra'=> '2.066',
+ 'IO::Uncompress::Adapter::Bunzip2'=> '2.066',
+ 'IO::Uncompress::Adapter::Identity'=> '2.066',
+ 'IO::Uncompress::Adapter::Inflate'=> '2.066',
+ 'IO::Uncompress::AnyInflate'=> '2.066',
+ 'IO::Uncompress::AnyUncompress'=> '2.066',
+ 'IO::Uncompress::Base' => '2.066',
+ 'IO::Uncompress::Bunzip2'=> '2.066',
+ 'IO::Uncompress::Gunzip'=> '2.066',
+ 'IO::Uncompress::Inflate'=> '2.066',
+ 'IO::Uncompress::RawInflate'=> '2.066',
+ 'IO::Uncompress::Unzip' => '2.066',
+ 'JSON::PP' => '2.27300',
+ 'Module::CoreList' => '5.20141020',
+ 'Module::CoreList::TieHashDelta'=> '5.20141020',
+ 'Module::CoreList::Utils'=> '5.20141020',
+ 'Net::Cmd' => '3.02',
+ 'Net::Config' => '3.02',
+ 'Net::Domain' => '3.02',
+ 'Net::FTP' => '3.02',
+ 'Net::FTP::A' => '3.02',
+ 'Net::FTP::E' => '3.02',
+ 'Net::FTP::I' => '3.02',
+ 'Net::FTP::L' => '3.02',
+ 'Net::FTP::dataconn' => '3.02',
+ 'Net::NNTP' => '3.02',
+ 'Net::Netrc' => '3.02',
+ 'Net::POP3' => '3.02',
+ 'Net::SMTP' => '3.02',
+ 'Net::Time' => '3.02',
+ 'Opcode' => '1.29',
+ 'POSIX' => '1.45',
+ 'Socket' => '2.016',
+ 'Test::Builder' => '1.001008',
+ 'Test::Builder::Module' => '1.001008',
+ 'Test::More' => '1.001008',
+ 'Test::Simple' => '1.001008',
+ 'XS::APItest' => '0.65',
+ 'XSLoader' => '0.18',
+ 'attributes' => '0.24',
+ 'experimental' => '0.012',
+ 'feature' => '1.38',
+ 'perlfaq' => '5.0150046',
+ 're' => '0.27',
+ 'threads::shared' => '1.47',
+ 'warnings' => '1.28',
+ 'warnings::register' => '1.04',
+ },
+ removed => {
+ }
+ },
+ 5.021006 => {
+ delta_from => 5.021005,
+ changed => {
+ 'App::Prove' => '3.34',
+ 'App::Prove::State' => '3.34',
+ 'App::Prove::State::Result'=> '3.34',
+ 'App::Prove::State::Result::Test'=> '3.34',
+ 'B' => '1.53',
+ 'B::Concise' => '0.995',
+ 'B::Deparse' => '1.30',
+ 'B::Op_private' => '5.021006',
+ 'CPAN::Meta' => '2.143240',
+ 'CPAN::Meta::Converter' => '2.143240',
+ 'CPAN::Meta::Feature' => '2.143240',
+ 'CPAN::Meta::History' => '2.143240',
+ 'CPAN::Meta::Merge' => '2.143240',
+ 'CPAN::Meta::Prereqs' => '2.143240',
+ 'CPAN::Meta::Requirements'=> '2.130',
+ 'CPAN::Meta::Spec' => '2.143240',
+ 'CPAN::Meta::Validator' => '2.143240',
+ 'Config' => '5.021006',
+ 'Devel::Peek' => '1.19',
+ 'Digest::SHA' => '5.93',
+ 'DynaLoader' => '1.28',
+ 'Encode' => '2.64',
+ 'Exporter' => '5.72',
+ 'Exporter::Heavy' => '5.72',
+ 'ExtUtils::Command::MM' => '7.02',
+ 'ExtUtils::Liblist' => '7.02',
+ 'ExtUtils::Liblist::Kid'=> '7.02',
+ 'ExtUtils::MM' => '7.02',
+ 'ExtUtils::MM_AIX' => '7.02',
+ 'ExtUtils::MM_Any' => '7.02',
+ 'ExtUtils::MM_BeOS' => '7.02',
+ 'ExtUtils::MM_Cygwin' => '7.02',
+ 'ExtUtils::MM_DOS' => '7.02',
+ 'ExtUtils::MM_Darwin' => '7.02',
+ 'ExtUtils::MM_MacOS' => '7.02',
+ 'ExtUtils::MM_NW5' => '7.02',
+ 'ExtUtils::MM_OS2' => '7.02',
+ 'ExtUtils::MM_QNX' => '7.02',
+ 'ExtUtils::MM_UWIN' => '7.02',
+ 'ExtUtils::MM_Unix' => '7.02',
+ 'ExtUtils::MM_VMS' => '7.02',
+ 'ExtUtils::MM_VOS' => '7.02',
+ 'ExtUtils::MM_Win32' => '7.02',
+ 'ExtUtils::MM_Win95' => '7.02',
+ 'ExtUtils::MY' => '7.02',
+ 'ExtUtils::MakeMaker' => '7.02',
+ 'ExtUtils::MakeMaker::Config'=> '7.02',
+ 'ExtUtils::MakeMaker::Locale'=> '7.02',
+ 'ExtUtils::MakeMaker::version'=> '7.02',
+ 'ExtUtils::MakeMaker::version::regex'=> '7.02',
+ 'ExtUtils::MakeMaker::version::vpp'=> '7.02',
+ 'ExtUtils::Manifest' => '1.69',
+ 'ExtUtils::Mkbootstrap' => '7.02',
+ 'ExtUtils::Mksymlists' => '7.02',
+ 'ExtUtils::ParseXS' => '3.26',
+ 'ExtUtils::ParseXS::Constants'=> '3.26',
+ 'ExtUtils::ParseXS::CountLines'=> '3.26',
+ 'ExtUtils::ParseXS::Eval'=> '3.26',
+ 'ExtUtils::ParseXS::Utilities'=> '3.26',
+ 'ExtUtils::testlib' => '7.02',
+ 'File::Spec::VMS' => '3.52',
+ 'HTTP::Tiny' => '0.051',
+ 'I18N::Langinfo' => '0.12',
+ 'IO::Socket' => '1.38',
+ 'Module::CoreList' => '5.20141120',
+ 'Module::CoreList::TieHashDelta'=> '5.20141120',
+ 'Module::CoreList::Utils'=> '5.20141120',
+ 'POSIX' => '1.46',
+ 'PerlIO::encoding' => '0.20',
+ 'PerlIO::scalar' => '0.20',
+ 'TAP::Base' => '3.34',
+ 'TAP::Formatter::Base' => '3.34',
+ 'TAP::Formatter::Color' => '3.34',
+ 'TAP::Formatter::Console'=> '3.34',
+ 'TAP::Formatter::Console::ParallelSession'=> '3.34',
+ 'TAP::Formatter::Console::Session'=> '3.34',
+ 'TAP::Formatter::File' => '3.34',
+ 'TAP::Formatter::File::Session'=> '3.34',
+ 'TAP::Formatter::Session'=> '3.34',
+ 'TAP::Harness' => '3.34',
+ 'TAP::Harness::Env' => '3.34',
+ 'TAP::Object' => '3.34',
+ 'TAP::Parser' => '3.34',
+ 'TAP::Parser::Aggregator'=> '3.34',
+ 'TAP::Parser::Grammar' => '3.34',
+ 'TAP::Parser::Iterator' => '3.34',
+ 'TAP::Parser::Iterator::Array'=> '3.34',
+ 'TAP::Parser::Iterator::Process'=> '3.34',
+ 'TAP::Parser::Iterator::Stream'=> '3.34',
+ 'TAP::Parser::IteratorFactory'=> '3.34',
+ 'TAP::Parser::Multiplexer'=> '3.34',
+ 'TAP::Parser::Result' => '3.34',
+ 'TAP::Parser::Result::Bailout'=> '3.34',
+ 'TAP::Parser::Result::Comment'=> '3.34',
+ 'TAP::Parser::Result::Plan'=> '3.34',
+ 'TAP::Parser::Result::Pragma'=> '3.34',
+ 'TAP::Parser::Result::Test'=> '3.34',
+ 'TAP::Parser::Result::Unknown'=> '3.34',
+ 'TAP::Parser::Result::Version'=> '3.34',
+ 'TAP::Parser::Result::YAML'=> '3.34',
+ 'TAP::Parser::ResultFactory'=> '3.34',
+ 'TAP::Parser::Scheduler'=> '3.34',
+ 'TAP::Parser::Scheduler::Job'=> '3.34',
+ 'TAP::Parser::Scheduler::Spinner'=> '3.34',
+ 'TAP::Parser::Source' => '3.34',
+ 'TAP::Parser::SourceHandler'=> '3.34',
+ 'TAP::Parser::SourceHandler::Executable'=> '3.34',
+ 'TAP::Parser::SourceHandler::File'=> '3.34',
+ 'TAP::Parser::SourceHandler::Handle'=> '3.34',
+ 'TAP::Parser::SourceHandler::Perl'=> '3.34',
+ 'TAP::Parser::SourceHandler::RawTAP'=> '3.34',
+ 'TAP::Parser::YAMLish::Reader'=> '3.34',
+ 'TAP::Parser::YAMLish::Writer'=> '3.34',
+ 'Test::Builder' => '1.301001_075',
+ 'Test::Builder::Module' => '1.301001_075',
+ 'Test::Builder::Tester' => '1.301001_075',
+ 'Test::Builder::Tester::Color'=> '1.301001_075',
+ 'Test::Harness' => '3.34',
+ 'Test::More' => '1.301001_075',
+ 'Test::More::DeepCheck' => undef,
+ 'Test::More::DeepCheck::Strict'=> undef,
+ 'Test::More::DeepCheck::Tolerant'=> undef,
+ 'Test::More::Tools' => undef,
+ 'Test::MostlyLike' => undef,
+ 'Test::Simple' => '1.301001_075',
+ 'Test::Stream' => '1.301001_075',
+ 'Test::Stream::ArrayBase'=> undef,
+ 'Test::Stream::ArrayBase::Meta'=> undef,
+ 'Test::Stream::Carp' => undef,
+ 'Test::Stream::Context' => undef,
+ 'Test::Stream::Event' => undef,
+ 'Test::Stream::Event::Bail'=> undef,
+ 'Test::Stream::Event::Child'=> undef,
+ 'Test::Stream::Event::Diag'=> undef,
+ 'Test::Stream::Event::Finish'=> undef,
+ 'Test::Stream::Event::Note'=> undef,
+ 'Test::Stream::Event::Ok'=> undef,
+ 'Test::Stream::Event::Plan'=> undef,
+ 'Test::Stream::Event::Subtest'=> undef,
+ 'Test::Stream::ExitMagic'=> undef,
+ 'Test::Stream::ExitMagic::Context'=> undef,
+ 'Test::Stream::Exporter'=> undef,
+ 'Test::Stream::Exporter::Meta'=> undef,
+ 'Test::Stream::IOSets' => undef,
+ 'Test::Stream::Meta' => undef,
+ 'Test::Stream::PackageUtil'=> undef,
+ 'Test::Stream::Tester' => undef,
+ 'Test::Stream::Tester::Checks'=> undef,
+ 'Test::Stream::Tester::Checks::Event'=> undef,
+ 'Test::Stream::Tester::Events'=> undef,
+ 'Test::Stream::Tester::Events::Event'=> undef,
+ 'Test::Stream::Tester::Grab'=> undef,
+ 'Test::Stream::Threads' => undef,
+ 'Test::Stream::Toolset' => undef,
+ 'Test::Stream::Util' => undef,
+ 'Test::Tester' => '1.301001_075',
+ 'Test::Tester::Capture' => undef,
+ 'Test::use::ok' => '1.301001_075',
+ 'Unicode::UCD' => '0.59',
+ 'XS::APItest' => '0.68',
+ 'XSLoader' => '0.19',
+ 'experimental' => '0.013',
+ 'locale' => '1.05',
+ 'ok' => '1.301001_075',
+ 'overload' => '1.24',
+ 're' => '0.28',
+ 'warnings' => '1.29',
+ },
+ removed => {
+ }
+ },
+ 5.021007 => {
+ delta_from => 5.021006,
+ changed => {
+ 'Archive::Tar' => '2.04',
+ 'Archive::Tar::Constant'=> '2.04',
+ 'Archive::Tar::File' => '2.04',
+ 'B' => '1.54',
+ 'B::Concise' => '0.996',
+ 'B::Deparse' => '1.31',
+ 'B::Op_private' => '5.021007',
+ 'B::Showlex' => '1.05',
+ 'Compress::Raw::Bzip2' => '2.067',
+ 'Compress::Raw::Zlib' => '2.067',
+ 'Compress::Zlib' => '2.067',
+ 'Config' => '5.021007',
+ 'Cwd' => '3.54',
+ 'DB_File' => '1.834',
+ 'Data::Dumper' => '2.155',
+ 'Devel::PPPort' => '3.25',
+ 'Devel::Peek' => '1.20',
+ 'DynaLoader' => '1.29',
+ 'Encode' => '2.67',
+ 'Errno' => '1.22',
+ 'ExtUtils::CBuilder' => '0.280221',
+ 'ExtUtils::CBuilder::Base'=> '0.280221',
+ 'ExtUtils::CBuilder::Platform::Unix'=> '0.280221',
+ 'ExtUtils::CBuilder::Platform::VMS'=> '0.280221',
+ 'ExtUtils::CBuilder::Platform::Windows'=> '0.280221',
+ 'ExtUtils::CBuilder::Platform::aix'=> '0.280221',
+ 'ExtUtils::CBuilder::Platform::android'=> '0.280221',
+ 'ExtUtils::CBuilder::Platform::cygwin'=> '0.280221',
+ 'ExtUtils::CBuilder::Platform::darwin'=> '0.280221',
+ 'ExtUtils::CBuilder::Platform::dec_osf'=> '0.280221',
+ 'ExtUtils::CBuilder::Platform::os2'=> '0.280221',
+ 'ExtUtils::Command::MM' => '7.04',
+ 'ExtUtils::Liblist' => '7.04',
+ 'ExtUtils::Liblist::Kid'=> '7.04',
+ 'ExtUtils::MM' => '7.04',
+ 'ExtUtils::MM_AIX' => '7.04',
+ 'ExtUtils::MM_Any' => '7.04',
+ 'ExtUtils::MM_BeOS' => '7.04',
+ 'ExtUtils::MM_Cygwin' => '7.04',
+ 'ExtUtils::MM_DOS' => '7.04',
+ 'ExtUtils::MM_Darwin' => '7.04',
+ 'ExtUtils::MM_MacOS' => '7.04',
+ 'ExtUtils::MM_NW5' => '7.04',
+ 'ExtUtils::MM_OS2' => '7.04',
+ 'ExtUtils::MM_QNX' => '7.04',
+ 'ExtUtils::MM_UWIN' => '7.04',
+ 'ExtUtils::MM_Unix' => '7.04',
+ 'ExtUtils::MM_VMS' => '7.04',
+ 'ExtUtils::MM_VOS' => '7.04',
+ 'ExtUtils::MM_Win32' => '7.04',
+ 'ExtUtils::MM_Win95' => '7.04',
+ 'ExtUtils::MY' => '7.04',
+ 'ExtUtils::MakeMaker' => '7.04',
+ 'ExtUtils::MakeMaker::Config'=> '7.04',
+ 'ExtUtils::MakeMaker::Locale'=> '7.04',
+ 'ExtUtils::MakeMaker::version'=> '7.04',
+ 'ExtUtils::MakeMaker::version::regex'=> '7.04',
+ 'ExtUtils::MakeMaker::version::vpp'=> '7.04',
+ 'ExtUtils::Mkbootstrap' => '7.04',
+ 'ExtUtils::Mksymlists' => '7.04',
+ 'ExtUtils::ParseXS' => '3.27',
+ 'ExtUtils::ParseXS::Constants'=> '3.27',
+ 'ExtUtils::ParseXS::CountLines'=> '3.27',
+ 'ExtUtils::ParseXS::Eval'=> '3.27',
+ 'ExtUtils::ParseXS::Utilities'=> '3.27',
+ 'ExtUtils::testlib' => '7.04',
+ 'File::Spec' => '3.53',
+ 'File::Spec::Cygwin' => '3.54',
+ 'File::Spec::Epoc' => '3.54',
+ 'File::Spec::Functions' => '3.54',
+ 'File::Spec::Mac' => '3.54',
+ 'File::Spec::OS2' => '3.54',
+ 'File::Spec::Unix' => '3.54',
+ 'File::Spec::VMS' => '3.54',
+ 'File::Spec::Win32' => '3.54',
+ 'Filter::Util::Call' => '1.51',
+ 'HTTP::Tiny' => '0.053',
+ 'IO' => '1.35',
+ 'IO::Compress::Adapter::Bzip2'=> '2.067',
+ 'IO::Compress::Adapter::Deflate'=> '2.067',
+ 'IO::Compress::Adapter::Identity'=> '2.067',
+ 'IO::Compress::Base' => '2.067',
+ 'IO::Compress::Base::Common'=> '2.067',
+ 'IO::Compress::Bzip2' => '2.067',
+ 'IO::Compress::Deflate' => '2.067',
+ 'IO::Compress::Gzip' => '2.067',
+ 'IO::Compress::Gzip::Constants'=> '2.067',
+ 'IO::Compress::RawDeflate'=> '2.067',
+ 'IO::Compress::Zip' => '2.067',
+ 'IO::Compress::Zip::Constants'=> '2.067',
+ 'IO::Compress::Zlib::Constants'=> '2.067',
+ 'IO::Compress::Zlib::Extra'=> '2.067',
+ 'IO::Socket::IP' => '0.34',
+ 'IO::Uncompress::Adapter::Bunzip2'=> '2.067',
+ 'IO::Uncompress::Adapter::Identity'=> '2.067',
+ 'IO::Uncompress::Adapter::Inflate'=> '2.067',
+ 'IO::Uncompress::AnyInflate'=> '2.067',
+ 'IO::Uncompress::AnyUncompress'=> '2.067',
+ 'IO::Uncompress::Base' => '2.067',
+ 'IO::Uncompress::Bunzip2'=> '2.067',
+ 'IO::Uncompress::Gunzip'=> '2.067',
+ 'IO::Uncompress::Inflate'=> '2.067',
+ 'IO::Uncompress::RawInflate'=> '2.067',
+ 'IO::Uncompress::Unzip' => '2.067',
+ 'Locale::Codes' => '3.33',
+ 'Locale::Codes::Constants'=> '3.33',
+ 'Locale::Codes::Country'=> '3.33',
+ 'Locale::Codes::Country_Codes'=> '3.33',
+ 'Locale::Codes::Country_Retired'=> '3.33',
+ 'Locale::Codes::Currency'=> '3.33',
+ 'Locale::Codes::Currency_Codes'=> '3.33',
+ 'Locale::Codes::Currency_Retired'=> '3.33',
+ 'Locale::Codes::LangExt'=> '3.33',
+ 'Locale::Codes::LangExt_Codes'=> '3.33',
+ 'Locale::Codes::LangExt_Retired'=> '3.33',
+ 'Locale::Codes::LangFam'=> '3.33',
+ 'Locale::Codes::LangFam_Codes'=> '3.33',
+ 'Locale::Codes::LangFam_Retired'=> '3.33',
+ 'Locale::Codes::LangVar'=> '3.33',
+ 'Locale::Codes::LangVar_Codes'=> '3.33',
+ 'Locale::Codes::LangVar_Retired'=> '3.33',
+ 'Locale::Codes::Language'=> '3.33',
+ 'Locale::Codes::Language_Codes'=> '3.33',
+ 'Locale::Codes::Language_Retired'=> '3.33',
+ 'Locale::Codes::Script' => '3.33',
+ 'Locale::Codes::Script_Codes'=> '3.33',
+ 'Locale::Codes::Script_Retired'=> '3.33',
+ 'Locale::Country' => '3.33',
+ 'Locale::Currency' => '3.33',
+ 'Locale::Language' => '3.33',
+ 'Locale::Maketext' => '1.26',
+ 'Locale::Script' => '3.33',
+ 'Module::CoreList' => '5.20141220',
+ 'Module::CoreList::TieHashDelta'=> '5.20141220',
+ 'Module::CoreList::Utils'=> '5.20141220',
+ 'NDBM_File' => '1.14',
+ 'Net::Cmd' => '3.04',
+ 'Net::Config' => '3.04',
+ 'Net::Domain' => '3.04',
+ 'Net::FTP' => '3.04',
+ 'Net::FTP::A' => '3.04',
+ 'Net::FTP::E' => '3.04',
+ 'Net::FTP::I' => '3.04',
+ 'Net::FTP::L' => '3.04',
+ 'Net::FTP::dataconn' => '3.04',
+ 'Net::NNTP' => '3.04',
+ 'Net::Netrc' => '3.04',
+ 'Net::POP3' => '3.04',
+ 'Net::SMTP' => '3.04',
+ 'Net::Time' => '3.04',
+ 'Opcode' => '1.30',
+ 'POSIX' => '1.48',
+ 'PerlIO::scalar' => '0.21',
+ 'Pod::Escapes' => '1.07',
+ 'SDBM_File' => '1.12',
+ 'Storable' => '2.52',
+ 'Sys::Hostname' => '1.20',
+ 'Test::Builder' => '1.301001_090',
+ 'Test::Builder::Module' => '1.301001_090',
+ 'Test::Builder::Tester' => '1.301001_090',
+ 'Test::Builder::Tester::Color'=> '1.301001_090',
+ 'Test::CanFork' => undef,
+ 'Test::CanThread' => undef,
+ 'Test::More' => '1.301001_090',
+ 'Test::Simple' => '1.301001_090',
+ 'Test::Stream' => '1.301001_090',
+ 'Test::Stream::API' => undef,
+ 'Test::Stream::ForceExit'=> undef,
+ 'Test::Stream::Subtest' => undef,
+ 'Test::Tester' => '1.301001_090',
+ 'Test::use::ok' => '1.301001_090',
+ 'Unicode::Collate' => '1.09',
+ 'Unicode::Collate::CJK::Big5'=> '1.09',
+ 'Unicode::Collate::CJK::GB2312'=> '1.09',
+ 'Unicode::Collate::CJK::JISX0208'=> '1.09',
+ 'Unicode::Collate::CJK::Korean'=> '1.09',
+ 'Unicode::Collate::CJK::Pinyin'=> '1.09',
+ 'Unicode::Collate::CJK::Stroke'=> '1.09',
+ 'Unicode::Collate::CJK::Zhuyin'=> '1.09',
+ 'Unicode::Collate::Locale'=> '1.09',
+ 'XS::APItest' => '0.69',
+ 'XSLoader' => '0.20',
+ '_charnames' => '1.43',
+ 'arybase' => '0.09',
+ 'charnames' => '1.43',
+ 'feature' => '1.39',
+ 'mro' => '1.17',
+ 'ok' => '1.301001_090',
+ 'strict' => '1.09',
+ 'threads' => '1.96_001',
+ },
+ removed => {
+ }
+ },
+ 5.021008 => {
+ delta_from => 5.021007,
+ changed => {
+ 'App::Prove' => '3.35',
+ 'App::Prove::State' => '3.35',
+ 'App::Prove::State::Result'=> '3.35',
+ 'App::Prove::State::Result::Test'=> '3.35',
+ 'B' => '1.55',
+ 'B::Deparse' => '1.32',
+ 'B::Op_private' => '5.021008',
+ 'CPAN::Meta::Requirements'=> '2.131',
+ 'Compress::Raw::Bzip2' => '2.068',
+ 'Compress::Raw::Zlib' => '2.068',
+ 'Compress::Zlib' => '2.068',
+ 'Config' => '5.021008',
+ 'DB_File' => '1.835',
+ 'Data::Dumper' => '2.156',
+ 'Devel::PPPort' => '3.28',
+ 'Devel::Peek' => '1.21',
+ 'Digest::MD5' => '2.54',
+ 'Digest::SHA' => '5.95',
+ 'DynaLoader' => '1.30',
+ 'ExtUtils::Command' => '1.20',
+ 'ExtUtils::Manifest' => '1.70',
+ 'Fatal' => '2.26',
+ 'File::Glob' => '1.24',
+ 'Filter::Util::Call' => '1.54',
+ 'Getopt::Long' => '2.43',
+ 'IO::Compress::Adapter::Bzip2'=> '2.068',
+ 'IO::Compress::Adapter::Deflate'=> '2.068',
+ 'IO::Compress::Adapter::Identity'=> '2.068',
+ 'IO::Compress::Base' => '2.068',
+ 'IO::Compress::Base::Common'=> '2.068',
+ 'IO::Compress::Bzip2' => '2.068',
+ 'IO::Compress::Deflate' => '2.068',
+ 'IO::Compress::Gzip' => '2.068',
+ 'IO::Compress::Gzip::Constants'=> '2.068',
+ 'IO::Compress::RawDeflate'=> '2.068',
+ 'IO::Compress::Zip' => '2.068',
+ 'IO::Compress::Zip::Constants'=> '2.068',
+ 'IO::Compress::Zlib::Constants'=> '2.068',
+ 'IO::Compress::Zlib::Extra'=> '2.068',
+ 'IO::Socket::IP' => '0.36',
+ 'IO::Uncompress::Adapter::Bunzip2'=> '2.068',
+ 'IO::Uncompress::Adapter::Identity'=> '2.068',
+ 'IO::Uncompress::Adapter::Inflate'=> '2.068',
+ 'IO::Uncompress::AnyInflate'=> '2.068',
+ 'IO::Uncompress::AnyUncompress'=> '2.068',
+ 'IO::Uncompress::Base' => '2.068',
+ 'IO::Uncompress::Bunzip2'=> '2.068',
+ 'IO::Uncompress::Gunzip'=> '2.068',
+ 'IO::Uncompress::Inflate'=> '2.068',
+ 'IO::Uncompress::RawInflate'=> '2.068',
+ 'IO::Uncompress::Unzip' => '2.068',
+ 'MIME::Base64' => '3.15',
+ 'Module::CoreList' => '5.20150220',
+ 'Module::CoreList::TieHashDelta'=> '5.20150220',
+ 'Module::CoreList::Utils'=> '5.20150220',
+ 'Module::Load::Conditional'=> '0.64',
+ 'Module::Metadata' => '1.000026',
+ 'Net::Cmd' => '3.05',
+ 'Net::Config' => '3.05',
+ 'Net::Domain' => '3.05',
+ 'Net::FTP' => '3.05',
+ 'Net::FTP::A' => '3.05',
+ 'Net::FTP::E' => '3.05',
+ 'Net::FTP::I' => '3.05',
+ 'Net::FTP::L' => '3.05',
+ 'Net::FTP::dataconn' => '3.05',
+ 'Net::NNTP' => '3.05',
+ 'Net::Netrc' => '3.05',
+ 'Net::POP3' => '3.05',
+ 'Net::SMTP' => '3.05',
+ 'Net::Time' => '3.05',
+ 'Opcode' => '1.31',
+ 'POSIX' => '1.49',
+ 'PerlIO::encoding' => '0.21',
+ 'Pod::Simple' => '3.29',
+ 'Pod::Simple::BlackBox' => '3.29',
+ 'Pod::Simple::Checker' => '3.29',
+ 'Pod::Simple::Debug' => '3.29',
+ 'Pod::Simple::DumpAsText'=> '3.29',
+ 'Pod::Simple::DumpAsXML'=> '3.29',
+ 'Pod::Simple::HTML' => '3.29',
+ 'Pod::Simple::HTMLBatch'=> '3.29',
+ 'Pod::Simple::LinkSection'=> '3.29',
+ 'Pod::Simple::Methody' => '3.29',
+ 'Pod::Simple::Progress' => '3.29',
+ 'Pod::Simple::PullParser'=> '3.29',
+ 'Pod::Simple::PullParserEndToken'=> '3.29',
+ 'Pod::Simple::PullParserStartToken'=> '3.29',
+ 'Pod::Simple::PullParserTextToken'=> '3.29',
+ 'Pod::Simple::PullParserToken'=> '3.29',
+ 'Pod::Simple::RTF' => '3.29',
+ 'Pod::Simple::Search' => '3.29',
+ 'Pod::Simple::SimpleTree'=> '3.29',
+ 'Pod::Simple::Text' => '3.29',
+ 'Pod::Simple::TextContent'=> '3.29',
+ 'Pod::Simple::TiedOutFH'=> '3.29',
+ 'Pod::Simple::Transcode'=> '3.29',
+ 'Pod::Simple::TranscodeDumb'=> '3.29',
+ 'Pod::Simple::TranscodeSmart'=> '3.29',
+ 'Pod::Simple::XHTML' => '3.29',
+ 'Pod::Simple::XMLOutStream'=> '3.29',
+ 'SDBM_File' => '1.13',
+ 'Safe' => '2.39',
+ 'TAP::Base' => '3.35',
+ 'TAP::Formatter::Base' => '3.35',
+ 'TAP::Formatter::Color' => '3.35',
+ 'TAP::Formatter::Console'=> '3.35',
+ 'TAP::Formatter::Console::ParallelSession'=> '3.35',
+ 'TAP::Formatter::Console::Session'=> '3.35',
+ 'TAP::Formatter::File' => '3.35',
+ 'TAP::Formatter::File::Session'=> '3.35',
+ 'TAP::Formatter::Session'=> '3.35',
+ 'TAP::Harness' => '3.35',
+ 'TAP::Harness::Env' => '3.35',
+ 'TAP::Object' => '3.35',
+ 'TAP::Parser' => '3.35',
+ 'TAP::Parser::Aggregator'=> '3.35',
+ 'TAP::Parser::Grammar' => '3.35',
+ 'TAP::Parser::Iterator' => '3.35',
+ 'TAP::Parser::Iterator::Array'=> '3.35',
+ 'TAP::Parser::Iterator::Process'=> '3.35',
+ 'TAP::Parser::Iterator::Stream'=> '3.35',
+ 'TAP::Parser::IteratorFactory'=> '3.35',
+ 'TAP::Parser::Multiplexer'=> '3.35',
+ 'TAP::Parser::Result' => '3.35',
+ 'TAP::Parser::Result::Bailout'=> '3.35',
+ 'TAP::Parser::Result::Comment'=> '3.35',
+ 'TAP::Parser::Result::Plan'=> '3.35',
+ 'TAP::Parser::Result::Pragma'=> '3.35',
+ 'TAP::Parser::Result::Test'=> '3.35',
+ 'TAP::Parser::Result::Unknown'=> '3.35',
+ 'TAP::Parser::Result::Version'=> '3.35',
+ 'TAP::Parser::Result::YAML'=> '3.35',
+ 'TAP::Parser::ResultFactory'=> '3.35',
+ 'TAP::Parser::Scheduler'=> '3.35',
+ 'TAP::Parser::Scheduler::Job'=> '3.35',
+ 'TAP::Parser::Scheduler::Spinner'=> '3.35',
+ 'TAP::Parser::Source' => '3.35',
+ 'TAP::Parser::SourceHandler'=> '3.35',
+ 'TAP::Parser::SourceHandler::Executable'=> '3.35',
+ 'TAP::Parser::SourceHandler::File'=> '3.35',
+ 'TAP::Parser::SourceHandler::Handle'=> '3.35',
+ 'TAP::Parser::SourceHandler::Perl'=> '3.35',
+ 'TAP::Parser::SourceHandler::RawTAP'=> '3.35',
+ 'TAP::Parser::YAMLish::Reader'=> '3.35',
+ 'TAP::Parser::YAMLish::Writer'=> '3.35',
+ 'Test::Builder' => '1.301001_097',
+ 'Test::Builder::Module' => '1.301001_097',
+ 'Test::Builder::Tester' => '1.301001_097',
+ 'Test::Builder::Tester::Color'=> '1.301001_097',
+ 'Test::Harness' => '3.35',
+ 'Test::More' => '1.301001_097',
+ 'Test::Simple' => '1.301001_097',
+ 'Test::Stream' => '1.301001_097',
+ 'Test::Stream::Block' => undef,
+ 'Test::Tester' => '1.301001_097',
+ 'Test::Tester::CaptureRunner'=> undef,
+ 'Test::Tester::Delegate'=> undef,
+ 'Test::use::ok' => '1.301001_097',
+ 'Unicode::Collate' => '1.10',
+ 'Unicode::Collate::CJK::Big5'=> '1.10',
+ 'Unicode::Collate::CJK::GB2312'=> '1.10',
+ 'Unicode::Collate::CJK::JISX0208'=> '1.10',
+ 'Unicode::Collate::CJK::Korean'=> '1.10',
+ 'Unicode::Collate::CJK::Pinyin'=> '1.10',
+ 'Unicode::Collate::CJK::Stroke'=> '1.10',
+ 'Unicode::Collate::CJK::Zhuyin'=> '1.10',
+ 'Unicode::Collate::Locale'=> '1.10',
+ 'VMS::DCLsym' => '1.06',
+ 'XS::APItest' => '0.70',
+ 'arybase' => '0.10',
+ 'attributes' => '0.25',
+ 'autodie' => '2.26',
+ 'autodie::Scope::Guard' => '2.26',
+ 'autodie::Scope::GuardStack'=> '2.26',
+ 'autodie::ScopeUtil' => '2.26',
+ 'autodie::exception' => '2.26',
+ 'autodie::exception::system'=> '2.26',
+ 'autodie::hints' => '2.26',
+ 'autodie::skip' => '2.26',
+ 'ok' => '1.301001_097',
+ 're' => '0.30',
+ 'warnings' => '1.30',
+ },
+ removed => {
+ }
+ },
+ 5.020002 => {
+ delta_from => 5.020001,
+ changed => {
+ 'CPAN::Author' => '5.5002',
+ 'CPAN::CacheMgr' => '5.5002',
+ 'CPAN::FTP' => '5.5006',
+ 'CPAN::HTTP::Client' => '1.9601',
+ 'CPAN::HandleConfig' => '5.5005',
+ 'CPAN::Index' => '1.9601',
+ 'CPAN::LWP::UserAgent' => '1.9601',
+ 'CPAN::Mirrors' => '1.9601',
+ 'Config' => '5.020002',
+ 'Cwd' => '3.48_01',
+ 'Data::Dumper' => '2.151_01',
+ 'Errno' => '1.20_05',
+ 'File::Spec' => '3.48_01',
+ 'File::Spec::Cygwin' => '3.48_01',
+ 'File::Spec::Epoc' => '3.48_01',
+ 'File::Spec::Functions' => '3.48_01',
+ 'File::Spec::Mac' => '3.48_01',
+ 'File::Spec::OS2' => '3.48_01',
+ 'File::Spec::Unix' => '3.48_01',
+ 'File::Spec::VMS' => '3.48_01',
+ 'File::Spec::Win32' => '3.48_01',
+ 'IO::Socket' => '1.38',
+ 'Module::CoreList' => '5.20150214',
+ 'Module::CoreList::TieHashDelta'=> '5.20150214',
+ 'Module::CoreList::Utils'=> '5.20150214',
+ 'PerlIO::scalar' => '0.18_01',
+ 'Pod::PlainText' => '2.07',
+ 'Storable' => '2.49_01',
+ 'VMS::DCLsym' => '1.05_01',
+ 'VMS::Stdio' => '2.41',
+ 'attributes' => '0.23',
+ 'feature' => '1.36_01',
+ },
+ removed => {
+ }
+ },
);
sub is_core
@@ -9275,7 +11098,7 @@ sub is_core
my ($module_version, $perl_version);
$module_version = shift if @_ > 0;
- $perl_version = @_ > 0 ? shift : $^V;
+ $perl_version = @_ > 0 ? shift : $];
my $first_release = first_release($module);
@@ -9307,7 +11130,7 @@ sub is_core
last RELEASE if $prn > $perl_version;
next unless defined(my $next_module_version
= $delta{$prn}->{changed}->{$module});
- return 1 if $next_module_version >= $module_version;
+ return 1 if version->parse($next_module_version) >= version->parse($module_version);
}
return 0;
}
@@ -9485,7 +11308,20 @@ for my $version (sort { $a <=> $b } keys %delta) {
removed => {
}
},
-
+ 5.018003 => {
+ delta_from => 5.018,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.018004 => {
+ delta_from => 5.018,
+ changed => {
+ },
+ removed => {
+ }
+ },
5.019 => {
delta_from => 5.018,
@@ -9617,6 +11453,134 @@ for my $version (sort { $a <=> $b } keys %delta) {
removed => {
}
},
+ 5.019007 => {
+ delta_from => 5.019006,
+ changed => {
+ 'CGI' => '1',
+ 'CGI::Apache' => '1',
+ 'CGI::Carp' => '1',
+ 'CGI::Cookie' => '1',
+ 'CGI::Fast' => '1',
+ 'CGI::Pretty' => '1',
+ 'CGI::Push' => '1',
+ 'CGI::Switch' => '1',
+ 'CGI::Util' => '1',
+ },
+ removed => {
+ }
+ },
+ 5.019008 => {
+ delta_from => 5.019007,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.019009 => {
+ delta_from => 5.019008,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.01901 => {
+ delta_from => 5.019009,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.019011 => {
+ delta_from => 5.019010,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.020000 => {
+ delta_from => 5.019011,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021000 => {
+ delta_from => 5.020000,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021001 => {
+ delta_from => 5.017007,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021002 => {
+ delta_from => 5.021001,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021003 => {
+ delta_from => 5.021002,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.020001 => {
+ delta_from => 5.020000,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021004 => {
+ delta_from => 5.021003,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021005 => {
+ delta_from => 5.021004,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021006 => {
+ delta_from => 5.021005,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021007 => {
+ delta_from => 5.021006,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021008 => {
+ delta_from => 5.021007,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.020002 => {
+ delta_from => 5.020001,
+ changed => {
+ },
+ removed => {
+ }
+ },
);
for my $version (sort { $a <=> $b } keys %deprecated) {
@@ -9778,6 +11742,7 @@ for my $version (sort { $a <=> $b } keys %deprecated) {
'IO::Compress::Zip::Constants'=> 'cpan',
'IO::Compress::Zlib::Constants'=> 'cpan',
'IO::Compress::Zlib::Extra'=> 'cpan',
+ 'IO::Socket::IP' => 'cpan',
'IO::Uncompress::Adapter::Bunzip2'=> 'cpan',
'IO::Uncompress::Adapter::Identity'=> 'cpan',
'IO::Uncompress::Adapter::Inflate'=> 'cpan',
@@ -10028,9 +11993,13 @@ for my $version (sort { $a <=> $b } keys %deprecated) {
'autodie::skip' => 'cpan',
'encoding' => 'cpan',
'encoding::warnings' => 'cpan',
+ 'experimental' => 'cpan',
'inc::latest' => 'cpan',
'parent' => 'cpan',
'perlfaq' => 'cpan',
+ 'version' => 'cpan',
+ 'version::regex' => 'cpan',
+ 'version::vpp' => 'cpan',
);
%bug_tracker = (
@@ -10043,15 +12012,15 @@ for my $version (sort { $a <=> $b } keys %deprecated) {
'Archive::Tar::Constant'=> undef,
'Archive::Tar::File' => undef,
'B::Debug' => undef,
- 'CGI' => undef,
- 'CGI::Apache' => undef,
- 'CGI::Carp' => undef,
- 'CGI::Cookie' => undef,
- 'CGI::Fast' => undef,
- 'CGI::Pretty' => undef,
- 'CGI::Push' => undef,
- 'CGI::Switch' => undef,
- 'CGI::Util' => undef,
+ 'CGI' => 'https://github.com/leejo/CGI.pm/issues',
+ 'CGI::Apache' => 'https://github.com/leejo/CGI.pm/issues',
+ 'CGI::Carp' => 'https://github.com/leejo/CGI.pm/issues',
+ 'CGI::Cookie' => 'https://github.com/leejo/CGI.pm/issues',
+ 'CGI::Fast' => 'https://github.com/leejo/cgi-fast/issues',
+ 'CGI::Pretty' => 'https://github.com/leejo/CGI.pm/issues',
+ 'CGI::Push' => 'https://github.com/leejo/CGI.pm/issues',
+ 'CGI::Switch' => 'https://github.com/leejo/CGI.pm/issues',
+ 'CGI::Util' => 'https://github.com/leejo/CGI.pm/issues',
'CPAN' => undef,
'CPAN::Author' => undef,
'CPAN::Bundle' => undef,
@@ -10099,7 +12068,7 @@ for my $version (sort { $a <=> $b } keys %deprecated) {
'Compress::Zlib' => undef,
'Config::Perl::V' => undef,
'DB_File' => undef,
- 'Devel::PPPort' => undef,
+ 'Devel::PPPort' => 'https://github.com/mhx/Devel-PPPort/issues/',
'Digest' => undef,
'Digest::MD5' => undef,
'Digest::SHA' => undef,
@@ -10182,6 +12151,7 @@ for my $version (sort { $a <=> $b } keys %deprecated) {
'IO::Compress::Zip::Constants'=> undef,
'IO::Compress::Zlib::Constants'=> undef,
'IO::Compress::Zlib::Extra'=> undef,
+ 'IO::Socket::IP' => undef,
'IO::Uncompress::Adapter::Bunzip2'=> undef,
'IO::Uncompress::Adapter::Identity'=> undef,
'IO::Uncompress::Adapter::Inflate'=> undef,
@@ -10250,7 +12220,7 @@ for my $version (sort { $a <=> $b } keys %deprecated) {
'Module::Build::ConfigData'=> undef,
'Module::Build::Cookbook'=> undef,
'Module::Build::Dumper' => undef,
- 'Module::Build::ModuleInfo'=> undef,
+ 'Module::Build::ModuleInfo'=> 'http://rt.cpan.org/Public/Dist/Display.html?Name=Module-Build-Deprecated',
'Module::Build::Notes' => undef,
'Module::Build::PPMMaker'=> undef,
'Module::Build::Platform::Default'=> undef,
@@ -10264,8 +12234,8 @@ for my $version (sort { $a <=> $b } keys %deprecated) {
'Module::Build::Platform::darwin'=> undef,
'Module::Build::Platform::os2'=> undef,
'Module::Build::PodParser'=> undef,
- 'Module::Build::Version'=> undef,
- 'Module::Build::YAML' => undef,
+ 'Module::Build::Version'=> 'http://rt.cpan.org/Public/Dist/Display.html?Name=Module-Build-Deprecated',
+ 'Module::Build::YAML' => 'http://rt.cpan.org/Public/Dist/Display.html?Name=Module-Build-Deprecated',
'Module::Load' => undef,
'Module::Load::Conditional'=> undef,
'Module::Loaded' => undef,
@@ -10393,16 +12363,16 @@ for my $version (sort { $a <=> $b } keys %deprecated) {
'TAP::Parser::SourceHandler::RawTAP'=> 'http://rt.cpan.org/Public/Dist/Display.html?Name=Test-Harness',
'TAP::Parser::YAMLish::Reader'=> 'http://rt.cpan.org/Public/Dist/Display.html?Name=Test-Harness',
'TAP::Parser::YAMLish::Writer'=> 'http://rt.cpan.org/Public/Dist/Display.html?Name=Test-Harness',
- 'Term::ANSIColor' => undef,
+ 'Term::ANSIColor' => 'https://rt.cpan.org/Public/Dist/Display.html?Name=Term-ANSIColor',
'Term::Cap' => undef,
'Test' => undef,
- 'Test::Builder' => 'http://github.com/schwern/test-more/issues/',
- 'Test::Builder::Module' => 'http://github.com/schwern/test-more/issues/',
- 'Test::Builder::Tester' => 'http://github.com/schwern/test-more/issues',
- 'Test::Builder::Tester::Color'=> 'http://github.com/schwern/test-more/issues',
+ 'Test::Builder' => 'http://github.com/Test-More/test-more/issues/',
+ 'Test::Builder::Module' => 'http://github.com/Test-More/test-more/issues/',
+ 'Test::Builder::Tester' => 'http://github.com/Test-More/test-more/issues/',
+ 'Test::Builder::Tester::Color'=> 'http://github.com/Test-More/test-more/issues/',
'Test::Harness' => 'http://rt.cpan.org/Public/Dist/Display.html?Name=Test-Harness',
- 'Test::More' => 'http://github.com/schwern/test-more/issues/',
- 'Test::Simple' => 'http://github.com/schwern/test-more/issues/',
+ 'Test::More' => 'http://github.com/Test-More/test-more/issues/',
+ 'Test::Simple' => 'http://github.com/Test-More/test-more/issues/',
'Text::Balanced' => undef,
'Text::ParseWords' => undef,
'Text::Tabs' => undef,
@@ -10432,9 +12402,13 @@ for my $version (sort { $a <=> $b } keys %deprecated) {
'autodie::skip' => 'http://rt.cpan.org/NoAuth/Bugs.html?Dist=autodie',
'encoding' => undef,
'encoding::warnings' => undef,
- 'inc::latest' => undef,
+ 'experimental' => 'http://rt.cpan.org/Public/Dist/Display.html?Name=experimental',
+ 'inc::latest' => 'https://github.com/dagolden/inc-latest/issues',
'parent' => undef,
'perlfaq' => 'https://github.com/perl-doc-cats/perlfaq/issues',
+ 'version' => 'https://rt.cpan.org/Public/Dist/Display.html?Name=version',
+ 'version::regex' => 'https://rt.cpan.org/Public/Dist/Display.html?Name=version',
+ 'version::vpp' => 'https://rt.cpan.org/Public/Dist/Display.html?Name=version',
);
# Create aliases with trailing zeros for $] use
@@ -10442,6 +12416,7 @@ for my $version (sort { $a <=> $b } keys %deprecated) {
$released{'5.000'} = $released{5};
$version{'5.000'} = $version{5};
+_create_aliases(\%delta);
_create_aliases(\%released);
_create_aliases(\%version);
_create_aliases(\%deprecated);
@@ -10450,7 +12425,7 @@ sub _create_aliases {
my ($hash) = @_;
for my $version (keys %$hash) {
- next unless $version >= 5.010;
+ next unless $version >= 5.006;
my $padded = sprintf "%0.6f", $version;
diff --git a/Master/tlpkg/tlperl/lib/Module/CoreList.pod b/Master/tlpkg/tlperl/lib/Module/CoreList.pod
new file mode 100644
index 00000000000..edc00ec9feb
--- /dev/null
+++ b/Master/tlpkg/tlperl/lib/Module/CoreList.pod
@@ -0,0 +1,251 @@
+=head1 NAME
+
+Module::CoreList - what modules shipped with versions of perl
+
+=head1 SYNOPSIS
+
+ use Module::CoreList;
+
+ print $Module::CoreList::version{5.00503}{CPAN}; # prints 1.48
+
+ print Module::CoreList->first_release('File::Spec'); # prints 5.00405
+ print Module::CoreList->first_release_by_date('File::Spec'); # prints 5.005
+ print Module::CoreList->first_release('File::Spec', 0.82); # prints 5.006001
+
+ if (Module::CoreList::is_core('File::Spec')) {
+ print "File::Spec is a core module\n";
+ }
+
+ print join ', ', Module::CoreList->find_modules(qr/Data/);
+ # prints 'Data::Dumper'
+ print join ', ',
+ Module::CoreList->find_modules(qr/test::h.*::.*s/i, 5.008008);
+ # prints 'Test::Harness::Assert, Test::Harness::Straps'
+
+ print join ", ", @{ $Module::CoreList::families{5.005} };
+ # prints "5.005, 5.00503, 5.00504"
+
+=head1 DESCRIPTION
+
+Module::CoreList provides information on which core and dual-life modules shipped
+with each version of L<perl>.
+
+It provides a number of mechanisms for querying this information.
+
+There is a utility called L<corelist> provided with this module
+which is a convenient way of querying from the command-line.
+
+There is a functional programming API available for programmers to query
+information.
+
+Programmers may also query the contained hash structures to find relevant
+information.
+
+=head1 FUNCTIONS API
+
+These are the functions that are available, they may either be called as functions or class methods:
+
+ Module::CoreList::first_release('File::Spec'); # as a function
+
+ Module::CoreList->first_release('File::Spec'); # class method
+
+=over
+
+=item C<first_release( MODULE )>
+
+Behaviour since version 2.11
+
+Requires a MODULE name as an argument, returns the perl version when that module first
+appeared in core as ordered by perl version number or undef ( in scalar context )
+or an empty list ( in list context ) if that module is not in core.
+
+=item C<first_release_by_date( MODULE )>
+
+Requires a MODULE name as an argument, returns the perl version when that module first
+appeared in core as ordered by release date or undef ( in scalar context )
+or an empty list ( in list context ) if that module is not in core.
+
+=item C<find_modules( REGEX, [ LIST OF PERLS ] )>
+
+Takes a regex as an argument, returns a list of modules that match the regex given.
+If only a regex is provided applies to all modules in all perl versions. Optionally
+you may provide a list of perl versions to limit the regex search.
+
+=item C<find_version( PERL_VERSION )>
+
+Takes a perl version as an argument. Returns that perl version if it exists or C<undef>
+otherwise.
+
+=item C<is_core( MODULE, [ MODULE_VERSION, [ PERL_VERSION ] ] )>
+
+Available in version 2.99 and above.
+
+Returns true if MODULE was bundled with the specified version of Perl.
+You can optionally specify a minimum version of the module,
+and can also specify a version of Perl.
+If a version of Perl isn't specified,
+C<is_core()> will use the numeric version of Perl that is running (ie C<$]>).
+
+If you want to specify the version of Perl, but don't care about
+the version of the module, pass C<undef> for the module version:
+
+=item C<is_deprecated( MODULE, PERL_VERSION )>
+
+Available in version 2.22 and above.
+
+Returns true if MODULE is marked as deprecated in PERL_VERSION. If PERL_VERSION is
+omitted, it defaults to the current version of Perl.
+
+=item C<deprecated_in( MODULE )>
+
+Available in version 2.77 and above.
+
+Returns the first PERL_VERSION where the MODULE was marked as deprecated. Returns C<undef>
+if the MODULE has not been marked as deprecated.
+
+=item C<removed_from( MODULE )>
+
+Available in version 2.32 and above
+
+Takes a module name as an argument, returns the first perl version where that module
+was removed from core. Returns undef if the given module was never in core or remains
+in core.
+
+=item C<removed_from_by_date( MODULE )>
+
+Available in version 2.32 and above
+
+Takes a module name as an argument, returns the first perl version by release date where that module
+was removed from core. Returns undef if the given module was never in core or remains
+in core.
+
+=item C<changes_between( PERL_VERSION, PERL_VERSION )>
+
+Available in version 2.66 and above.
+
+Given two perl versions, this returns a list of pairs describing the changes in
+core module content between them. The list is suitable for storing in a hash.
+The keys are library names and the values are hashrefs. Each hashref has an
+entry for one or both of C<left> and C<right>, giving the versions of the
+library in each of the left and right perl distributions.
+
+For example, it might return these data (among others) for the difference
+between 5.008000 and 5.008001:
+
+ 'Pod::ParseLink' => { left => '1.05', right => '1.06' },
+ 'Pod::ParseUtils' => { left => '0.22', right => '0.3' },
+ 'Pod::Perldoc' => { right => '3.10' },
+ 'Pod::Perldoc::BaseTo' => { right => undef },
+
+This shows us two libraries being updated and two being added, one of which has
+an undefined version in the right-hand side version.
+
+=back
+
+=head1 DATA STRUCTURES
+
+These are the hash data structures that are available:
+
+=over
+
+=item C<%Module::CoreList::version>
+
+A hash of hashes that is keyed on perl version as indicated
+in $]. The second level hash is module => version pairs.
+
+Note, it is possible for the version of a module to be unspecified,
+whereby the value is C<undef>, so use C<exists $version{$foo}{$bar}> if
+that's what you're testing for.
+
+Starting with 2.10, the special module name C<Unicode> refers to the version of
+the Unicode Character Database bundled with Perl.
+
+=item C<%Module::CoreList::delta>
+
+Available in version 3.00 and above.
+
+C<%Module::CoreList::version> is implemented via C<Module::CoreList::TieHashDelta>
+using this hash of delta changes.
+
+It is a hash of hashes that is keyed on perl version. Each keyed hash will have the
+following keys:
+
+ delta_from - a previous perl version that the changes are based on
+ changed - a hash of module/versions that have changed
+ removed - a hash of modules that have been removed
+
+=item C<%Module::CoreList::released>
+
+Keyed on perl version this contains ISO
+formatted versions of the release dates, as gleaned from L<perlhist>.
+
+=item C<%Module::CoreList::families>
+
+New, in 1.96, a hash that
+clusters known perl releases by their major versions.
+
+=item C<%Module::CoreList::deprecated>
+
+A hash of hashes keyed on perl version and on module name.
+If a module is defined it indicates that that module is
+deprecated in that perl version and is scheduled for removal
+from core at some future point.
+
+=item C<%Module::CoreList::upstream>
+
+A hash that contains information on where patches should be directed
+for each core module.
+
+UPSTREAM indicates where patches should go. C<undef> implies
+that this hasn't been discussed for the module at hand.
+C<blead> indicates that the copy of the module in the blead
+sources is to be considered canonical, C<cpan> means that the
+module on CPAN is to be patched first. C<first-come> means
+that blead can be patched freely if it is in sync with the
+latest release on CPAN.
+
+=item C<%Module::CoreList::bug_tracker>
+
+A hash that contains information on the appropriate bug tracker
+for each core module.
+
+BUGS is an email or url to post bug reports. For modules with
+UPSTREAM => 'blead', use perl5-porters@perl.org. rt.cpan.org
+appears to automatically provide a URL for CPAN modules; any value
+given here overrides the default:
+http://rt.cpan.org/Public/Dist/Display.html?Name=$ModuleName
+
+=back
+
+=head1 CAVEATS
+
+Module::CoreList currently covers the 5.000, 5.001, 5.002, 5.003_07,
+5.004, 5.004_05, 5.005, 5.005_03, 5.005_04 and 5.7.3 releases of perl.
+
+All stable releases of perl since 5.6.0 are covered.
+
+All development releases of perl since 5.9.0 are covered.
+
+
+=head1 HISTORY
+
+Moved to Changes file.
+
+=head1 AUTHOR
+
+Richard Clamp E<lt>richardc@unixbeard.netE<gt>
+
+Currently maintained by the perl 5 porters E<lt>perl5-porters@perl.orgE<gt>.
+
+=head1 LICENSE
+
+Copyright (C) 2002-2009 Richard Clamp. All Rights Reserved.
+
+This module is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 SEE ALSO
+
+L<corelist>, L<Module::Info>, L<perl>, L<http://perlpunks.de/corelist>
+
+=cut
diff --git a/Master/tlpkg/tlperl/lib/Module/CoreList/TieHashDelta.pm b/Master/tlpkg/tlperl/lib/Module/CoreList/TieHashDelta.pm
index b0c133950b2..eb769f3070a 100644
--- a/Master/tlpkg/tlperl/lib/Module/CoreList/TieHashDelta.pm
+++ b/Master/tlpkg/tlperl/lib/Module/CoreList/TieHashDelta.pm
@@ -3,7 +3,7 @@ package Module::CoreList::TieHashDelta;
use strict;
use vars qw($VERSION);
-$VERSION = "3.03";
+$VERSION = '5.20150214';
sub TIEHASH {
my ($class, $changed, $removed, $parent) = @_;
@@ -32,12 +32,14 @@ sub FETCH {
sub EXISTS {
my ($self, $key) = @_;
+ restart:
if (exists $self->{changed}{$key}) {
return 1;
} elsif (exists $self->{removed}{$key}) {
return '';
} elsif (defined $self->{parent}) {
- return exists $self->{parent}{$key};
+ $self = tied %{$self->{parent}}; #avoid extreme magic/tie recursion
+ goto restart;
}
return '';
}
diff --git a/Master/tlpkg/tlperl/lib/Module/CoreList/Utils.pm b/Master/tlpkg/tlperl/lib/Module/CoreList/Utils.pm
index 5967e032ad5..b9fde3e27a2 100755
--- a/Master/tlpkg/tlperl/lib/Module/CoreList/Utils.pm
+++ b/Master/tlpkg/tlperl/lib/Module/CoreList/Utils.pm
@@ -6,7 +6,7 @@ use vars qw[$VERSION %utilities];
use Module::CoreList;
use Module::CoreList::TieHashDelta;
-$VERSION = '3.03';
+$VERSION = '5.20150214';
sub utilities {
my $perl = shift;
@@ -822,6 +822,20 @@ my %delta = (
removed => {
}
},
+ 5.018003 => {
+ delta_from => 5.018000,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.018004 => {
+ delta_from => 5.018000,
+ changed => {
+ },
+ removed => {
+ }
+ },
5.019000 => {
delta_from => 5.018000,
changed => {
@@ -882,6 +896,123 @@ my %delta = (
removed => {
}
},
+ 5.019008 => {
+ delta_from => 5.019007,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.019009 => {
+ delta_from => 5.019008,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.019010 => {
+ delta_from => 5.019009,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.019011 => {
+ delta_from => 5.019010,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.020000 => {
+ delta_from => 5.019011,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021000 => {
+ delta_from => 5.020000,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021001 => {
+ delta_from => 5.021000,
+ changed => {
+ },
+ removed => {
+ 'a2p' => 1,
+ 'config_data' => 1,
+ 'find2perl' => 1,
+ 'psed' => 1,
+ 's2p' => 1,
+ }
+ },
+ 5.021002 => {
+ delta_from => 5.021001,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021003 => {
+ delta_from => 5.021002,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.020001 => {
+ delta_from => 5.02,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021004 => {
+ delta_from => 5.021003,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021005 => {
+ delta_from => 5.021004,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021006 => {
+ delta_from => 5.021005,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021007 => {
+ delta_from => 5.021006,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.021008 => {
+ delta_from => 5.021007,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.020002 => {
+ delta_from => 5.020001,
+ changed => {
+ },
+ removed => {
+ }
+ },
);
for my $version (sort { $a <=> $b } keys %delta) {
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
diff --git a/Master/tlpkg/tlperl/lib/Module/Load/Conditional.pm b/Master/tlpkg/tlperl/lib/Module/Load/Conditional.pm
index 342371f8794..422f56b4d5c 100644
--- a/Master/tlpkg/tlperl/lib/Module/Load/Conditional.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Load/Conditional.pm
@@ -2,7 +2,7 @@ package Module::Load::Conditional;
use strict;
-use Module::Load;
+use Module::Load qw/load autoload_remote/;
use Params::Check qw[check];
use Locale::Maketext::Simple Style => 'gettext';
@@ -13,14 +13,16 @@ use version;
use Module::Metadata ();
-use constant ON_VMS => $^O eq 'VMS';
+use constant ON_VMS => $^O eq 'VMS';
+use constant ON_WIN32 => $^O eq 'MSWin32' ? 1 : 0;
+use constant QUOTE => do { ON_WIN32 ? q["] : q['] };
BEGIN {
use vars qw[ $VERSION @ISA $VERBOSE $CACHE @EXPORT_OK $DEPRECATED
$FIND_VERSION $ERROR $CHECK_INC_HASH];
use Exporter;
@ISA = qw[Exporter];
- $VERSION = '0.54';
+ $VERSION = '0.62';
$VERBOSE = 0;
$DEPRECATED = 0;
$FIND_VERSION = 1;
@@ -195,7 +197,7 @@ sub check_install {
}
}
- ### we didnt find the filename yet by looking in %INC,
+ ### we didn't find the filename yet by looking in %INC,
### so scan the dirs
unless( $filename ) {
@@ -317,7 +319,7 @@ sub check_install {
return $href;
}
-=head2 $bool = can_load( modules => { NAME => VERSION [,NAME => VERSION] }, [verbose => BOOL, nocache => BOOL] )
+=head2 $bool = can_load( modules => { NAME => VERSION [,NAME => VERSION] }, [verbose => BOOL, nocache => BOOL, autoload => BOOL] )
C<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*
@@ -327,8 +329,8 @@ 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 C<load> function from Module::Load under the
-hood.
+This function uses the C<load> function or the C<autoload_remote> function
+from Module::Load under the hood.
C<can_load> takes the following arguments:
@@ -353,6 +355,12 @@ same module twice, nor will it attempt to load a module that has
already failed to load before. By default, C<can_load> will check its
cache, but you can override that by setting C<nocache> to true.
+=item autoload
+
+This controls whether imports the functions of a loaded modules to the caller package. The default is no importing any functions.
+
+See the C<autoload> function and the C<autoload_remote> function from L<Module::Load> for details.
+
=cut
sub can_load {
@@ -362,6 +370,7 @@ sub can_load {
modules => { default => {}, strict_type => 1 },
verbose => { default => $VERBOSE },
nocache => { default => 0 },
+ autoload => { default => 0 },
};
my $args;
@@ -434,7 +443,12 @@ sub can_load {
if ( $CACHE->{$mod}->{uptodate} ) {
- eval { load $mod };
+ if ( $args->{autoload} ) {
+ my $who = (caller())[0];
+ eval { autoload_remote $who, $mod };
+ } else {
+ eval { load $mod };
+ }
### in case anything goes wrong, log the error, the fact
### we tried to use this module and return 0;
@@ -495,12 +509,15 @@ sub requires {
}
my $lib = join " ", map { qq["-I$_"] } @INC;
- my $cmd = qq["$^X" $lib -M$who -e"print(join(qq[\\n],keys(%INC)))"];
+ my $oneliner = 'print(join(qq[\n],map{qq[BONG=$_]}keys(%INC)),qq[\n])';
+ my $cmd = join '', qq["$^X" $lib -M$who -e], QUOTE, $oneliner, QUOTE;
return sort
grep { !/^$who$/ }
map { chomp; s|/|::|g; $_ }
grep { s|\.pm$||i; }
+ map { s!^BONG\=!!; $_ }
+ grep { m!^BONG\=! }
`$cmd`;
}
diff --git a/Master/tlpkg/tlperl/lib/Module/Metadata.pm b/Master/tlpkg/tlperl/lib/Module/Metadata.pm
index e3c25049460..e352d316208 100644
--- a/Master/tlpkg/tlperl/lib/Module/Metadata.pm
+++ b/Master/tlpkg/tlperl/lib/Module/Metadata.pm
@@ -10,8 +10,9 @@ package Module::Metadata;
# parrot future to look at other types of modules).
use strict;
-use vars qw($VERSION);
-$VERSION = '1.000011';
+use warnings;
+
+our $VERSION = '1.000019';
$VERSION = eval $VERSION;
use Carp qw/croak/;
@@ -29,11 +30,39 @@ use File::Find qw(find);
my $V_NUM_REGEXP = qr{v?[0-9._]+}; # crudely, a v-string or decimal
+my $PKG_FIRST_WORD_REGEXP = qr{ # the FIRST word in a package name
+ [a-zA-Z_] # the first word CANNOT start with a digit
+ (?:
+ [\w']? # can contain letters, digits, _, or ticks
+ \w # But, NO multi-ticks or trailing ticks
+ )*
+}x;
+
+my $PKG_ADDL_WORD_REGEXP = qr{ # the 2nd+ word in a package name
+ \w # the 2nd+ word CAN start with digits
+ (?:
+ [\w']? # and can contain letters or ticks
+ \w # But, NO multi-ticks or trailing ticks
+ )*
+}x;
+
+my $PKG_NAME_REGEXP = qr{ # match a package name
+ (?: :: )? # a pkg name can start with aristotle
+ $PKG_FIRST_WORD_REGEXP # a package word
+ (?:
+ (?: :: )+ ### aristotle (allow one or many times)
+ $PKG_ADDL_WORD_REGEXP ### a package word
+ )* # ^ zero, one or many times
+ (?:
+ :: # allow trailing aristotle
+ )?
+}x;
+
my $PKG_REGEXP = qr{ # match a package declaration
^[\s\{;]* # intro chars on a line
package # the word 'package'
\s+ # whitespace
- ([\w:]+) # a package name
+ ($PKG_NAME_REGEXP) # a package name
\s* # optional whitespace
($V_NUM_REGEXP)? # optional version number
\s* # optional whitesapce
@@ -93,16 +122,16 @@ sub new_from_module {
}
{
-
+
my $compare_versions = sub {
my ($v1, $op, $v2) = @_;
$v1 = version->new($v1)
unless UNIVERSAL::isa($v1,'version');
-
+
my $eval_str = "\$v1 $op \$v2";
my $result = eval $eval_str;
log_info { "error comparing versions: '$eval_str' $@" } if $@;
-
+
return $result;
};
@@ -128,7 +157,7 @@ sub new_from_module {
my $resolve_module_versions = sub {
my $packages = shift;
-
+
my( $file, $version );
my $err = '';
foreach my $p ( @$packages ) {
@@ -146,17 +175,17 @@ sub new_from_module {
}
$file ||= $p->{file} if defined( $p->{file} );
}
-
+
if ( $err ) {
$err = " $file ($version)\n" . $err;
}
-
+
my %result = (
file => $file,
version => $version,
err => $err
);
-
+
return \%result;
};
@@ -221,16 +250,16 @@ sub new_from_module {
my $mapped_filename = File::Spec::Unix->abs2rel( $file, $dir );
my @path = split( /\//, $mapped_filename );
(my $prime_package = join( '::', @path )) =~ s/\.pm$//;
-
+
my $pm_info = $class->new_from_file( $file );
-
+
foreach my $package ( $pm_info->packages_inside ) {
next if $package eq 'main'; # main can appear numerous times, ignore
next if $package eq 'DB'; # special debugging package, ignore
next if grep /^_/, split( /::/, $package ); # private package, ignore
-
+
my $version = $pm_info->version( $package );
-
+
$prime_package = $package if lc($prime_package) eq lc($package);
if ( $package eq $prime_package ) {
if ( exists( $prime{$package} ) ) {
@@ -248,15 +277,15 @@ sub new_from_module {
}
}
}
-
+
# Then we iterate over all the packages found above, identifying conflicts
# and selecting the "best" candidate for recording the file & version
# for each package.
foreach my $package ( keys( %alt ) ) {
my $result = $resolve_module_versions->( $alt{$package} );
-
+
if ( exists( $prime{$package} ) ) { # primary package selected
-
+
if ( $result->{err} ) {
# Use the selected primary package, but there are conflicting
# errors among multiple alternative packages that need to be
@@ -266,11 +295,11 @@ sub new_from_module {
" $prime{$package}{file} ($prime{$package}{version})\n" .
$result->{err}
};
-
+
} elsif ( defined( $result->{version} ) ) {
# There is a primary package selected, and exactly one
# alternative package
-
+
if ( exists( $prime{$package}{version} ) &&
defined( $prime{$package}{version} ) ) {
# Unless the version of the primary package agrees with the
@@ -286,28 +315,28 @@ sub new_from_module {
" $result->{file} ($result->{version})\n"
};
}
-
+
} else {
# The prime package selected has no version so, we choose to
# use any alternative package that does have a version
$prime{$package}{file} = $result->{file};
$prime{$package}{version} = $result->{version};
}
-
+
} else {
# no alt package found with a version, but we have a prime
# package so we use it whether it has a version or not
}
-
+
} else { # No primary package was selected, use the best alternative
-
+
if ( $result->{err} ) {
log_info {
"Found conflicting versions for package '$package'\n" .
$result->{err}
};
}
-
+
# Despite possible conflicting versions, we choose to record
# something rather than nothing
$prime{$package}{file} = $result->{file};
@@ -315,17 +344,17 @@ sub new_from_module {
if defined( $result->{version} );
}
}
-
+
# Normalize versions. Can't use exists() here because of bug in YAML::Node.
- # XXX "bug in YAML::Node" comment seems irrelvant -- dagolden, 2009-05-18
+ # XXX "bug in YAML::Node" comment seems irrelevant -- dagolden, 2009-05-18
for (grep defined $_->{version}, values %prime) {
$_->{version} = $normalize_version->( $_->{version} );
}
-
+
return \%prime;
}
-}
-
+}
+
sub _init {
my $class = shift;
@@ -490,6 +519,7 @@ sub _parse_fh {
my $pkg = 'main';
my $pod_sect = '';
my $pod_data = '';
+ my $in_end = 0;
while (defined( my $line = <$fh> )) {
my $line_num = $.;
@@ -532,11 +562,18 @@ sub _parse_fh {
} else {
+ # Skip after __END__
+ next if $in_end;
+
# Skip comments in code
next if $line =~ /^\s*#/;
# Would be nice if we could also check $in_string or something too
- last if $line =~ /^__(?:DATA|END)__$/;
+ if ($line eq '__END__') {
+ $in_end++;
+ next;
+ }
+ last if $line eq '__DATA__';
# parse $line to see if it's a $VERSION declaration
my( $vers_sig, $vers_fullname, $vers_pkg ) =
@@ -583,7 +620,7 @@ sub _parse_fh {
unless ( defined $vers{$pkg} && length $vers{$pkg} ) {
$vers{$pkg} = $v;
- }
+ }
}
@@ -613,10 +650,11 @@ sub _evaluate_version_line {
# compiletime/runtime issues with local()
my $vsub;
$pn++; # everybody gets their own package
- my $eval = qq{BEGIN { q# Hide from _packages_inside()
+ my $eval = qq{BEGIN { my \$dummy = q# Hide from _packages_inside()
#; package Module::Metadata::_version::p$pn;
use version;
no strict;
+ no warnings;
\$vsub = sub {
local $sigil$var;
@@ -626,6 +664,8 @@ sub _evaluate_version_line {
};
}};
+ $eval = $1 if $eval =~ m{^(.+)}s;
+
local $^W;
# Try to get the $VERSION
eval $eval;
@@ -713,12 +753,12 @@ sub _evaluate_version_line {
############################################################
# accessors
-sub name { $_[0]->{module} }
+sub name { $_[0]->{module} }
-sub filename { $_[0]->{filename} }
-sub packages_inside { @{$_[0]->{packages}} }
-sub pod_inside { @{$_[0]->{pod_headings}} }
-sub contains_pod { $#{$_[0]->{pod_headings}} }
+sub filename { $_[0]->{filename} }
+sub packages_inside { @{$_[0]->{packages}} }
+sub pod_inside { @{$_[0]->{pod_headings}} }
+sub contains_pod { 0+@{$_[0]->{pod_headings}} }
sub version {
my $self = shift;
@@ -764,8 +804,10 @@ Module::Metadata - Gather package and POD information from perl module files
=head1 DESCRIPTION
-This module provides a standard way to gather metadata about a .pm file
-without executing unsafe code.
+This module provides a standard way to gather metadata about a .pm file through
+(mostly) static analysis and (some) code execution. When determining the
+version of a module, the C<$VERSION> assignment is C<eval>ed, as is traditional
+in the CPAN toolchain.
=head1 USAGE
@@ -934,7 +976,10 @@ Returns the absolute path to the file.
Returns a list of packages. Note: this is a raw list of packages
discovered (or assumed, in the case of C<main>). It is not
filtered for C<DB>, C<main> or private packages the way the
-C<provides> method does.
+C<provides> method does. Invalid package names are not returned,
+for example "Foo:Bar". Strange but valid package names are
+returned, for example "Foo::Bar::", and are left up to the caller
+on how to handle.
=item C<< pod_inside() >>
diff --git a/Master/tlpkg/tlperl/lib/Module/Pluggable.pm b/Master/tlpkg/tlperl/lib/Module/Pluggable.pm
deleted file mode 100644
index 9e7962efab7..00000000000
--- a/Master/tlpkg/tlperl/lib/Module/Pluggable.pm
+++ /dev/null
@@ -1,457 +0,0 @@
-package Module::Pluggable;
-
-use strict;
-use vars qw($VERSION $FORCE_SEARCH_ALL_PATHS);
-use Module::Pluggable::Object;
-
-use if $] > 5.017, 'deprecate';
-
-# ObQuote:
-# Bob Porter: Looks like you've been missing a lot of work lately.
-# Peter Gibbons: I wouldn't say I've been missing it, Bob!
-
-
-$VERSION = '4.7';
-$FORCE_SEARCH_ALL_PATHS = 0;
-
-sub import {
- my $class = shift;
- my %opts = @_;
-
- my ($pkg, $file) = caller;
- # the default name for the method is 'plugins'
- my $sub = $opts{'sub_name'} || 'plugins';
- # get our package
- my ($package) = $opts{'package'} || $pkg;
- $opts{filename} = $file;
- $opts{package} = $package;
- $opts{force_search_all_paths} = $FORCE_SEARCH_ALL_PATHS unless exists $opts{force_search_all_paths};
-
-
- my $finder = Module::Pluggable::Object->new(%opts);
- my $subroutine = sub { my $self = shift; return $finder->plugins(@_) };
-
- my $searchsub = sub {
- my $self = shift;
- my ($action,@paths) = @_;
-
- $finder->{'search_path'} = ["${package}::Plugin"] if ($action eq 'add' and not $finder->{'search_path'} );
- push @{$finder->{'search_path'}}, @paths if ($action eq 'add');
- $finder->{'search_path'} = \@paths if ($action eq 'new');
- return $finder->{'search_path'};
- };
-
-
- my $onlysub = sub {
- my ($self, $only) = @_;
-
- if (defined $only) {
- $finder->{'only'} = $only;
- };
-
- return $finder->{'only'};
- };
-
- my $exceptsub = sub {
- my ($self, $except) = @_;
-
- if (defined $except) {
- $finder->{'except'} = $except;
- };
-
- return $finder->{'except'};
- };
-
-
- no strict 'refs';
- no warnings qw(redefine prototype);
-
- *{"$package\::$sub"} = $subroutine;
- *{"$package\::search_path"} = $searchsub;
- *{"$package\::only"} = $onlysub;
- *{"$package\::except"} = $exceptsub;
-
-}
-
-1;
-
-=pod
-
-=head1 NAME
-
-Module::Pluggable - automatically give your module the ability to have plugins
-
-=head1 SYNOPSIS
-
-
-Simple use Module::Pluggable -
-
- package MyClass;
- use Module::Pluggable;
-
-
-and then later ...
-
- use MyClass;
- my $mc = MyClass->new();
- # returns the names of all plugins installed under MyClass::Plugin::*
- my @plugins = $mc->plugins();
-
-=head1 EXAMPLE
-
-Why would you want to do this? Say you have something that wants to pass an
-object to a number of different plugins in turn. For example you may
-want to extract meta-data from every email you get sent and do something
-with it. Plugins make sense here because then you can keep adding new
-meta data parsers and all the logic and docs for each one will be
-self contained and new handlers are easy to add without changing the
-core code. For that, you might do something like ...
-
- package Email::Examiner;
-
- use strict;
- use Email::Simple;
- use Module::Pluggable require => 1;
-
- sub handle_email {
- my $self = shift;
- my $email = shift;
-
- foreach my $plugin ($self->plugins) {
- $plugin->examine($email);
- }
-
- return 1;
- }
-
-
-
-.. and all the plugins will get a chance in turn to look at it.
-
-This can be trivally extended so that plugins could save the email
-somewhere and then no other plugin should try and do that.
-Simply have it so that the C<examine> method returns C<1> if
-it has saved the email somewhere. You might also wnat to be paranoid
-and check to see if the plugin has an C<examine> method.
-
- foreach my $plugin ($self->plugins) {
- next unless $plugin->can('examine');
- last if $plugin->examine($email);
- }
-
-
-And so on. The sky's the limit.
-
-
-=head1 DESCRIPTION
-
-Provides a simple but, hopefully, extensible way of having 'plugins' for
-your module. Obviously this isn't going to be the be all and end all of
-solutions but it works for me.
-
-Essentially all it does is export a method into your namespace that
-looks through a search path for .pm files and turn those into class names.
-
-Optionally it instantiates those classes for you.
-
-=head1 ADVANCED USAGE
-
-Alternatively, if you don't want to use 'plugins' as the method ...
-
- package MyClass;
- use Module::Pluggable sub_name => 'foo';
-
-
-and then later ...
-
- my @plugins = $mc->foo();
-
-
-Or if you want to look in another namespace
-
- package MyClass;
- use Module::Pluggable search_path => ['Acme::MyClass::Plugin', 'MyClass::Extend'];
-
-or directory
-
- use Module::Pluggable search_dirs => ['mylibs/Foo'];
-
-
-Or if you want to instantiate each plugin rather than just return the name
-
- package MyClass;
- use Module::Pluggable instantiate => 'new';
-
-and then
-
- # whatever is passed to 'plugins' will be passed
- # to 'new' for each plugin
- my @plugins = $mc->plugins(@options);
-
-
-alternatively you can just require the module without instantiating it
-
- package MyClass;
- use Module::Pluggable require => 1;
-
-since requiring automatically searches inner packages, which may not be desirable, you can turn this off
-
-
- package MyClass;
- use Module::Pluggable require => 1, inner => 0;
-
-
-You can limit the plugins loaded using the except option, either as a string,
-array ref or regex
-
- package MyClass;
- use Module::Pluggable except => 'MyClass::Plugin::Foo';
-
-or
-
- package MyClass;
- use Module::Pluggable except => ['MyClass::Plugin::Foo', 'MyClass::Plugin::Bar'];
-
-or
-
- package MyClass;
- use Module::Pluggable except => qr/^MyClass::Plugin::(Foo|Bar)$/;
-
-
-and similarly for only which will only load plugins which match.
-
-Remember you can use the module more than once
-
- package MyClass;
- use Module::Pluggable search_path => 'MyClass::Filters' sub_name => 'filters';
- use Module::Pluggable search_path => 'MyClass::Plugins' sub_name => 'plugins';
-
-and then later ...
-
- my @filters = $self->filters;
- my @plugins = $self->plugins;
-
-=head1 PLUGIN SEARCHING
-
-Every time you call 'plugins' the whole search path is walked again. This allows
-for dynamically loading plugins even at run time. However this can get expensive
-and so if you don't expect to want to add new plugins at run time you could do
-
-
- package Foo;
- use strict;
- use Module::Pluggable sub_name => '_plugins';
-
- our @PLUGINS;
- sub plugins { @PLUGINS ||= shift->_plugins }
- 1;
-
-=head1 INNER PACKAGES
-
-If you have, for example, a file B<lib/Something/Plugin/Foo.pm> that
-contains package definitions for both C<Something::Plugin::Foo> and
-C<Something::Plugin::Bar> then as long as you either have either
-the B<require> or B<instantiate> option set then we'll also find
-C<Something::Plugin::Bar>. Nifty!
-
-=head1 OPTIONS
-
-You can pass a hash of options when importing this module.
-
-The options can be ...
-
-=head2 sub_name
-
-The name of the subroutine to create in your namespace.
-
-By default this is 'plugins'
-
-=head2 search_path
-
-An array ref of namespaces to look in.
-
-=head2 search_dirs
-
-An array ref of directorys to look in before @INC.
-
-=head2 instantiate
-
-Call this method on the class. In general this will probably be 'new'
-but it can be whatever you want. Whatever arguments are passed to 'plugins'
-will be passed to the method.
-
-The default is 'undef' i.e just return the class name.
-
-=head2 require
-
-Just require the class, don't instantiate (overrides 'instantiate');
-
-=head2 inner
-
-If set to 0 will B<not> search inner packages.
-If set to 1 will override C<require>.
-
-=head2 only
-
-Takes a string, array ref or regex describing the names of the only plugins to
-return. Whilst this may seem perverse ... well, it is. But it also
-makes sense. Trust me.
-
-=head2 except
-
-Similar to C<only> it takes a description of plugins to exclude
-from returning. This is slightly less perverse.
-
-=head2 package
-
-This is for use by extension modules which build on C<Module::Pluggable>:
-passing a C<package> option allows you to place the plugin method in a
-different package other than your own.
-
-=head2 file_regex
-
-By default C<Module::Pluggable> only looks for I<.pm> files.
-
-By supplying a new C<file_regex> then you can change this behaviour e.g
-
- file_regex => qr/\.plugin$/
-
-=head2 include_editor_junk
-
-By default C<Module::Pluggable> ignores files that look like they were
-left behind by editors. Currently this means files ending in F<~> (~),
-the extensions F<.swp> or F<.swo>, or files beginning with F<.#>.
-
-Setting C<include_editor_junk> changes C<Module::Pluggable> so it does
-not ignore any files it finds.
-
-=head2 follow_symlinks
-
-Whether, when searching directories, to follow symlinks.
-
-Defaults to 1 i.e do follow symlinks.
-
-=head2 min_depth, max_depth
-
-This will allow you to set what 'depth' of plugin will be allowed.
-
-So, for example, C<MyClass::Plugin::Foo> will have a depth of 3 and
-C<MyClass::Plugin::Foo::Bar> will have a depth of 4 so to only get the former
-(i.e C<MyClass::Plugin::Foo>) do
-
- package MyClass;
- use Module::Pluggable max_depth => 3;
-
-and to only get the latter (i.e C<MyClass::Plugin::Foo::Bar>)
-
- package MyClass;
- use Module::Pluggable min_depth => 4;
-
-
-=head1 TRIGGERS
-
-Various triggers can also be passed in to the options.
-
-If any of these triggers return 0 then the plugin will not be returned.
-
-=head2 before_require <plugin>
-
-Gets passed the plugin name.
-
-If 0 is returned then this plugin will not be required either.
-
-=head2 on_require_error <plugin> <err>
-
-Gets called when there's an error on requiring the plugin.
-
-Gets passed the plugin name and the error.
-
-The default on_require_error handler is to C<carp> the error and return 0.
-
-=head2 on_instantiate_error <plugin> <err>
-
-Gets called when there's an error on instantiating the plugin.
-
-Gets passed the plugin name and the error.
-
-The default on_instantiate_error handler is to C<carp> the error and return 0.
-
-=head2 after_require <plugin>
-
-Gets passed the plugin name.
-
-If 0 is returned then this plugin will be required but not returned as a plugin.
-
-=head1 METHODs
-
-=head2 search_path
-
-The method C<search_path> is exported into you namespace as well.
-You can call that at any time to change or replace the
-search_path.
-
- $self->search_path( add => "New::Path" ); # add
- $self->search_path( new => "New::Path" ); # replace
-
-=head1 BEHAVIOUR UNDER TEST ENVIRONMENT
-
-In order to make testing reliable we exclude anything not from blib if blib.pm is
-in %INC.
-
-However if the module being tested used another module that itself used C<Module::Pluggable>
-then the second module would fail. This was fixed by checking to see if the caller
-had (^|/)blib/ in their filename.
-
-There's an argument that this is the wrong behaviour and that modules should explicitly
-trigger this behaviour but that particular code has been around for 7 years now and I'm
-reluctant to change the default behaviour.
-
-You can now (as of version 4.1) force Module::Pluggable to look outside blib in a test environment by doing either
-
- require Module::Pluggable;
- $Module::Pluggable::FORCE_SEARCH_ALL_PATHS = 1;
- import Module::Pluggable;
-
-or
-
- use Module::Pluggable force_search_all_paths => 1;
-
-
-=head1 FUTURE PLANS
-
-This does everything I need and I can't really think of any other
-features I want to add. Famous last words of course
-
-Recently tried fixed to find inner packages and to make it
-'just work' with PAR but there are still some issues.
-
-
-However suggestions (and patches) are welcome.
-
-=head1 DEVELOPMENT
-
-The master repo for this module is at
-
-https://github.com/simonwistow/Module-Pluggable
-
-=head1 AUTHOR
-
-Simon Wistow <simon@thegestalt.org>
-
-=head1 COPYING
-
-Copyright, 2006 Simon Wistow
-
-Distributed under the same terms as Perl itself.
-
-=head1 BUGS
-
-None known.
-
-=head1 SEE ALSO
-
-L<File::Spec>, L<File::Find>, L<File::Basename>, L<Class::Factory::Util>, L<Module::Pluggable::Ordered>
-
-=cut
-
-
diff --git a/Master/tlpkg/tlperl/lib/Module/Pluggable/Object.pm b/Master/tlpkg/tlperl/lib/Module/Pluggable/Object.pm
deleted file mode 100644
index 6b1d265456c..00000000000
--- a/Master/tlpkg/tlperl/lib/Module/Pluggable/Object.pm
+++ /dev/null
@@ -1,405 +0,0 @@
-package Module::Pluggable::Object;
-
-use strict;
-use File::Find ();
-use File::Basename;
-use File::Spec::Functions qw(splitdir catdir curdir catfile abs2rel);
-use Carp qw(croak carp confess);
-use Devel::InnerPackage;
-use vars qw($VERSION);
-
-use if $] > 5.017, 'deprecate';
-
-$VERSION = '4.6';
-
-
-sub new {
- my $class = shift;
- my %opts = @_;
-
- return bless \%opts, $class;
-
-}
-
-### Eugggh, this code smells
-### This is what happens when you keep adding patches
-### *sigh*
-
-
-sub plugins {
- my $self = shift;
- my @args = @_;
-
- # override 'require'
- $self->{'require'} = 1 if $self->{'inner'};
-
- my $filename = $self->{'filename'};
- my $pkg = $self->{'package'};
-
- # Get the exception params instantiated
- $self->_setup_exceptions;
-
- # automatically turn a scalar search path or namespace into a arrayref
- for (qw(search_path search_dirs)) {
- $self->{$_} = [ $self->{$_} ] if exists $self->{$_} && !ref($self->{$_});
- }
-
- # default search path is '<Module>::<Name>::Plugin'
- $self->{'search_path'} ||= ["${pkg}::Plugin"];
-
- # default error handler
- $self->{'on_require_error'} ||= sub { my ($plugin, $err) = @_; carp "Couldn't require $plugin : $err"; return 0 };
- $self->{'on_instantiate_error'} ||= sub { my ($plugin, $err) = @_; carp "Couldn't instantiate $plugin: $err"; return 0 };
-
- # default whether to follow symlinks
- $self->{'follow_symlinks'} = 1 unless exists $self->{'follow_symlinks'};
-
- # check to see if we're running under test
- my @SEARCHDIR = exists $INC{"blib.pm"} && defined $filename && $filename =~ m!(^|/)blib/! && !$self->{'force_search_all_paths'} ? grep {/blib/} @INC : @INC;
-
- # add any search_dir params
- unshift @SEARCHDIR, @{$self->{'search_dirs'}} if defined $self->{'search_dirs'};
-
- # set our @INC up to include and prefer our search_dirs if necessary
- my @tmp = @INC;
- unshift @tmp, @{$self->{'search_dirs'} || []};
- local @INC = @tmp if defined $self->{'search_dirs'};
-
- my @plugins = $self->search_directories(@SEARCHDIR);
- push(@plugins, $self->handle_innerpackages($_)) for @{$self->{'search_path'}};
-
- # return blank unless we've found anything
- return () unless @plugins;
-
- # remove duplicates
- # probably not necessary but hey ho
- my %plugins;
- for(@plugins) {
- next unless $self->_is_legit($_);
- $plugins{$_} = 1;
- }
-
- # are we instantiating or requring?
- if (defined $self->{'instantiate'}) {
- my $method = $self->{'instantiate'};
- my @objs = ();
- foreach my $package (sort keys %plugins) {
- next unless $package->can($method);
- my $obj = eval { $package->$method(@_) };
- $self->{'on_instantiate_error'}->($package, $@) if $@;
- push @objs, $obj if $obj;
- }
- return @objs;
- } else {
- # no? just return the names
- my @objs= sort keys %plugins;
- return @objs;
- }
-}
-
-sub _setup_exceptions {
- my $self = shift;
-
- my %only;
- my %except;
- my $only;
- my $except;
-
- if (defined $self->{'only'}) {
- if (ref($self->{'only'}) eq 'ARRAY') {
- %only = map { $_ => 1 } @{$self->{'only'}};
- } elsif (ref($self->{'only'}) eq 'Regexp') {
- $only = $self->{'only'}
- } elsif (ref($self->{'only'}) eq '') {
- $only{$self->{'only'}} = 1;
- }
- }
-
-
- if (defined $self->{'except'}) {
- if (ref($self->{'except'}) eq 'ARRAY') {
- %except = map { $_ => 1 } @{$self->{'except'}};
- } elsif (ref($self->{'except'}) eq 'Regexp') {
- $except = $self->{'except'}
- } elsif (ref($self->{'except'}) eq '') {
- $except{$self->{'except'}} = 1;
- }
- }
- $self->{_exceptions}->{only_hash} = \%only;
- $self->{_exceptions}->{only} = $only;
- $self->{_exceptions}->{except_hash} = \%except;
- $self->{_exceptions}->{except} = $except;
-
-}
-
-sub _is_legit {
- my $self = shift;
- my $plugin = shift;
- my %only = %{$self->{_exceptions}->{only_hash}||{}};
- my %except = %{$self->{_exceptions}->{except_hash}||{}};
- my $only = $self->{_exceptions}->{only};
- my $except = $self->{_exceptions}->{except};
- my $depth = () = split '::', $plugin, -1;
-
- return 0 if (keys %only && !$only{$plugin} );
- return 0 unless (!defined $only || $plugin =~ m!$only! );
-
- return 0 if (keys %except && $except{$plugin} );
- return 0 if (defined $except && $plugin =~ m!$except! );
-
- return 0 if defined $self->{max_depth} && $depth>$self->{max_depth};
- return 0 if defined $self->{min_depth} && $depth<$self->{min_depth};
-
- return 1;
-}
-
-sub search_directories {
- my $self = shift;
- my @SEARCHDIR = @_;
-
- my @plugins;
- # go through our @INC
- foreach my $dir (@SEARCHDIR) {
- push @plugins, $self->search_paths($dir);
- }
- return @plugins;
-}
-
-
-sub search_paths {
- my $self = shift;
- my $dir = shift;
- my @plugins;
-
- my $file_regex = $self->{'file_regex'} || qr/\.pm$/;
-
-
- # and each directory in our search path
- foreach my $searchpath (@{$self->{'search_path'}}) {
- # create the search directory in a cross platform goodness way
- my $sp = catdir($dir, (split /::/, $searchpath));
-
- # if it doesn't exist or it's not a dir then skip it
- next unless ( -e $sp && -d _ ); # Use the cached stat the second time
-
- my @files = $self->find_files($sp);
-
- # foreach one we've found
- foreach my $file (@files) {
- # untaint the file; accept .pm only
- next unless ($file) = ($file =~ /(.*$file_regex)$/);
- # parse the file to get the name
- my ($name, $directory, $suffix) = fileparse($file, $file_regex);
-
- next if (!$self->{include_editor_junk} && $self->_is_editor_junk($name));
-
- $directory = abs2rel($directory, $sp);
-
- # If we have a mixed-case package name, assume case has been preserved
- # correctly. Otherwise, root through the file to locate the case-preserved
- # version of the package name.
- my @pkg_dirs = ();
- if ( $name eq lc($name) || $name eq uc($name) ) {
- my $pkg_file = catfile($sp, $directory, "$name$suffix");
- open PKGFILE, "<$pkg_file" or die "search_paths: Can't open $pkg_file: $!";
- my $in_pod = 0;
- while ( my $line = <PKGFILE> ) {
- $in_pod = 1 if $line =~ m/^=\w/;
- $in_pod = 0 if $line =~ /^=cut/;
- next if ($in_pod || $line =~ /^=cut/); # skip pod text
- next if $line =~ /^\s*#/; # and comments
- if ( $line =~ m/^\s*package\s+(.*::)?($name)\s*;/i ) {
- @pkg_dirs = split /::/, $1 if defined $1;;
- $name = $2;
- last;
- }
- }
- close PKGFILE;
- }
-
- # then create the class name in a cross platform way
- $directory =~ s/^[a-z]://i if($^O =~ /MSWin32|dos/); # remove volume
- my @dirs = ();
- if ($directory) {
- ($directory) = ($directory =~ /(.*)/);
- @dirs = grep(length($_), splitdir($directory))
- unless $directory eq curdir();
- for my $d (reverse @dirs) {
- my $pkg_dir = pop @pkg_dirs;
- last unless defined $pkg_dir;
- $d =~ s/\Q$pkg_dir\E/$pkg_dir/i; # Correct case
- }
- } else {
- $directory = "";
- }
- my $plugin = join '::', $searchpath, @dirs, $name;
-
- next unless $plugin =~ m!(?:[a-z\d]+)[a-z\d]!i;
-
- $self->handle_finding_plugin($plugin, \@plugins)
- }
-
- # now add stuff that may have been in package
- # NOTE we should probably use all the stuff we've been given already
- # but then we can't unload it :(
- push @plugins, $self->handle_innerpackages($searchpath);
- } # foreach $searchpath
-
- return @plugins;
-}
-
-sub _is_editor_junk {
- my $self = shift;
- my $name = shift;
-
- # Emacs (and other Unix-y editors) leave temp files ending in a
- # tilde as a backup.
- return 1 if $name =~ /~$/;
- # Emacs makes these files while a buffer is edited but not yet
- # saved.
- return 1 if $name =~ /^\.#/;
- # Vim can leave these files behind if it crashes.
- return 1 if $name =~ /\.sw[po]$/;
-
- return 0;
-}
-
-sub handle_finding_plugin {
- my $self = shift;
- my $plugin = shift;
- my $plugins = shift;
- my $no_req = shift || 0;
-
- return unless $self->_is_legit($plugin);
- unless (defined $self->{'instantiate'} || $self->{'require'}) {
- push @$plugins, $plugin;
- return;
- }
-
- $self->{before_require}->($plugin) || return if defined $self->{before_require};
- unless ($no_req) {
- my $tmp = $@;
- my $res = eval { $self->_require($plugin) };
- my $err = $@;
- $@ = $tmp;
- if ($err) {
- if (defined $self->{on_require_error}) {
- $self->{on_require_error}->($plugin, $err) || return;
- } else {
- return;
- }
- }
- }
- $self->{after_require}->($plugin) || return if defined $self->{after_require};
- push @$plugins, $plugin;
-}
-
-sub find_files {
- my $self = shift;
- my $search_path = shift;
- my $file_regex = $self->{'file_regex'} || qr/\.pm$/;
-
-
- # find all the .pm files in it
- # this isn't perfect and won't find multiple plugins per file
- #my $cwd = Cwd::getcwd;
- my @files = ();
- { # for the benefit of perl 5.6.1's Find, localize topic
- local $_;
- File::Find::find( { no_chdir => 1,
- follow => $self->{'follow_symlinks'},
- wanted => sub {
- # Inlined from File::Find::Rule C< name => '*.pm' >
- return unless $File::Find::name =~ /$file_regex/;
- (my $path = $File::Find::name) =~ s#^\\./##;
- push @files, $path;
- }
- }, $search_path );
- }
- #chdir $cwd;
- return @files;
-
-}
-
-sub handle_innerpackages {
- my $self = shift;
- return () if (exists $self->{inner} && !$self->{inner});
-
- my $path = shift;
- my @plugins;
-
- foreach my $plugin (Devel::InnerPackage::list_packages($path)) {
- $self->handle_finding_plugin($plugin, \@plugins, 1);
- }
- return @plugins;
-
-}
-
-
-sub _require {
- my $self = shift;
- my $pack = shift;
- eval "CORE::require $pack";
- die ($@) if $@;
- return 1;
-}
-
-
-1;
-
-=pod
-
-=head1 NAME
-
-Module::Pluggable::Object - automatically give your module the ability to have plugins
-
-=head1 SYNOPSIS
-
-
-Simple use Module::Pluggable -
-
- package MyClass;
- use Module::Pluggable::Object;
-
- my $finder = Module::Pluggable::Object->new(%opts);
- print "My plugins are: ".join(", ", $finder->plugins)."\n";
-
-=head1 DESCRIPTION
-
-Provides a simple but, hopefully, extensible way of having 'plugins' for
-your module. Obviously this isn't going to be the be all and end all of
-solutions but it works for me.
-
-Essentially all it does is export a method into your namespace that
-looks through a search path for .pm files and turn those into class names.
-
-Optionally it instantiates those classes for you.
-
-This object is wrapped by C<Module::Pluggable>. If you want to do something
-odd or add non-general special features you're probably best to wrap this
-and produce your own subclass.
-
-=head1 OPTIONS
-
-See the C<Module::Pluggable> docs.
-
-=head1 AUTHOR
-
-Simon Wistow <simon@thegestalt.org>
-
-=head1 COPYING
-
-Copyright, 2006 Simon Wistow
-
-Distributed under the same terms as Perl itself.
-
-=head1 BUGS
-
-None known.
-
-=head1 SEE ALSO
-
-L<Module::Pluggable>
-
-=cut
-