diff options
Diffstat (limited to 'Master/tlpkg/tlperl/lib/Module')
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 - |