Test-Version-2.05000755001750001750 012767221254 13757 5ustar00ollisgollisg000000000000README100644001750001750 1065012767221254 14742 0ustar00ollisgollisg000000000000Test-Version-2.05NAME Test::Version - Check to see that version's in modules are sane VERSION version 2.05 SYNOPSIS use Test::More; use Test::Version 1.001001 qw( version_all_ok ), { is_strict => 0, has_version => 1, consistent => 1, }; # test blib or lib by default version_all_ok(); done_testing; DESCRIPTION This module's goal is to be a one stop shop for checking to see that your versions across your dist are sane. Please ensure that you use version 0.04 or later only, as earlier versions are old code and may not work correctly. Current feature list: module has a version Tests to insure that all modules checked have a VERSION defined, Can replace Test::HasVersion module has a valid version Tests to insure that all versions are valid, according to the rules of version method is_lax. To quote: The lax criteria corresponds to what is currently allowed by the version parser. All of the following formats are acceptable for dotted-decimal formats strings: v1.2 1.2345.6 v1.23_4 1.2345 1.2345_01 If you want to limit yourself to a much more narrow definition of what a version string constitutes, is_strict() is limited to version strings like the following list: v1.234.5 2.3456 you can cause your tests to fail if not strict by setting is_strict to 1 FUNCTIONS version_ok version_ok( $filename, [ $name ] ); Test a single .pm file by passing a path to the function. Checks if the module has a version, and that it is valid with is_lax. version_all_ok version_all_ok( [ $directory, [ $name ]] ); Test all modules in a directory with version_ok. By default it will check blib or lib if you haven't passed it a directory. CONFIGURATION AND ENVIRONMENT has_version use Test::Version qw( version_all_ok ), { has_version => 0 }; Allows disabling whether a module has to have a version. If set to 0 version tests will be skipped in any module where no version is found. really doesn't make sense to use with just version_ok is_strict use Test::Version { is_strict => 1 }; this allows enabling of versions is_strict checks to ensure that your version is strict. consistent use Test::Version { consistent => 1 }; Check if every module has the same version number. ignore_unindexable use Test::Version { ignore_unindexable => 0}; if you have at least Module::Metadata v1.000020 Test::Version will by default skip any files not considered is_indexable filename_match use Test::Version 2.0 { filename_match => [qr{Foo/Bar.pm$}] }; Only test files that match the given pattern. Pattern may be a list of strings, regular expressions or code references. The filename will match if it matches one or more patterns. string The file matches if it matches the pattern string exactly. regular expression The file matches if it matches the regular expression. code reference The file matches if the code reference returns a true value. The filename is passed in as the only argument to the code reference. multiple use Test::Version 2.02 { multiple => 1 }; Test each version for each package if multiple packages are found in a file. SEE ALSO The goal is to have the functionality of all of these. Test::HasVersion Test::ConsistentVersion Test::GreaterVersion If you are using Dist::Zilla there is a plugin Dist::Zilla::Plugin::Test::Version BUGS Please report any bugs or feature requests on the bugtracker website https://github.com/plicease/test-version/issues When submitting a bug or request, please include a test-file or a patch to an existing test-file that illustrates the bug or desired feature. CONTRIBUTORS * Dave Rolsky * Gabor Szabo * Karen Etheridge * Michael G. Schwern * Mike Doherty * particle AUTHORS * Graham Ollis * Caleb Cushing COPYRIGHT AND LICENSE This software is Copyright (c) 2016 by Caleb Cushing. This is free software, licensed under: The Artistic License 2.0 (GPL Compatible) Changes100644001750001750 743012767221254 15337 0ustar00ollisgollisg000000000000Test-Version-2.05Revision history for Test-Version 2.05 2016-09-17 - Bump requirement for newer version of Module::Metadata (again) Required for ignore_unindexable 2.04 2016-06-22 - Bump requirement for a newer version of Module::Metadata (the version that comes with Perl 5.14 cannot handle package block syntax) 2.03 2015-06-29 - Remove annoying warnings when version_ok called by itself GH #5 (DROLSKY) 2.02 2015-06-17 - Production release identical to 2.01_01 release 2.01_01 2015-06-15 - Added 'multiple' option to check each version inside a .pm file with multiple packages. 2.01 2015-05-19 - Fix failing test in t/all-generated.t 2.00 2015-05-06 - Added filename_match setting 1.05 2015-05-05 - New maintainer (PLICEASE) updated meta 1.004001 2014-10-20 - improved consistent check diagnostics GH #11 (SZABGAB) 1.004000 2014-10-18 - add consistent check GH #10 (SZABGAB) 1.003001 2014-09-06 - remove inline and remove _get_version, trying to skip test there won't work GH #4 (ETHER) 1.003000 2014-09-05 - skip packages unindexable by pause GH #4 (ETHER) 1.002004 2013-11-21 - fix bugs in argument handling - fix whitespace 1.002003 2013-10-14 - fix misgithap - more dist.ini updates 1.002002 2013-10-14 - fix synopsis GH #6, #7 ( plicease ) - change Dist::Zilla Plugins - remove old documentation that no longer applies 1.002001 2012-03-14 - fix metadata caused by a bug in DZP::GitHub after asking repo to be unlinked from gitpan. 1.002000 2012-01-09 - use Module::Metadata - allow disabling of 'has_version' - require at least 1 version - allow for checking that a module is_strict 1.001003 2011-12-01 - use Module::Metadata apparently it's closer to how Perl works than Module::Extract::VERSION 1.001002 2011-11-02 - fix some issues in the pod 1.001001 2011-11-01 - provide is_strict setting to replace STRICTNESS - provide has_version setting to disable that a module must always have a version - use perl decimal style semantic versioning because of bugs in EUMM with vstring versions v1.1.0 2011-08-14 - check if versions are strict - provide STRICTNESS settings to decide what to do if they aren't strict 1.0.0 2011-07-01 - Change to Semantic Versioning - Consider API Stable - No real changes since version 0.11 0.11 2011-06-18 - correct the version of version.pm that we need to depend on. is_lax was not properly exported until version 0.86 0.10 2011-06-08 - fix warning on bad api call #1 - make diagnostics human readable #1 - remove diagnostics from pod #1 - change return values #1 - improve tests #1 0.09 2011-06-07 - Test for FILE_NOT_DEFINED was not actually included in the last release. Add it. 0.08 2011-06-04 - test NO_FILE and FILE_NOT_DEFINED - document only use 0.04 or later - fix 04-all.t test that compares the arrays 0.07 2011-05-29 - more documentation - don't use diag for VERSION_OK status 0.06 2011-05-28 - update diag messages - check that $file exists - switch to Test::Tester exclusively - fix 04-all.t from failing due to array order being random 0.05 2011-05-27 - switch to Test::Tester for some tests. - update changelog for 0.04 due to leaving featurelist out 0.04 2011-05-26 - Release new codebase as a trial version - Ability to iterate through a directory checking versions with version_all_ok() - validate versions with is_lax 0.03 2011-05-26 - Maintainership passed to Caleb Cushing - Deprecate "expected" parameter to version_ok - Switch to Dist::Zilla for release management 0.02 2002-11-18 - removed rogue 'plan' statement in Version.pm, which was causing test failure 0.01 2002-11-17 - original version; created by h2xs 1.21 with options -AX Test::Version t000755001750001750 012767221254 14143 5ustar00ollisgollisg000000000000Test-Version-2.05all.t100644001750001750 107112767221254 15237 0ustar00ollisgollisg000000000000Test-Version-2.05/t#!/usr/bin/perl use 5.006; use strict; use warnings; use Test::Tester; use Test::Version version_all_ok => { ignore_unindexable => 0 }; use Test::More; my ( $premature, @results ) = run_tests( sub { version_all_ok('corpus'); } ); is( scalar(@results), 18, 'correct number of results' ); my @oks; foreach my $result ( @results ) { push @oks, $result->{ok}; } my $sorted = [ sort @oks ]; my $expected = [ ( 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ) ]; note( 'unsorted oks: ', @oks ); is_deeply( $sorted, $expected, 'oks are ok' ); done_testing; LICENSE100644001750001750 2152212767221254 15067 0ustar00ollisgollisg000000000000Test-Version-2.05This software is Copyright (c) 2016 by Caleb Cushing. This is free software, licensed under: The Artistic License 2.0 (GPL Compatible) The Artistic License 2.0 Copyright (c) 2000-2006, The Perl Foundation. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble This license establishes the terms under which a given free software Package may be copied, modified, distributed, and/or redistributed. The intent is that the Copyright Holder maintains some artistic control over the development of that Package while still keeping the Package available as open source and free software. You are always permitted to make arrangements wholly outside of this license directly with the Copyright Holder of a given Package. If the terms of this license do not permit the full use that you propose to make of the Package, you should contact the Copyright Holder and seek a different licensing arrangement. Definitions "Copyright Holder" means the individual(s) or organization(s) named in the copyright notice for the entire Package. "Contributor" means any party that has contributed code or other material to the Package, in accordance with the Copyright Holder's procedures. "You" and "your" means any person who would like to copy, distribute, or modify the Package. "Package" means the collection of files distributed by the Copyright Holder, and derivatives of that collection and/or of those files. A given Package may consist of either the Standard Version, or a Modified Version. "Distribute" means providing a copy of the Package or making it accessible to anyone else, or in the case of a company or organization, to others outside of your company or organization. "Distributor Fee" means any fee that you charge for Distributing this Package or providing support for this Package to another party. It does not mean licensing fees. "Standard Version" refers to the Package if it has not been modified, or has been modified only in ways explicitly requested by the Copyright Holder. "Modified Version" means the Package, if it has been changed, and such changes were not explicitly requested by the Copyright Holder. "Original License" means this Artistic License as Distributed with the Standard Version of the Package, in its current version or as it may be modified by The Perl Foundation in the future. "Source" form means the source code, documentation source, and configuration files for the Package. "Compiled" form means the compiled bytecode, object code, binary, or any other form resulting from mechanical transformation or translation of the Source form. Permission for Use and Modification Without Distribution (1) You are permitted to use the Standard Version and create and use Modified Versions for any purpose without restriction, provided that you do not Distribute the Modified Version. Permissions for Redistribution of the Standard Version (2) You may Distribute verbatim copies of the Source form of the Standard Version of this Package in any medium without restriction, either gratis or for a Distributor Fee, provided that you duplicate all of the original copyright notices and associated disclaimers. At your discretion, such verbatim copies may or may not include a Compiled form of the Package. (3) You may apply any bug fixes, portability changes, and other modifications made available from the Copyright Holder. The resulting Package will still be considered the Standard Version, and as such will be subject to the Original License. Distribution of Modified Versions of the Package as Source (4) You may Distribute your Modified Version as Source (either gratis or for a Distributor Fee, and with or without a Compiled form of the Modified Version) provided that you clearly document how it differs from the Standard Version, including, but not limited to, documenting any non-standard features, executables, or modules, and provided that you do at least ONE of the following: (a) make the Modified Version available to the Copyright Holder of the Standard Version, under the Original License, so that the Copyright Holder may include your modifications in the Standard Version. (b) ensure that installation of your Modified Version does not prevent the user installing or running the Standard Version. In addition, the Modified Version must bear a name that is different from the name of the Standard Version. (c) allow anyone who receives a copy of the Modified Version to make the Source form of the Modified Version available to others under (i) the Original License or (ii) a license that permits the licensee to freely copy, modify and redistribute the Modified Version using the same licensing terms that apply to the copy that the licensee received, and requires that the Source form of the Modified Version, and of any works derived from it, be made freely available in that license fees are prohibited but Distributor Fees are allowed. Distribution of Compiled Forms of the Standard Version or Modified Versions without the Source (5) You may Distribute Compiled forms of the Standard Version without the Source, provided that you include complete instructions on how to get the Source of the Standard Version. Such instructions must be valid at the time of your distribution. If these instructions, at any time while you are carrying out such distribution, become invalid, you must provide new instructions on demand or cease further distribution. If you provide valid instructions or cease distribution within thirty days after you become aware that the instructions are invalid, then you do not forfeit any of your rights under this license. (6) You may Distribute a Modified Version in Compiled form without the Source, provided that you comply with Section 4 with respect to the Source of the Modified Version. Aggregating or Linking the Package (7) You may aggregate the Package (either the Standard Version or Modified Version) with other packages and Distribute the resulting aggregation provided that you do not charge a licensing fee for the Package. Distributor Fees are permitted, and licensing fees for other components in the aggregation are permitted. The terms of this license apply to the use and Distribution of the Standard or Modified Versions as included in the aggregation. (8) You are permitted to link Modified and Standard Versions with other works, to embed the Package in a larger work of your own, or to build stand-alone binary or bytecode versions of applications that include the Package, and Distribute the result without restriction, provided the result does not expose a direct interface to the Package. Items That are Not Considered Part of a Modified Version (9) Works (including, but not limited to, modules and scripts) that merely extend or make use of the Package, do not, by themselves, cause the Package to be a Modified Version. In addition, such works are not considered parts of the Package itself, and are not subject to the terms of this license. General Provisions (10) Any use, modification, and distribution of the Standard or Modified Versions is governed by this Artistic License. By using, modifying or distributing the Package, you accept this license. Do not use, modify, or distribute the Package, if you do not accept this license. (11) If your Modified Version has been derived from a Modified Version made by someone other than you, you are nevertheless required to ensure that your Modified Version complies with the requirements of this license. (12) This license does not grant you the right to use any trademark, service mark, tradename, or logo of the Copyright Holder. (13) This license includes the non-exclusive, worldwide, free-of-charge patent license to make, have made, use, offer to sell, sell, import and otherwise transfer the Package with respect to any patent claims licensable by the Copyright Holder that are necessarily infringed by the Package. If you institute patent litigation (including a cross-claim or counterclaim) against any party alleging that the Package constitutes direct or contributory patent infringement, then this Artistic License to you shall terminate on the date that such litigation is filed. (14) Disclaimer of Warranty: THE PACKAGE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES. THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT PERMITTED BY YOUR LOCAL LAW. UNLESS REQUIRED BY LAW, NO COPYRIGHT HOLDER OR CONTRIBUTOR WILL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THE PACKAGE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. pass.t100644001750001750 60212767221254 15414 0ustar00ollisgollisg000000000000Test-Version-2.05/t#!/usr/bin/perl use 5.006; use strict; use warnings; use Test::Tester tests => 8; use Test::More; use Test::Version version_ok => { ignore_unindexable => 0 }; my $ret; check_test( sub { $ret = version_ok( 'corpus/pass/Foo.pm' ); }, { ok => 1, name => q[check version in 'corpus/pass/Foo.pm'], diag => '', }, 'version ok' ); ok $ret, "version_ok() returned true on pass"; fail.t100644001750001750 74612767221254 15372 0ustar00ollisgollisg000000000000Test-Version-2.05/t#!/usr/bin/perl use 5.006; use strict; use warnings; use Test::Tester tests => 8; use Test::More; use Test::Version version_ok => { ignore_unindexable => 0 }; my $ret; check_test( sub { $ret = version_ok( 'corpus/fail/FooBarBaz.pm' ); }, { ok => 0, name => q[check version in 'corpus/fail/FooBarBaz.pm'], diag => qq[The version 'v.Inf' found in 'corpus/fail/FooBarBaz.pm' (FooBarBaz) is invalid.], }, 'version invalid' ); ok !$ret, "version_ok() returned false on fail"; bare.t100644001750001750 45412767221254 15364 0ustar00ollisgollisg000000000000Test-Version-2.05/tuse strict; use warnings; use Test::More tests => 1; use Test::Version 'version_ok'; # if there are warnings emitted from calling # version_ok without version_all_ok then # they should be visible when testing. # a la https://github.com/plicease/Test-Version/pull/5 version_ok 'corpus/pass/Foo.pm'; META.yml100644001750001750 255612767221254 15321 0ustar00ollisgollisg000000000000Test-Version-2.05--- abstract: "Check to see that version's in modules are sane" author: - 'Graham Ollis ' - 'Caleb Cushing ' build_requires: ExtUtils::MakeMaker: '0' File::Spec: '0' IO::Handle: '0' IPC::Open3: '0' Test::Exception: '0' Test::More: '0.94' Test::Tester: '0' blib: '1.01' configure_requires: ExtUtils::MakeMaker: '0' dynamic_config: 0 generated_by: 'Dist::Zilla version 6.007, CPAN::Meta::Converter version 2.150010' license: artistic_2 meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: '1.4' name: Test-Version no_index: directory: - corpus file: - perlcritic.rc requires: Carp: '0' Exporter: '0' File::Find::Rule::Perl: '0' Module::Metadata: '1.000020' Test::Builder: '0' Test::More: '0.94' parent: '0' perl: '5.006' strict: '0' version: '0.86' warnings: '0' resources: bugtracker: https://github.com/plicease/test-version/issues homepage: https://metacpan.org/dist/Test-Version repository: git://github.com/plicease/test-version.git version: '2.05' x_contributors: - 'Dave Rolsky ' - 'Gabor Szabo ' - 'Karen Etheridge ' - 'Michael G. Schwern ' - 'Mike Doherty ' - 'particle ' x_serialization_backend: 'YAML::Tiny version 1.69' MANIFEST100644001750001750 230012767221254 15164 0ustar00ollisgollisg000000000000Test-Version-2.05# This file was automatically generated by Dist::Zilla::Plugin::Manifest v6.007. CONTRIBUTING Changes LICENSE MANIFEST META.json META.yml Makefile.PL README corpus/consistent/Bar.pm corpus/consistent/Foo.pm corpus/fail/FooBarBaz.pm corpus/generated/Foo.pm corpus/generated/Foo/ConfigData.pm corpus/generated/Foo/Install/Files.pm corpus/inconsistent/Bar.pm corpus/inconsistent/Foo.pm corpus/missing/Bar.pm corpus/missing/Baz.pm corpus/missing/Foo.pm corpus/multiple-inconsistent/Foo.pm corpus/multiple-missing/Foo.pm corpus/multiple/Foo.pm corpus/not_strict/NotStrict.pm corpus/noversion/FooBar.pm corpus/pass/Foo.pm lib/Test/Version.pm perlcritic.rc t/00-compile.t t/00-report-prereqs.dd t/00-report-prereqs.t t/all-generated.t t/all-has-version-false.t t/all.t t/at-least-one-version.t t/bare.t t/consistent.t t/fail.t t/file-not-defined.t t/inconsistent.t t/missing-has-version.t t/missing.t t/multiple-inconsistent.t t/multiple.t t/no-file.t t/noversion.t t/pass.t t/strict.t xt/author/critic.t xt/author/eol.t xt/author/pod-coverage.t xt/author/pod-syntax.t xt/author/portability.t xt/author/test-version.t xt/release/cpan-changes.t xt/release/dist-manifest.t xt/release/meta-json.t xt/release/minimum-version.t META.json100644001750001750 533412767221254 15466 0ustar00ollisgollisg000000000000Test-Version-2.05{ "abstract" : "Check to see that version's in modules are sane", "author" : [ "Graham Ollis ", "Caleb Cushing " ], "dynamic_config" : 0, "generated_by" : "Dist::Zilla version 6.007, CPAN::Meta::Converter version 2.150010", "license" : [ "artistic_2" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : 2 }, "name" : "Test-Version", "no_index" : { "directory" : [ "corpus" ], "file" : [ "perlcritic.rc" ] }, "prereqs" : { "configure" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "develop" : { "requires" : { "English" : "0", "Pod::Coverage::TrustPod" : "0", "Test::CPAN::Changes" : "0.19", "Test::CPAN::Meta::JSON" : "0.16", "Test::EOL" : "0", "Test::More" : "0.96", "Test::Pod" : "1.41", "Test::Pod::Coverage" : "1.08", "Test::Portability::Files" : "0", "Test::Version" : "1" } }, "runtime" : { "requires" : { "Carp" : "0", "Exporter" : "0", "File::Find::Rule::Perl" : "0", "Module::Metadata" : "1.000020", "Test::Builder" : "0", "Test::More" : "0.94", "parent" : "0", "perl" : "5.006", "strict" : "0", "version" : "0.86", "warnings" : "0" } }, "test" : { "recommends" : { "CPAN::Meta" : "2.120900" }, "requires" : { "ExtUtils::MakeMaker" : "0", "File::Spec" : "0", "IO::Handle" : "0", "IPC::Open3" : "0", "Test::Exception" : "0", "Test::More" : "0.94", "Test::Tester" : "0", "blib" : "1.01" } } }, "release_status" : "stable", "resources" : { "bugtracker" : { "web" : "https://github.com/plicease/test-version/issues" }, "homepage" : "https://metacpan.org/dist/Test-Version", "repository" : { "type" : "git", "url" : "git://github.com/plicease/test-version.git", "web" : "https://github.com/plicease/test-version" } }, "version" : "2.05", "x_contributors" : [ "Dave Rolsky ", "Gabor Szabo ", "Karen Etheridge ", "Michael G. Schwern ", "Mike Doherty ", "particle " ], "x_serialization_backend" : "Cpanel::JSON::XS version 3.0217" } strict.t100644001750001750 101712767221254 15777 0ustar00ollisgollisg000000000000Test-Version-2.05/t#!/usr/bin/perl use 5.006; use strict; use warnings; use Test::Tester; use Test::More; use Test::Version version_ok => { is_strict => 1, ignore_unindexable => 0, }; my $ret; check_test( sub { $ret = version_ok( 'corpus/not_strict/NotStrict.pm' ); }, { ok => 0, name => q[check version in 'corpus/not_strict/NotStrict.pm'], diag => qq[The version '0.1.0' found in 'corpus/not_strict/NotStrict.pm' (NotStrict) is not strict.], }, ); is $ret, 0, "version_ok() returns false unless strict"; done_testing; no-file.t100644001750001750 42012767221254 15775 0ustar00ollisgollisg000000000000Test-Version-2.05/t#!/usr/bin/perl use 5.006; use strict; use warnings; use Test::More; use Test::Exception; use Test::Version version_ok => { ignore_unindexable => 0 }; dies_ok { version_ok( 'corpus/nofile/nofile.pm' ) } 'file "corpus/nofile/nofile.pm" does not exist' ; done_testing; missing.t100644001750001750 76012767221254 16124 0ustar00ollisgollisg000000000000Test-Version-2.05/t#!/usr/bin/perl use 5.006; use strict; use warnings; use Test::Tester; use Test::More; use Test::Version version_all_ok => { has_version => 0, ignore_unindexable => 0, consistent => 1, }; my ( $premature, @results ) = run_tests( sub { version_all_ok('corpus/missing'); } ); is( scalar(@results), 4, 'correct number of results' ); my @oks = map { $_->{ok} } @results; note( 'unsorted oks: ', @oks ); is_deeply( [sort @oks], [0, 1, 1, 1], 'oks are ok' ); done_testing; Makefile.PL100644001750001750 347412767221254 16022 0ustar00ollisgollisg000000000000Test-Version-2.05# This file was automatically generated by Dist::Zilla::Plugin::MakeMaker v6.007. use strict; use warnings; use 5.006; use ExtUtils::MakeMaker; my %WriteMakefileArgs = ( "ABSTRACT" => "Check to see that version's in modules are sane", "AUTHOR" => "Graham Ollis , Caleb Cushing ", "CONFIGURE_REQUIRES" => { "ExtUtils::MakeMaker" => 0 }, "DISTNAME" => "Test-Version", "LICENSE" => "artistic_2", "MIN_PERL_VERSION" => "5.006", "NAME" => "Test::Version", "PREREQ_PM" => { "Carp" => 0, "Exporter" => 0, "File::Find::Rule::Perl" => 0, "Module::Metadata" => "1.000020", "Test::Builder" => 0, "Test::More" => "0.94", "parent" => 0, "strict" => 0, "version" => "0.86", "warnings" => 0 }, "TEST_REQUIRES" => { "ExtUtils::MakeMaker" => 0, "File::Spec" => 0, "IO::Handle" => 0, "IPC::Open3" => 0, "Test::Exception" => 0, "Test::More" => "0.94", "Test::Tester" => 0, "blib" => "1.01" }, "VERSION" => "2.05", "test" => { "TESTS" => "t/*.t" } ); my %FallbackPrereqs = ( "Carp" => 0, "Exporter" => 0, "ExtUtils::MakeMaker" => 0, "File::Find::Rule::Perl" => 0, "File::Spec" => 0, "IO::Handle" => 0, "IPC::Open3" => 0, "Module::Metadata" => "1.000020", "Test::Builder" => 0, "Test::Exception" => 0, "Test::More" => "0.94", "Test::Tester" => 0, "blib" => "1.01", "parent" => 0, "strict" => 0, "version" => "0.86", "warnings" => 0 ); unless ( eval { ExtUtils::MakeMaker->VERSION(6.63_03) } ) { delete $WriteMakefileArgs{TEST_REQUIRES}; delete $WriteMakefileArgs{BUILD_REQUIRES}; $WriteMakefileArgs{PREREQ_PM} = \%FallbackPrereqs; } delete $WriteMakefileArgs{CONFIGURE_REQUIRES} unless eval { ExtUtils::MakeMaker->VERSION(6.52) }; WriteMakefile(%WriteMakefileArgs); CONTRIBUTING100644001750001750 2220212767221254 15710 0ustar00ollisgollisg000000000000Test-Version-2.05Checklist (and a short version for the impatient): Commits: * make sure your work applies cleanly to branch master, it is not the default branch. `git checkout * master`, you are welcome to run tests from build/master to avoid needing Dist::Zilla * make commits of logical units * check for unnecessary whitespace with "git diff --check" before committing * do not check in commented out code or unneeded files * the first line of the commit message should be a short description and should skip the full stop * the body should provide a meaningful commit message, which: * uses the imperative, present tense: "change", not "changed" or "changes". * includes motivation for the change, and contrasts its implementation with previous behaviour * if you want your work included in the main repository, add a "Signed-off-by: Your Name " line to the commit message (or just use the option "-s" when committing) to confirm that you agree to the Developer's Certificate of Origin * make sure that you have tests for the bug you are fixing * make sure that the test suite passes after your commit. This distribution is built with Dist::Zilla ensure that running `dzil test` passes. You are responsible for ensuring that generated, hand written and author tests pass. Patch: * if you change, add, or remove any features or make some other user interface change, the associated documentation should be updated as well. * if your name is not writable in ASCII, make sure that you send the patch in the correct encoding. Long version: I started reading over the SubmittingPatches document for git, primarily because I wanted to have a document similar to it for my projects to make sure people understand what they are doing when they write "Signed-off-by" line. But the patch submission requirements are a lot more relaxed here on the technical/contents front, because my projects are thousand times smaller ;-). So here is only the relevant bits. (0) Decide what to base your work on. In general, always base your work on the oldest branch that your change is relevant to. * A bugfix should be based on 'maint' in general. If the bug is not present in 'maint', base it on 'master'. For a bug that's not yet in 'master', find the topic that introduces the regression, and base your work on the tip of the topic. If a 'maint' branch is not present base it on master. * A new feature should be based on 'master' in general. If the new feature depends on a topic that is in 'pu', but not in 'master', base your work on the tip of that topic. * Corrections and enhancements to a topic not yet in 'master' should be based on the tip of that topic. If the topic has not been merged to 'next', it's alright to add a note to squash minor corrections into the series. * In the exceptional case that a new feature depends on several topics not in 'master', start working on 'next' or 'pu' privately and send out patches for discussion. Before the final merge, you may have to wait until some of the dependent topics graduate to 'master', and rebase your work. To find the tip of a topic branch, run "git log --first-parent master..pu" and look for the merge commit. The second parent of this commit is the tip of the topic branch. (1) Make separate commits for logically separate changes. Unless your patch is really trivial, you should not be sending out a patch that was generated between your working tree and your commit head. Instead, always make a commit with complete commit message and generate a series of patches from your repository. It is a good discipline. Describe the technical detail of the change(s). If your description starts to get too long, that's a sign that you probably need to split up your commit to finer grained pieces. That being said, patches which plainly describe the things that help reviewers check the patch, and future maintainers understand the code, are the most beautiful patches. Descriptions that summarise the point in the subject well, and describe the motivation for the change, the approach taken by the change, and if relevant how this differs substantially from the prior version, can be found on Usenet archives back into the late 80's. Consider it like good Netiquette, but for code. Oh, another thing. I am picky about whitespaces. Make sure your changes do not trigger errors with the sample pre-commit hook shipped in templates/hooks--pre-commit. To help ensure this does not happen, run git diff --check on your changes before you commit. (2) Generate your patch using git tools out of your commits. git based diff tools (git, Cogito, and StGIT included) generate unidiff which is the preferred format. You do not have to be afraid to use -M option to "git diff" or "git format-patch", if your patch involves file renames. The receiving end can handle them just fine. Please make sure your patch does not include any extra files which do not belong in a patch submission. Make sure to review your patch after generating it, to ensure accuracy. Before sending out, please make sure it cleanly applies to the "master" branch head. If you are preparing a work based on "next" branch, that is fine, but please mark it as such. (4) Sign your work To improve tracking of who did what, we've borrowed the "sign-off" procedure from the Linux kernel project on patches that are being emailed around. Although this project is a lot smaller it is a good discipline to follow it. The sign-off is a simple line at the end of the explanation for the patch, which certifies that you wrote it or otherwise have the right to pass it on as a open-source patch. The rules are pretty simple: if you can certify the below: Developer's Certificate of Origin 1.1 By making a contribution to this project, I certify that: (a) The contribution was created in whole or in part by me and I have the right to submit it under the open source license indicated in the file; or (b) The contribution is based upon previous work that, to the best of my knowledge, is covered under an appropriate open source license and I have the right under that license to submit that work with modifications, whether created in whole or in part by me, under the same open source license (unless I am permitted to submit under a different license), as indicated in the file; or (c) The contribution was provided directly to me by some other person who certified (a), (b) or (c) and I have not modified it. (d) I understand and agree that this project and the contribution are public and that a record of the contribution (including all personal information I submit with it, including my sign-off) is maintained indefinitely and may be redistributed consistent with this project or the open source license(s) involved. then you just add a line saying Signed-off-by: Random J Developer This line can be automatically added by git if you run the git-commit command with the -s option. Notice that you can place your own Signed-off-by: line when forwarding somebody else's patch with the above rules for D-C-O. Indeed you are encouraged to do so. Also notice that a real name is used in the Signed-off-by: line. Please don't hide your real name. Some people also put extra tags at the end. "Acked-by:" says that the patch was reviewed by the person who is more familiar with the issues and the area the patch attempts to modify. "Tested-by:" says the patch was tested by the person and found to have the desired effect. An ideal patch flow Here is an ideal patch flow for this project the current maintainer suggests to the contributors: 0. You come up with an itch. You code it up. 1. Send it to the bug tracker and cc people who may need to know about the change. The people who may need to know are the ones whose code you are butchering. These people happen to be the ones who are most likely to be knowledgeable enough to help you, but they have no obligation to help you (i.e. you ask for help, don't demand). "git log -p -- $area_you_are_modifying" would help you find out who they are. 2. You get comments and suggestions for improvements. You may even get them in a "on top of your change" patch form. 3. Polish, refine, and re-send to the the people who spend their time to improve your patch. Go back to step (2). 4. A topic branch is created with the patch and is merged to 'next', and cooked further and eventually graduates to 'master'. In any time between the (2)-(3) cycle, the maintainer may pick it up from the list and queue it to 'pu', in order to make it easier for people play with it without having to pick up and apply the patch to their trees themselves. Know the status of your patch after submission * You can use Git itself to find out when your patch is merged in master. 'git pull --rebase' will automatically skip already-applied patches, and will let you know. This works only if you rebase on top of the branch in which your patch has been merged (i.e. it will not tell you if your patch is merged in pu if you rebase on top of master). multiple.t100644001750001750 233012767221254 16321 0ustar00ollisgollisg000000000000Test-Version-2.05/t#!/usr/bin/perl use 5.006; use strict; use warnings; use Test::Tester tests => 3; use Test::More; use Test::Version version_ok => { multiple => 1, ignore_unindexable => 0, }; subtest 'multiple, good' => sub { my $ret; check_test( sub { $ret = version_ok( 'corpus/multiple/Foo.pm' ); }, { ok => 1, name => q[check version in 'corpus/multiple/Foo.pm'], diag => '', }, 'version ok' ); ok $ret, "version_ok() returned true on pass"; }; subtest 'multiple, missing' => sub { my $ret; check_test( sub { $ret = version_ok( 'corpus/multiple-missing/Foo.pm' ); }, { ok => 0, name => q[check version in 'corpus/multiple-missing/Foo.pm'], diag => 'No version was found in \'corpus/multiple-missing/Foo.pm\' (Foo::Bar).', }, 'version ok' ); ok !$ret, "version_ok() returned false on fail"; }; subtest 'multiple, inconsistent' => sub { my $ret; check_test( sub { $ret = version_ok( 'corpus/multiple-inconsistent/Foo.pm' ); }, { ok => 1, name => q[check version in 'corpus/multiple-inconsistent/Foo.pm'], diag => '', }, 'version ok' ); ok $ret, "version_ok() returned true on pass"; }; perlcritic.rc100644001750001750 12212767221254 16501 0ustar00ollisgollisg000000000000Test-Version-2.05severity = 3 verbose = 9 [Subroutines::ProhibitExcessComplexity] max_mccabe = 40 noversion.t100644001750001750 60112767221254 16467 0ustar00ollisgollisg000000000000Test-Version-2.05/t#!/usr/bin/perl use 5.006; use strict; use warnings; use Test::Tester tests => 7; use Test::Version version_ok => { ignore_unindexable => 0 }; check_test( sub { version_ok( 'corpus/noversion/FooBar.pm' ); }, { ok => 0, name => q[check version in 'corpus/noversion/FooBar.pm'], diag => q[No version was found in 'corpus/noversion/FooBar.pm' (FooBar).], }, 'no version' ); consistent.t100644001750001750 76012767221254 16644 0ustar00ollisgollisg000000000000Test-Version-2.05/t#!/usr/bin/perl use 5.006; use strict; use warnings; use Test::Tester; use Test::More; use Test::Version version_all_ok => { has_version => 0, ignore_unindexable => 0, consistent => 1, }; my ( $premature, @results ) = run_tests( sub { version_all_ok('corpus/consistent'); } ); is( scalar(@results), 3, 'correct number of results' ); my @oks = map { $_->{ok} } @results; note( 'unsorted oks: ', @oks ); is_deeply( [sort @oks], [1, 1, 1], 'oks are ok' ); done_testing; 00-compile.t100644001750001750 233112767221254 16334 0ustar00ollisgollisg000000000000Test-Version-2.05/tuse 5.006; use strict; use warnings; # this test was generated with Dist::Zilla::Plugin::Test::Compile 2.054 use Test::More; plan tests => 1 + ($ENV{AUTHOR_TESTING} ? 1 : 0); my @module_files = ( 'Test/Version.pm' ); # no fake home requested my $inc_switch = -d 'blib' ? '-Mblib' : '-Ilib'; use File::Spec; use IPC::Open3; use IO::Handle; open my $stdin, '<', File::Spec->devnull or die "can't open devnull: $!"; my @warnings; for my $lib (@module_files) { # see L my $stderr = IO::Handle->new; my $pid = open3($stdin, '>&STDERR', $stderr, $^X, $inc_switch, '-e', "require q[$lib]"); binmode $stderr, ':crlf' if $^O eq 'MSWin32'; my @_warnings = <$stderr>; waitpid($pid, 0); is($?, 0, "$lib loaded ok"); shift @_warnings if @_warnings and $_warnings[0] =~ /^Using .*\bblib/ and not eval { require blib; blib->VERSION('1.01') }; if (@_warnings) { warn @_warnings; push @warnings, @_warnings; } } is(scalar(@warnings), 0, 'no warnings found') or diag 'got warnings: ', ( Test::More->can('explain') ? Test::More::explain(\@warnings) : join("\n", '', @warnings) ) if $ENV{AUTHOR_TESTING}; author000755001750001750 012767221254 15635 5ustar00ollisgollisg000000000000Test-Version-2.05/xteol.t100644001750001750 132112767221254 16736 0ustar00ollisgollisg000000000000Test-Version-2.05/xt/authoruse strict; use warnings; # this test was generated with Dist::Zilla::Plugin::Test::EOL 0.19 use Test::More 0.88; use Test::EOL; my @files = ( 'lib/Test/Version.pm', 't/00-compile.t', 't/00-report-prereqs.dd', 't/00-report-prereqs.t', 't/all-generated.t', 't/all-has-version-false.t', 't/all.t', 't/at-least-one-version.t', 't/bare.t', 't/consistent.t', 't/fail.t', 't/file-not-defined.t', 't/inconsistent.t', 't/missing-has-version.t', 't/missing.t', 't/multiple-inconsistent.t', 't/multiple.t', 't/no-file.t', 't/noversion.t', 't/pass.t', 't/strict.t' ); eol_unix_ok($_, { trailing_whitespace => 1 }) foreach @files; done_testing; inconsistent.t100644001750001750 76212767221254 17175 0ustar00ollisgollisg000000000000Test-Version-2.05/t#!/usr/bin/perl use 5.006; use strict; use warnings; use Test::Tester; use Test::More; use Test::Version version_all_ok => { has_version => 0, ignore_unindexable => 0, consistent => 1, }; my ( $premature, @results ) = run_tests( sub { version_all_ok('corpus/inconsistent'); } ); is( scalar(@results), 3, 'correct number of results' ); my @oks = map { $_->{ok} } @results; note( 'unsorted oks: ', @oks ); is_deeply( [sort @oks], [0, 1, 1], 'oks are ok' ); done_testing; all-generated.t100644001750001750 320212767221254 17171 0ustar00ollisgollisg000000000000Test-Version-2.05/tuse 5.006; use strict; use warnings; use Test::Tester; use Test::Version qw( version_all_ok ); use Test::More tests => 5; subtest 'do not skip files by default' => sub { plan tests => 1; my(undef, @results) = run_tests( sub { version_all_ok 'corpus/generated'; }, ); #is scalar @results, 7, 'corect number of results'; my @fail = sort map { $_->{name} } grep { ! $_->{ok} } @results; is_deeply \@fail, ["check version in 'corpus/generated/Foo/ConfigData.pm'","check version in 'corpus/generated/Foo/Install/Files.pm'"], 'error in expected modules'; foreach my $result (@results) { my $name = $result->{name} || $result->{reason}; my $status = $result->{type} eq 'skip' ? 'SKIP' : $result->{ok} ? 'PASS' : 'FAIL'; note "$status $name"; } }; my %patterns = ( string => 'corpus/generated/Foo.pm', '[string]' => ['corpus/generated/Foo.pm'], regex => qr/generated\/Foo\.pm$/, sub => sub { $_[0] eq 'corpus/generated/Foo.pm' }, ); while(my($pattern_type, $pattern) = each %patterns) { subtest "match_filename $pattern_type" => sub { plan tests => 2; Test::Version->import({filename_match => $pattern}); my(undef, @results) = run_tests( sub { version_all_ok 'corpus/generated'; }, ); is scalar(grep { ! $_->{ok} } @results), 0, 'no failures'; is scalar(grep { $_->{ok} && $_->{type} eq '' } @results), 2, 'two passes'; foreach my $result (@results) { my $name = $result->{name} || $result->{reason}; my $status = $result->{type} eq 'skip' ? 'SKIP' : $result->{ok} ? 'PASS' : 'FAIL'; note "$status $name"; } } }; pass000755001750001750 012767221254 16161 5ustar00ollisgollisg000000000000Test-Version-2.05/corpusFoo.pm100644001750001750 6112767221254 17337 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/passpackage Foo; BEGIN { our $VERSION = '1.0'; } 1; critic.t100644001750001750 43512767221254 17421 0ustar00ollisgollisg000000000000Test-Version-2.05/xt/author#!perl use strict; use warnings; use Test::More; use English qw(-no_match_vars); eval "use Test::Perl::Critic"; plan skip_all => 'Test::Perl::Critic required to criticise code' if $@; Test::Perl::Critic->import( -profile => "perlcritic.rc" ) if -e "perlcritic.rc"; all_critic_ok(); Test000755001750001750 012767221254 15365 5ustar00ollisgollisg000000000000Test-Version-2.05/libVersion.pm100644001750001750 2455212767221254 17540 0ustar00ollisgollisg000000000000Test-Version-2.05/lib/Testpackage Test::Version; use 5.006; use strict; use warnings; use Carp; our $VERSION = '2.05'; # VERSION use parent 'Exporter'; use Test::Builder; use version 0.86 qw( is_lax is_strict ); use File::Find::Rule::Perl; use Test::More; use Module::Metadata 1.000020; our @EXPORT = qw( version_all_ok ); ## no critic (Modules::ProhibitAutomaticExportation) our @EXPORT_OK = qw( version_ok ); my $cfg; sub import { ## no critic qw( Subroutines::RequireArgUnpacking Subroutines::RequireFinalReturn ) my @exports; foreach my $param ( @_ ) { unless ( ref( $param ) eq 'HASH' ) { push @exports, $param; } else { $cfg = $param } } $cfg->{is_strict} = defined $cfg->{is_strict} ? $cfg->{is_strict} : 0 ; $cfg->{has_version} = defined $cfg->{has_version} ? $cfg->{has_version} : 1 ; $cfg->{consistent} = defined $cfg->{consistent} ? $cfg->{consistent} : 0 ; $cfg->{filename_match} = defined $cfg->{filename_match} ? $cfg->{filename_match} : [] ; $cfg->{multiple} = defined $cfg->{multiple} ? $cfg->{multiple} : 0 ; unless(ref($cfg->{filename_match}) eq 'ARRAY') { $cfg->{filename_match} = [$cfg->{filename_match}]; } my $mmv = version->parse( $Module::Metadata::VERSION ); my $rec = version->parse( '1.000020' ); if ( $mmv >= $rec && ! defined $cfg->{ignore_unindexable} ) { $cfg->{ignore_unindexable} = 1; } __PACKAGE__->export_to_level( 1, @exports ); } my $version_counter = 0; my $version_number; my $consistent = 1; my %versions; my $test = Test::Builder->new; our $_IN_VERSION_ALL_OK = 0; sub version_ok { my ( $file, $name ) = @_; $file ||= ''; $name ||= "check version in '$file'"; croak 'No file passed to version_ok().' unless $file; croak "'$file' doesn't exist." unless -e $file; my $info = Module::Metadata->new_from_file( $file ); if ( $cfg->{ignore_unindexable} && ! $info->is_indexable) { $test->skip( "$file not indexable" ); return 0; } if(@{ $cfg->{filename_match} } > 0) { my $match = 0; foreach my $pattern (@{ $cfg->{filename_match} }) { if(ref($pattern) eq 'Regexp') { $match = 1 if $file =~ $pattern; } elsif(ref($pattern) eq 'CODE') { $match = 1 if $pattern->($file); } else { $match = 1 if $file eq $pattern; } last if $match; } unless ($match) { $test->skip( "$file does not match filename_match" ); return 0; } } my $ok = 1; my @diag; my @packages = $cfg->{multiple} ? $info->packages_inside : ($info->name); unless($_IN_VERSION_ALL_OK) { $consistent = 1; $version_number = undef; } unless($cfg->{has_version}) { @packages = grep { $info->version($_) } @packages; unless(@packages) { $test->skip(qq{No versions were found in "$file" and has_version is false}); $consistent = 0; $versions{$file}->{$info->name} = undef; return 1; } } unless(@packages) { $ok = 0; push @diag, "No packages found in '$file'"; } foreach my $package (@packages) { my $version = $info->version($package); $versions{$file}->{$package} = $version; if (not defined $version) { $consistent = 0; } $version_counter++; unless ( $version ) { $ok = 0; push @diag, "No version was found in '$file' ($package)."; next; } unless (defined $version_number) { $version_number = $version; } if ($version ne $version_number) { $consistent = 0; } unless ( is_lax( $version ) ) { $ok = 0; push @diag, "The version '$version' found in '$file' ($package) is invalid."; next; } if ( $cfg->{is_strict} ) { unless ( is_strict( $version ) ) { $ok = 0; push @diag, "The version '$version' found in '$file' ($package) is not strict."; next; } } } unless($_IN_VERSION_ALL_OK) { if($ok && ! $consistent && $cfg->{consistent}) { $ok = 0; push @diag, "The versions found in '$file' are inconsistent."; } } $test->ok( $ok, $name ); $test->diag($_) for @diag; return $ok; } sub version_all_ok { my ( $dir, $name ) = @_; $version_counter = 0; $version_number = undef; $consistent = 1; %versions = (); $dir = defined $dir ? $dir : -d 'blib' ? 'blib' : 'lib' ; croak $dir . ' does not exist, or is not a directory' unless -d $dir; # Report failure location correctly - GH #1 local $Test::Builder::Level = $Test::Builder::Level + 1; ## no critic (Variables::ProhibitPackageVars) $name ||= "all modules in $dir have valid versions"; my @files = File::Find::Rule->perl_module->in( $dir ); { local $_IN_VERSION_ALL_OK = 1; foreach my $file ( @files ) { version_ok( $file ); } } if ($cfg->{consistent} and not $consistent) { $test->ok( 0, $name ); $test->diag('The version numbers in this distribution are not the same'); foreach my $file (sort keys %versions) { foreach my $package (sort keys %{ $versions{$file} }) { my $version = $versions{$file}->{$package}; $test->diag(sprintf "%10s %s (%s)", defined $version ? $version : 'undef', $file, $package); } } return; } # has at least 1 version in the dist if ( not $cfg->{has_version} and $version_counter < 1 ) { $test->ok( 0, $name ); $test->diag( 'Your dist has no valid versions defined. ' . 'Must have at least one version' ); } else { $test->ok( 1, $name ); } return; } 1; # ABSTRACT: Check to see that version's in modules are sane __END__ =pod =encoding UTF-8 =head1 NAME Test::Version - Check to see that version's in modules are sane =head1 VERSION version 2.05 =head1 SYNOPSIS use Test::More; use Test::Version 1.001001 qw( version_all_ok ), { is_strict => 0, has_version => 1, consistent => 1, }; # test blib or lib by default version_all_ok(); done_testing; =head1 DESCRIPTION This module's goal is to be a one stop shop for checking to see that your versions across your dist are sane. Please ensure that you use version C<0.04> or later only, as earlier versions are old code and may not work correctly. Current feature list: =over =item module has a version Tests to insure that all modules checked have a VERSION defined, Can replace L =item module has a valid version Tests to insure that all versions are valid, according to the rules of L method C. To quote: I v1.2 1.2345.6 v1.23_4 1.2345 1.2345_01 I v1.234.5 2.3456 you can cause your tests to fail if not strict by setting L to C<1> =back =head1 FUNCTIONS =head2 version_ok version_ok( $filename, [ $name ] ); Test a single C<.pm> file by passing a path to the function. Checks if the module has a version, and that it is valid with C. =head2 version_all_ok version_all_ok( [ $directory, [ $name ]] ); Test all modules in a directory with C. By default it will check C or C if you haven't passed it a directory. =head1 CONFIGURATION AND ENVIRONMENT =head2 has_version use Test::Version qw( version_all_ok ), { has_version => 0 }; Allows disabling whether a module has to have a version. If set to 0 version tests will be skipped in any module where no version is found. really doesn't make sense to use with just L =head2 is_strict use Test::Version { is_strict => 1 }; this allows enabling of Ls C checks to ensure that your version is strict. =head2 consistent use Test::Version { consistent => 1 }; Check if every module has the same version number. =head2 ignore_unindexable use Test::Version { ignore_unindexable => 0}; if you have at least L vC<1.000020> Test::Version will by default skip any files not considered L =head2 filename_match use Test::Version 2.0 { filename_match => [qr{Foo/Bar.pm$}] }; Only test files that match the given pattern. Pattern may be a list of strings, regular expressions or code references. The filename will match if it matches one or more patterns. =over 4 =item string The file matches if it matches the pattern string exactly. =item regular expression The file matches if it matches the regular expression. =item code reference The file matches if the code reference returns a true value. The filename is passed in as the only argument to the code reference. =back =head2 multiple use Test::Version 2.02 { multiple => 1 }; Test each version for each package if multiple packages are found in a file. =head1 SEE ALSO The goal is to have the functionality of all of these. =over =item L =item L =item L =back If you are using L there is a plugin =over =item L =back =head1 BUGS Please report any bugs or feature requests on the bugtracker website https://github.com/plicease/test-version/issues When submitting a bug or request, please include a test-file or a patch to an existing test-file that illustrates the bug or desired feature. =head1 CONTRIBUTORS =for stopwords Dave Rolsky Gabor Szabo Karen Etheridge Michael G. Schwern Mike Doherty particle =over 4 =item * Dave Rolsky =item * Gabor Szabo =item * Karen Etheridge =item * Michael G. Schwern =item * Mike Doherty =item * particle =back =head1 AUTHORS =over 4 =item * Graham Ollis =item * Caleb Cushing =back =head1 COPYRIGHT AND LICENSE This software is Copyright (c) 2016 by Caleb Cushing. This is free software, licensed under: The Artistic License 2.0 (GPL Compatible) =cut file-not-defined.t100644001750001750 33012767221254 17555 0ustar00ollisgollisg000000000000Test-Version-2.05/t#!/usr/bin/perl use 5.006; use strict; use warnings; use Test::More; use Test::Exception; use Test::Version version_ok => { ignore_unindexable => 0 }; dies_ok { version_ok; } 'croak on bad api call'; done_testing; missing000755001750001750 012767221254 16664 5ustar00ollisgollisg000000000000Test-Version-2.05/corpusBaz.pm100644001750001750 2012767221254 20026 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/missingpackage Baz; 1; Bar.pm100644001750001750 6212767221254 20024 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/missingpackage Bar; BEGIN { our $VERSION = '1.23'; } 1; Foo.pm100644001750001750 6212767221254 20043 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/missingpackage Foo; BEGIN { our $VERSION = '1.23'; } 1; 00-report-prereqs.t100644001750001750 1271412767221254 17724 0ustar00ollisgollisg000000000000Test-Version-2.05/t#!perl use strict; use warnings; # This test was generated by Dist::Zilla::Plugin::Test::ReportPrereqs 0.025 use Test::More tests => 1; use ExtUtils::MakeMaker; use File::Spec; # from $version::LAX my $lax_version_re = qr/(?: undef | (?: (?:[0-9]+) (?: \. | (?:\.[0-9]+) (?:_[0-9]+)? )? | (?:\.[0-9]+) (?:_[0-9]+)? ) | (?: v (?:[0-9]+) (?: (?:\.[0-9]+)+ (?:_[0-9]+)? )? | (?:[0-9]+)? (?:\.[0-9]+){2,} (?:_[0-9]+)? ) )/x; # hide optional CPAN::Meta modules from prereq scanner # and check if they are available my $cpan_meta = "CPAN::Meta"; my $cpan_meta_pre = "CPAN::Meta::Prereqs"; my $HAS_CPAN_META = eval "require $cpan_meta; $cpan_meta->VERSION('2.120900')" && eval "require $cpan_meta_pre"; ## no critic # Verify requirements? my $DO_VERIFY_PREREQS = 1; sub _max { my $max = shift; $max = ( $_ > $max ) ? $_ : $max for @_; return $max; } sub _merge_prereqs { my ($collector, $prereqs) = @_; # CPAN::Meta::Prereqs object if (ref $collector eq $cpan_meta_pre) { return $collector->with_merged_prereqs( CPAN::Meta::Prereqs->new( $prereqs ) ); } # Raw hashrefs for my $phase ( keys %$prereqs ) { for my $type ( keys %{ $prereqs->{$phase} } ) { for my $module ( keys %{ $prereqs->{$phase}{$type} } ) { $collector->{$phase}{$type}{$module} = $prereqs->{$phase}{$type}{$module}; } } } return $collector; } my @include = qw( ); my @exclude = qw( ); # Add static prereqs to the included modules list my $static_prereqs = do 't/00-report-prereqs.dd'; # Merge all prereqs (either with ::Prereqs or a hashref) my $full_prereqs = _merge_prereqs( ( $HAS_CPAN_META ? $cpan_meta_pre->new : {} ), $static_prereqs ); # Add dynamic prereqs to the included modules list (if we can) my ($source) = grep { -f } 'MYMETA.json', 'MYMETA.yml'; if ( $source && $HAS_CPAN_META && (my $meta = eval { CPAN::Meta->load_file($source) } ) ) { $full_prereqs = _merge_prereqs($full_prereqs, $meta->prereqs); } else { $source = 'static metadata'; } my @full_reports; my @dep_errors; my $req_hash = $HAS_CPAN_META ? $full_prereqs->as_string_hash : $full_prereqs; # Add static includes into a fake section for my $mod (@include) { $req_hash->{other}{modules}{$mod} = 0; } for my $phase ( qw(configure build test runtime develop other) ) { next unless $req_hash->{$phase}; next if ($phase eq 'develop' and not $ENV{AUTHOR_TESTING}); for my $type ( qw(requires recommends suggests conflicts modules) ) { next unless $req_hash->{$phase}{$type}; my $title = ucfirst($phase).' '.ucfirst($type); my @reports = [qw/Module Want Have/]; for my $mod ( sort keys %{ $req_hash->{$phase}{$type} } ) { next if $mod eq 'perl'; next if grep { $_ eq $mod } @exclude; my $file = $mod; $file =~ s{::}{/}g; $file .= ".pm"; my ($prefix) = grep { -e File::Spec->catfile($_, $file) } @INC; my $want = $req_hash->{$phase}{$type}{$mod}; $want = "undef" unless defined $want; $want = "any" if !$want && $want == 0; my $req_string = $want eq 'any' ? 'any version required' : "version '$want' required"; if ($prefix) { my $have = MM->parse_version( File::Spec->catfile($prefix, $file) ); $have = "undef" unless defined $have; push @reports, [$mod, $want, $have]; if ( $DO_VERIFY_PREREQS && $HAS_CPAN_META && $type eq 'requires' ) { if ( $have !~ /\A$lax_version_re\z/ ) { push @dep_errors, "$mod version '$have' cannot be parsed ($req_string)"; } elsif ( ! $full_prereqs->requirements_for( $phase, $type )->accepts_module( $mod => $have ) ) { push @dep_errors, "$mod version '$have' is not in required range '$want'"; } } } else { push @reports, [$mod, $want, "missing"]; if ( $DO_VERIFY_PREREQS && $type eq 'requires' ) { push @dep_errors, "$mod is not installed ($req_string)"; } } } if ( @reports ) { push @full_reports, "=== $title ===\n\n"; my $ml = _max( map { length $_->[0] } @reports ); my $wl = _max( map { length $_->[1] } @reports ); my $hl = _max( map { length $_->[2] } @reports ); if ($type eq 'modules') { splice @reports, 1, 0, ["-" x $ml, "", "-" x $hl]; push @full_reports, map { sprintf(" %*s %*s\n", -$ml, $_->[0], $hl, $_->[2]) } @reports; } else { splice @reports, 1, 0, ["-" x $ml, "-" x $wl, "-" x $hl]; push @full_reports, map { sprintf(" %*s %*s %*s\n", -$ml, $_->[0], $wl, $_->[1], $hl, $_->[2]) } @reports; } push @full_reports, "\n"; } } } if ( @full_reports ) { diag "\nVersions for all modules listed in $source (including optional ones):\n\n", @full_reports; } if ( @dep_errors ) { diag join("\n", "\n*** WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING ***\n", "The following REQUIRED prerequisites were not satisfied:\n", @dep_errors, "\n" ); } pass; # vim: ts=4 sts=4 sw=4 et: multiple000755001750001750 012767221254 17046 5ustar00ollisgollisg000000000000Test-Version-2.05/corpusFoo.pm100644001750001750 12212767221254 20242 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/multiplepackage Foo; our $VERSION = '1.0'; package Foo::Bar; our $VERSION = '1.0'; 1; pod-syntax.t100644001750001750 25212767221254 20247 0ustar00ollisgollisg000000000000Test-Version-2.05/xt/author#!perl # This file was automatically generated by Dist::Zilla::Plugin::PodSyntaxTests. use strict; use warnings; use Test::More; use Test::Pod 1.41; all_pod_files_ok(); 00-report-prereqs.dd100644001750001750 470312767221254 20027 0ustar00ollisgollisg000000000000Test-Version-2.05/tdo { my $x = { 'configure' => { 'requires' => { 'ExtUtils::MakeMaker' => '0' } }, 'develop' => { 'requires' => { 'English' => '0', 'Pod::Coverage::TrustPod' => '0', 'Test::CPAN::Changes' => '0.19', 'Test::CPAN::Meta::JSON' => '0.16', 'Test::EOL' => '0', 'Test::More' => '0.96', 'Test::Pod' => '1.41', 'Test::Pod::Coverage' => '1.08', 'Test::Portability::Files' => '0', 'Test::Version' => '1' } }, 'runtime' => { 'requires' => { 'Carp' => '0', 'Exporter' => '0', 'File::Find::Rule::Perl' => '0', 'Module::Metadata' => '1.000020', 'Test::Builder' => '0', 'Test::More' => '0.94', 'parent' => '0', 'perl' => '5.006', 'strict' => '0', 'version' => '0.86', 'warnings' => '0' } }, 'test' => { 'recommends' => { 'CPAN::Meta' => '2.120900' }, 'requires' => { 'ExtUtils::MakeMaker' => '0', 'File::Spec' => '0', 'IO::Handle' => '0', 'IPC::Open3' => '0', 'Test::Exception' => '0', 'Test::More' => '0.94', 'Test::Tester' => '0', 'blib' => '1.01' } } }; $x; }release000755001750001750 012767221254 15753 5ustar00ollisgollisg000000000000Test-Version-2.05/xtmeta-json.t100644001750001750 6412767221254 20135 0ustar00ollisgollisg000000000000Test-Version-2.05/xt/release#!perl use Test::CPAN::Meta::JSON; meta_json_ok(); missing-has-version.t100644001750001750 76012767221254 20360 0ustar00ollisgollisg000000000000Test-Version-2.05/t#!/usr/bin/perl use 5.006; use strict; use warnings; use Test::Tester; use Test::More; use Test::Version version_all_ok => { has_version => 1, ignore_unindexable => 0, consistent => 1, }; my ( $premature, @results ) = run_tests( sub { version_all_ok('corpus/missing'); } ); is( scalar(@results), 4, 'correct number of results' ); my @oks = map { $_->{ok} } @results; note( 'unsorted oks: ', @oks ); is_deeply( [sort @oks], [0, 0, 1, 1], 'oks are ok' ); done_testing; generated000755001750001750 012767221254 17151 5ustar00ollisgollisg000000000000Test-Version-2.05/corpusFoo.pm100644001750001750 6112767221254 20327 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/generatedpackage Foo; BEGIN { our $VERSION = '1.0'; } 1; portability.t100644001750001750 26712767221254 20511 0ustar00ollisgollisg000000000000Test-Version-2.05/xt/authoruse strict; use warnings; use Test::More; eval 'use Test::Portability::Files'; plan skip_all => 'Test::Portability::Files required for testing portability' if $@; run_tests(); at-least-one-version.t100644001750001750 105612767221254 20446 0ustar00ollisgollisg000000000000Test-Version-2.05/t#!/usr/bin/perl use 5.006; use strict; use warnings; use Test::Tester; use Test::More; use Test::Version version_all_ok => { has_version => 0, ignore_unindexable => 0, }; my ( $premature, @results ) = run_tests( sub { version_all_ok('corpus/noversion'); } ); is( scalar(@results), 2, 'correct number of results' ); my @oks; foreach my $result ( @results ) { push @oks, $result->{ok}; } my $sorted = [ sort @oks ]; my $expected = [ ( 0, 1 ) ]; note( 'unsorted oks: ', @oks ); is_deeply( $sorted, $expected, 'oks are ok' ); done_testing; consistent000755001750001750 012767221254 17404 5ustar00ollisgollisg000000000000Test-Version-2.05/corpusBar.pm100644001750001750 6212767221254 20544 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/consistentpackage Bar; BEGIN { our $VERSION = '1.23'; } 1; Foo.pm100644001750001750 6212767221254 20563 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/consistentpackage Foo; BEGIN { our $VERSION = '1.23'; } 1; fail000755001750001750 012767221254 16126 5ustar00ollisgollisg000000000000Test-Version-2.05/corpusFooBarBaz.pm100644001750001750 11012767221254 20401 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/failpackage FooBarBaz; BEGIN { our $VERSION = 'v9223372036854775807'; } 1; pod-coverage.t100644001750001750 33412767221254 20515 0ustar00ollisgollisg000000000000Test-Version-2.05/xt/author#!perl # This file was automatically generated by Dist::Zilla::Plugin::PodCoverageTests. use Test::Pod::Coverage 1.08; use Pod::Coverage::TrustPod; all_pod_coverage_ok({ coverage_class => 'Pod::Coverage::TrustPod' }); test-version.t100644001750001750 63712767221254 20612 0ustar00ollisgollisg000000000000Test-Version-2.05/xt/authoruse strict; use warnings; use Test::More; # generated by Dist::Zilla::Plugin::Test::Version 1.09 use Test::Version; my @imports = qw( version_all_ok ); my $params = { is_strict => 0, has_version => 1, multiple => 0, }; push @imports, $params if version->parse( $Test::Version::VERSION ) >= version->parse('1.002'); Test::Version->import(@imports); version_all_ok; done_testing; all-has-version-false.t100644001750001750 112512767221254 20563 0ustar00ollisgollisg000000000000Test-Version-2.05/t#!/usr/bin/perl use 5.006; use strict; use warnings; use Test::Tester; use Test::More; use Test::Version version_all_ok => { has_version => 0, ignore_unindexable => 0, }; my ( $premature, @results ) = run_tests( sub { version_all_ok('corpus'); } ); is( scalar(@results), 18, 'correct number of results' ); my @oks; foreach my $result ( @results ) { push @oks, $result->{ok}; } my $sorted = [ sort @oks ]; my $expected = [ ( 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ) ]; note( 'unsorted oks: ', @oks ); is_deeply( $sorted, $expected, 'oks are ok' ); done_testing; multiple-inconsistent.t100644001750001750 247412767221254 21050 0ustar00ollisgollisg000000000000Test-Version-2.05/t#!/usr/bin/perl use 5.006; use strict; use warnings; use Test::Tester tests => 3; use Test::More; use Test::Version version_ok => { multiple => 1, consistent => 1, ignore_unindexable => 0, }; subtest 'multiple, good' => sub { my $ret; check_test( sub { $ret = version_ok( 'corpus/multiple/Foo.pm' ); }, { ok => 1, name => q[check version in 'corpus/multiple/Foo.pm'], diag => '', }, 'version ok' ); ok $ret, "version_ok() returned true on pass"; }; subtest 'multiple, missing' => sub { my $ret; check_test( sub { $ret = version_ok( 'corpus/multiple-missing/Foo.pm' ); }, { ok => 0, name => q[check version in 'corpus/multiple-missing/Foo.pm'], diag => 'No version was found in \'corpus/multiple-missing/Foo.pm\' (Foo::Bar).', }, 'version ok' ); ok !$ret, "version_ok() returned false on fail"; }; subtest 'multiple, inconsistent' => sub { my $ret; check_test( sub { $ret = version_ok( 'corpus/multiple-inconsistent/Foo.pm' ); }, { ok => 0, name => q[check version in 'corpus/multiple-inconsistent/Foo.pm'], diag => 'The versions found in \'corpus/multiple-inconsistent/Foo.pm\' are inconsistent.', }, 'version ok' ); ok !$ret, "version_ok() returned false on fail"; }; cpan-changes.t100644001750001750 34412767221254 20610 0ustar00ollisgollisg000000000000Test-Version-2.05/xt/releaseuse strict; use warnings; # this test was generated with Dist::Zilla::Plugin::Test::CPAN::Changes 0.012 use Test::More 0.96 tests => 1; use Test::CPAN::Changes; subtest 'changes_ok' => sub { changes_file_ok('Changes'); }; noversion000755001750001750 012767221254 17235 5ustar00ollisgollisg000000000000Test-Version-2.05/corpusFooBar.pm100644001750001750 2312767221254 21036 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/noversionpackage FooBar; 1; inconsistent000755001750001750 012767221254 17733 5ustar00ollisgollisg000000000000Test-Version-2.05/corpusBar.pm100644001750001750 6212767221254 21073 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/inconsistentpackage Bar; BEGIN { our $VERSION = '1.23'; } 1; Foo.pm100644001750001750 6212767221254 21112 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/inconsistentpackage Foo; BEGIN { our $VERSION = '1.24'; } 1; dist-manifest.t100644001750001750 23012767221254 21022 0ustar00ollisgollisg000000000000Test-Version-2.05/xt/release#!perl use Test::More; eval "use Test::DistManifest"; plan skip_all => "Test::DistManifest required for testing the manifest" if $@; manifest_ok(); minimum-version.t100644001750001750 27012767221254 21415 0ustar00ollisgollisg000000000000Test-Version-2.05/xt/release#!perl use Test::More; eval "use Test::MinimumVersion"; plan skip_all => "Test::MinimumVersion required for testing minimum versions" if $@; all_minimum_version_from_metayml_ok(); not_strict000755001750001750 012767221254 17403 5ustar00ollisgollisg000000000000Test-Version-2.05/corpusNotStrict.pm100644001750001750 7412767221254 21773 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/not_strictpackage NotStrict; BEGIN { our $VERSION = '0.1.0'; } 1; multiple-missing000755001750001750 012767221254 20515 5ustar00ollisgollisg000000000000Test-Version-2.05/corpusFoo.pm100644001750001750 7312767221254 21676 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/multiple-missingpackage Foo; our $VERSION = '1.0'; package Foo::Bar; 1; Foo000755001750001750 012767221254 17674 5ustar00ollisgollisg000000000000Test-Version-2.05/corpus/generatedConfigData.pm100644001750001750 3512767221254 22327 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/generated/Foopackage Foo::ConfigData; 1; multiple-inconsistent000755001750001750 012767221254 21564 5ustar00ollisgollisg000000000000Test-Version-2.05/corpusFoo.pm100644001750001750 12212767221254 22760 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/multiple-inconsistentpackage Foo; our $VERSION = '1.0'; package Foo::Bar; our $VERSION = '2.0'; 1; Install000755001750001750 012767221254 21302 5ustar00ollisgollisg000000000000Test-Version-2.05/corpus/generated/FooFiles.pm100644001750001750 4112767221254 22775 0ustar00ollisgollisg000000000000Test-Version-2.05/corpus/generated/Foo/Installpackage Foo::Install::Files; 1;