rpms/perl-Perl-MinimumVersion
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
perl-Perl-MinimumVersion-1_24-3_fc14
perl-Perl-MinimumVersion/Perl-MinimumVersion-25.patch

2108 lines
54 KiB
Diff
Raw Permalink Normal View History

- for the meantime apply changes from trunk. Other builds using this package should succed with perl-5.12.
2010-05-03 07:45:49 +00:00
diff -urN Perl-MinimumVersion-1.24/lib.old/Perl/MinimumVersion/Reason.pm Perl-MinimumVersion-1.24/lib/Perl/MinimumVersion/Reason.pm
--- Perl-MinimumVersion-1.24/lib.old/Perl/MinimumVersion/Reason.pm 2010-01-21 22:26:15.000000000 +0100
+++ Perl-MinimumVersion-1.24/lib/Perl/MinimumVersion/Reason.pm 2010-05-03 09:23:31.000000000 +0200
@@ -1,36 +1,36 @@
-package Perl::MinimumVersion::Reason;
-
-# Simple abstraction for a syntax limitation.
-# It contains the limiting version, the rule responsible, and the
-# PPI element responsible for the limitation (if any).
-
-use 5.006;
-use strict;
-use warnings;
-
-use vars qw{$VERSION};
-BEGIN {
- $VERSION = '1.24';
-
- # Only needed for dev releases, comment out otherwise
- $VERSION = eval $VERSION;
-}
-
-sub new {
- my $class = shift;
- return bless { @_ }, $class;
-}
-
-sub version {
- $_[0]->{version};
-}
-
-sub rule {
- $_[0]->{rule};
-}
-
-sub element {
- $_[0]->{element};
-}
-
-1;
+package Perl::MinimumVersion::Reason;
+
+# Simple abstraction for a syntax limitation.
+# It contains the limiting version, the rule responsible, and the
+# PPI element responsible for the limitation (if any).
+
+use 5.006;
+use strict;
+use warnings;
+
+use vars qw{$VERSION};
+BEGIN {
+ $VERSION = '1.25';
+
+ # Only needed for dev releases, comment out otherwise
+ $VERSION = eval $VERSION;
+}
+
+sub new {
+ my $class = shift;
+ return bless { @_ }, $class;
+}
+
+sub version {
+ $_[0]->{version};
+}
+
+sub rule {
+ $_[0]->{rule};
+}
+
+sub element {
+ $_[0]->{element};
+}
+
+1;
diff -urN Perl-MinimumVersion-1.24/lib.old/Perl/MinimumVersion/.svn/all-wcprops Perl-MinimumVersion-1.24/lib/Perl/MinimumVersion/.svn/all-wcprops
--- Perl-MinimumVersion-1.24/lib.old/Perl/MinimumVersion/.svn/all-wcprops 1970-01-01 01:00:00.000000000 +0100
+++ Perl-MinimumVersion-1.24/lib/Perl/MinimumVersion/.svn/all-wcprops 2010-05-03 09:23:31.000000000 +0200
@@ -0,0 +1,11 @@
+K 25
+svn:wc:ra_dav:version-url
+V 70
+/cpan/!svn/ver/11888/trunk/Perl-MinimumVersion/lib/Perl/MinimumVersion
+END
+Reason.pm
+K 25
+svn:wc:ra_dav:version-url
+V 80
+/cpan/!svn/ver/11888/trunk/Perl-MinimumVersion/lib/Perl/MinimumVersion/Reason.pm
+END
diff -urN Perl-MinimumVersion-1.24/lib.old/Perl/MinimumVersion/.svn/entries Perl-MinimumVersion-1.24/lib/Perl/MinimumVersion/.svn/entries
--- Perl-MinimumVersion-1.24/lib.old/Perl/MinimumVersion/.svn/entries 1970-01-01 01:00:00.000000000 +0100
+++ Perl-MinimumVersion-1.24/lib/Perl/MinimumVersion/.svn/entries 2010-05-03 09:23:31.000000000 +0200
@@ -0,0 +1,62 @@
+10
+
+dir
+12099
+http://svn.ali.as/cpan/trunk/Perl-MinimumVersion/lib/Perl/MinimumVersion
+http://svn.ali.as/cpan
+
+
+
+2010-04-11T14:30:55.494658Z
+11888
+chorny@cpan.org
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+88f4d9cd-8a04-0410-9d60-8f63309c3137
+
+Reason.pm
+file
+
+
+
+
+2010-05-03T07:23:31.091810Z
+3ece6d1a31707473047d796b366510bc
+2010-04-11T14:30:55.494658Z
+11888
+chorny@cpan.org
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+586
+
diff -urN Perl-MinimumVersion-1.24/lib.old/Perl/MinimumVersion/.svn/text-base/Reason.pm.svn-base Perl-MinimumVersion-1.24/lib/Perl/MinimumVersion/.svn/text-base/Reason.pm.svn-base
--- Perl-MinimumVersion-1.24/lib.old/Perl/MinimumVersion/.svn/text-base/Reason.pm.svn-base 1970-01-01 01:00:00.000000000 +0100
+++ Perl-MinimumVersion-1.24/lib/Perl/MinimumVersion/.svn/text-base/Reason.pm.svn-base 2010-05-03 09:23:31.000000000 +0200
@@ -0,0 +1,36 @@
+package Perl::MinimumVersion::Reason;
+
+# Simple abstraction for a syntax limitation.
+# It contains the limiting version, the rule responsible, and the
+# PPI element responsible for the limitation (if any).
+
+use 5.006;
+use strict;
+use warnings;
+
+use vars qw{$VERSION};
+BEGIN {
+ $VERSION = '1.25';
+
+ # Only needed for dev releases, comment out otherwise
+ $VERSION = eval $VERSION;
+}
+
+sub new {
+ my $class = shift;
+ return bless { @_ }, $class;
+}
+
+sub version {
+ $_[0]->{version};
+}
+
+sub rule {
+ $_[0]->{rule};
+}
+
+sub element {
+ $_[0]->{element};
+}
+
+1;
diff -urN Perl-MinimumVersion-1.24/lib.old/Perl/MinimumVersion.pm Perl-MinimumVersion-1.24/lib/Perl/MinimumVersion.pm
--- Perl-MinimumVersion-1.24/lib.old/Perl/MinimumVersion.pm 2010-01-21 22:26:15.000000000 +0100
+++ Perl-MinimumVersion-1.24/lib/Perl/MinimumVersion.pm 2010-05-03 09:23:31.000000000 +0200
@@ -12,7 +12,7 @@
$object = Perl::MinimumVersion->new( $filename );
$object = Perl::MinimumVersion->new( \$source );
$object = Perl::MinimumVersion->new( $ppi_document );
-
+
# Find the minimum version
$version = $object->minimum_version;
@@ -54,7 +54,7 @@
use vars qw{$VERSION @ISA @EXPORT_OK %CHECKS %MATCHES};
BEGIN {
- $VERSION = '1.24';
+ $VERSION = '1.25';
# Only needed for dev releases, comment out otherwise
$VERSION = eval $VERSION;
@@ -65,6 +65,10 @@
# The primary list of version checks
%CHECKS = (
+ _feature_bundle_5_12 => version->new('5.012'),
+ _yada_yada_yada => version->new('5.012'),
+ _pkg_name_version => version->new('5.012'),
+
_perl_5010_pragmas => version->new('5.010'),
_perl_5010_operators => version->new('5.010'),
_perl_5010_magic => version->new('5.010'),
@@ -375,7 +379,7 @@
$limit = version->new("$limit");
}
if ( defined $self->{syntax} ) {
- if ( $self->{syntax} >= $limit ) {
+ if ( $self->{syntax}->version >= $limit ) {
# Previously discovered minimum is what they want
return $self->{syntax};
}
@@ -505,10 +509,41 @@
-
#####################################################################
# Version Check Methods
+sub _yada_yada_yada {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Token::Operator')
+ and $_[1]->content eq '...'
+ } );
+}
+
+sub _feature_bundle_5_12 {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Include') or return '';
+ $_[1]->pragma eq 'feature' or return '';
+ my @child = $_[1]->schildren;
+ my @args = @child[1..$#child]; # skip 'use', 'feature' and ';'
+ foreach my $arg (@args) {
+ return $arg->content if $arg->content =~ /:5\.12/;
+ }
+ return '';
+ } );
+}
+
+sub _pkg_name_version {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Package') or return '';
+ my @child = $_[1]->schildren();
+ $child[0]->isa('PPI::Token::Word') or return '';
+ $child[0]->content eq 'package' or return '';
+ $child[1]->isa('PPI::Token::Word') or return '';
+ $child[2]->isa('PPI::Token::Number') or return '';
+ return 1;
+ } );
+}
+
sub _perl_5010_pragmas {
shift->Document->find_first( sub {
$_[1]->isa('PPI::Statement::Include')
@@ -970,6 +1005,9 @@
B<Write the recursive module descend stuff>
+B<Check for more 5.12 features (currently only detecting
+C<package NAME VERSION;>, C<...>, and C<use feature ':5.12'>)>
+
=head1 SUPPORT
All bugs should be filed via the CPAN bug tracker at
diff -urN Perl-MinimumVersion-1.24/lib.old/Perl/.svn/all-wcprops Perl-MinimumVersion-1.24/lib/Perl/.svn/all-wcprops
--- Perl-MinimumVersion-1.24/lib.old/Perl/.svn/all-wcprops 1970-01-01 01:00:00.000000000 +0100
+++ Perl-MinimumVersion-1.24/lib/Perl/.svn/all-wcprops 2010-05-03 09:23:31.000000000 +0200
@@ -0,0 +1,11 @@
+K 25
+svn:wc:ra_dav:version-url
+V 55
+/cpan/!svn/ver/11956/trunk/Perl-MinimumVersion/lib/Perl
+END
+MinimumVersion.pm
+K 25
+svn:wc:ra_dav:version-url
+V 73
+/cpan/!svn/ver/11956/trunk/Perl-MinimumVersion/lib/Perl/MinimumVersion.pm
+END
diff -urN Perl-MinimumVersion-1.24/lib.old/Perl/.svn/entries Perl-MinimumVersion-1.24/lib/Perl/.svn/entries
--- Perl-MinimumVersion-1.24/lib.old/Perl/.svn/entries 1970-01-01 01:00:00.000000000 +0100
+++ Perl-MinimumVersion-1.24/lib/Perl/.svn/entries 2010-05-03 09:23:31.000000000 +0200
@@ -0,0 +1,65 @@
+10
+
+dir
+12099
+http://svn.ali.as/cpan/trunk/Perl-MinimumVersion/lib/Perl
+http://svn.ali.as/cpan
+
+
+
+2010-04-16T12:06:52.798869Z
+11956
+smueller@cpan.org
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+88f4d9cd-8a04-0410-9d60-8f63309c3137
+
+MinimumVersion
+dir
+
+MinimumVersion.pm
+file
+
+
+
+
+2010-05-03T07:23:31.130560Z
+23be7b5a3fa8397ca2fa1aa5c316eebf
+2010-04-16T12:06:52.798869Z
+11956
+smueller@cpan.org
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+26235
+
diff -urN Perl-MinimumVersion-1.24/lib.old/Perl/.svn/prop-base/MinimumVersion.pm.svn-base Perl-MinimumVersion-1.24/lib/Perl/.svn/prop-base/MinimumVersion.pm.svn-base
--- Perl-MinimumVersion-1.24/lib.old/Perl/.svn/prop-base/MinimumVersion.pm.svn-base 1970-01-01 01:00:00.000000000 +0100
+++ Perl-MinimumVersion-1.24/lib/Perl/.svn/prop-base/MinimumVersion.pm.svn-base 2010-05-03 09:23:31.000000000 +0200
@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END
diff -urN Perl-MinimumVersion-1.24/lib.old/Perl/.svn/text-base/MinimumVersion.pm.svn-base Perl-MinimumVersion-1.24/lib/Perl/.svn/text-base/MinimumVersion.pm.svn-base
--- Perl-MinimumVersion-1.24/lib.old/Perl/.svn/text-base/MinimumVersion.pm.svn-base 1970-01-01 01:00:00.000000000 +0100
+++ Perl-MinimumVersion-1.24/lib/Perl/.svn/text-base/MinimumVersion.pm.svn-base 2010-05-03 09:23:31.000000000 +0200
@@ -0,0 +1,1037 @@
+package Perl::MinimumVersion;
+
+=pod
+
+=head1 NAME
+
+Perl::MinimumVersion - Find a minimum required version of perl for Perl code
+
+=head1 SYNOPSIS
+
+ # Create the version checking object
+ $object = Perl::MinimumVersion->new( $filename );
+ $object = Perl::MinimumVersion->new( \$source );
+ $object = Perl::MinimumVersion->new( $ppi_document );
+
+ # Find the minimum version
+ $version = $object->minimum_version;
+
+=head1 DESCRIPTION
+
+C<Perl::MinimumVersion> takes Perl source code and calculates the minimum
+version of perl required to be able to run it. Because it is based on
+L<PPI>, it can do this without having to actually load the code.
+
+Currently it tests both the syntax of your code, and the use of explicit
+version dependencies such as C<require 5.005>.
+
+Future plans are to also add support for tracing module dependencies.
+
+Using C<Perl::MinimumVersion> is dead simple, the synopsis pretty much
+covers it.
+
+=head1 METHODS
+
+=cut
+
+use 5.006;
+use strict;
+use version ();
+use Carp ();
+use Exporter ();
+use List::Util ();
+use Params::Util ('_INSTANCE', '_CLASS');
+use PPI::Util ('_Document');
+use PPI ();
+use Perl::Critic::Utils 1.104 qw{
+ :classification
+ :ppi
+};
+
+use Perl::MinimumVersion::Reason ();
+
+use constant REASON => 'Perl::MinimumVersion::Reason';
+
+use vars qw{$VERSION @ISA @EXPORT_OK %CHECKS %MATCHES};
+BEGIN {
+ $VERSION = '1.25';
+
+ # Only needed for dev releases, comment out otherwise
+ $VERSION = eval $VERSION;
+
+ # Export the PMV convenience constant
+ @ISA = 'Exporter';
+ @EXPORT_OK = 'PMV';
+
+ # The primary list of version checks
+ %CHECKS = (
+ _feature_bundle_5_12 => version->new('5.012'),
+ _yada_yada_yada => version->new('5.012'),
+ _pkg_name_version => version->new('5.012'),
+
+ _perl_5010_pragmas => version->new('5.010'),
+ _perl_5010_operators => version->new('5.010'),
+ _perl_5010_magic => version->new('5.010'),
+
+ # Various small things
+ _bugfix_magic_errno => version->new('5.008.003'),
+ _unquoted_versions => version->new('5.008.001'),
+ _perl_5008_pragmas => version->new('5.008'),
+ _constant_hash => version->new('5.008'),
+ _use_base_exporter => version->new('5.008'),
+ _local_soft_reference => version->new('5.008'),
+ _use_carp_version => version->new('5.008'),
+
+ # Included in 5.6. Broken until 5.8
+ _pragma_utf8 => version->new('5.008'),
+
+ _perl_5006_pragmas => version->new('5.006'),
+ _any_our_variables => version->new('5.006'),
+ _any_binary_literals => version->new('5.006'),
+ _any_version_literals => version->new('5.006'), #v-string
+ _magic_version => version->new('5.006'),
+ _any_attributes => version->new('5.006'),
+ _any_CHECK_blocks => version->new('5.006'),
+ _three_argument_open => version->new('5.006'),
+ _weaken => version->new('5.006'),
+ _mkdir_1_arg => version->new('5.006'),
+
+ _any_qr_tokens => version->new('5.005.03'),
+ _perl_5005_pragmas => version->new('5.005'),
+ _perl_5005_modules => version->new('5.005'),
+ _any_tied_arrays => version->new('5.005'),
+ _any_quotelike_regexp => version->new('5.005'),
+ _any_INIT_blocks => version->new('5.005'),
+ _substr_4_arg => version->new('5.005'),
+ _splice_negative_length => version->new('5.005'),
+
+ _postfix_foreach => version->new('5.004.05'),
+ );
+
+ # Predefine some indexes needed by various check methods
+ %MATCHES = (
+ _perl_5010_pragmas => {
+ mro => 1,
+ feature => 1,
+ },
+ _perl_5010_operators => {
+ '//' => 1,
+ '//=' => 1,
+ '~~' => 1,
+ },
+ _perl_5010_magic => {
+ '%+' => 1,
+ '%-' => 1,
+ },
+ _perl_5008_pragmas => {
+ threads => 1,
+ 'threads::shared' => 1,
+ sort => 1,
+ },
+ _perl_5006_pragmas => {
+ warnings => 1, #may be ported into older version
+ 'warnings::register' => 1,
+ attributes => 1,
+ open => 1,
+ filetest => 1,
+ charnames => 1,
+ bytes => 1,
+ },
+ _perl_5005_pragmas => {
+ re => 1,
+ fields => 1, # can be installed from CPAN, with base.pm
+ attr => 1,
+ },
+ );
+}
+
+sub PMV () { 'Perl::MinimumVersion' }
+
+
+
+
+
+#####################################################################
+# Constructor
+
+=pod
+
+=head2 new
+
+ # Create the version checking object
+ $object = Perl::MinimumVersion->new( $filename );
+ $object = Perl::MinimumVersion->new( \$source );
+ $object = Perl::MinimumVersion->new( $ppi_document );
+
+The C<new> constructor creates a new version checking object for a
+L<PPI::Document>. You can also provide the document to be read as a
+file name, or as a C<SCALAR> reference containing the code.
+
+Returns a new C<Perl::MinimumVersion> object, or C<undef> on error.
+
+=cut
+
+sub new {
+ my $class = ref $_[0] ? ref shift : shift;
+ my $Document = _Document(shift) or return undef;
+ my $default = _INSTANCE(shift, 'version') || version->new('5.004');
+
+ # Create the object
+ my $self = bless {
+ Document => $Document,
+
+ # Checking limit and default minimum version.
+ # Explicitly don't check below this version.
+ default => $default,
+
+ # Caches for resolved versions
+ explicit => undef,
+ syntax => undef,
+ external => undef,
+ }, $class;
+
+ $self;
+}
+
+=pod
+
+=head2 Document
+
+The C<Document> accessor can be used to get the L<PPI::Document> object
+back out of the version checker.
+
+=cut
+
+sub Document {
+ $_[0]->{Document}
+}
+
+
+
+
+
+#####################################################################
+# Main Methods
+
+=pod
+
+=head2 minimum_version
+
+The C<minimum_version> method is the primary method for finding the
+minimum perl version required based on C<all> factors in the document.
+
+At the present time, this is just syntax and explicit version checks,
+as L<Perl::Depends> is not yet completed.
+
+Returns a L<version> object, or C<undef> on error.
+
+=cut
+
+sub minimum_version {
+ my $self = _SELF(\@_) or return undef;
+ my $minimum = $self->{default}; # Sensible default
+
+ # Is the explicit version greater?
+ my $explicit = $self->minimum_explicit_version;
+ return undef unless defined $explicit;
+ if ( $explicit and $explicit > $minimum ) {
+ $minimum = $explicit;
+ }
+
+ # Is the syntax version greater?
+ # Since this is the most expensive operation (for this file),
+ # we need to be careful we don't run things we don't need to.
+ my $syntax = $self->minimum_syntax_version;
+ return undef unless defined $syntax;
+ if ( $syntax and $syntax > $minimum ) {
+ $minimum = $syntax;
+ }
+
+ ### FIXME - Disabled until minimum_external_version completed
+ # Is the external version greater?
+ #my $external = $self->minimum_external_version;
+ #return undef unless defined $external;
+ #if ( $external and $external > $minimum ) {
+ # $minimum = $external;
+ #}
+
+ $minimum;
+}
+
+sub minimum_reason {
+ my $self = _SELF(\@_) or return undef;
+ my $minimum = $self->default_reason; # Sensible default
+
+ # Is the explicit version greater?
+ my $explicit = $self->minimum_explicit_version;
+ return undef unless defined $explicit;
+ if ( $explicit and $explicit > $minimum ) {
+ $minimum = $explicit;
+ }
+
+}
+
+sub default_reason {
+ Perl::MinimumVersion->new(
+ rule => 'default',
+ version => $_[0]->{default},
+ element => undef,
+ );
+}
+
+=pod
+
+=head2 minimum_explicit_version
+
+The C<minimum_explicit_version> method checks through Perl code for the
+use of explicit version dependencies such as.
+
+ use 5.006;
+ require 5.005_03;
+
+Although there is almost always only one of these in a file, if more than
+one are found, the highest version dependency will be returned.
+
+Returns a L<version> object, false if no dependencies could be found,
+or C<undef> on error.
+
+=cut
+
+sub minimum_explicit_version {
+ my $self = _SELF(\@_) or return undef;
+ my $reason = $self->minimum_explicit_reason(@_);
+ return $reason ? $reason->version : $reason;
+}
+
+sub minimum_explicit_reason {
+ my $self = _SELF(\@_) or return undef;
+ unless ( defined $self->{explicit} ) {
+ $self->{explicit} = $self->_minimum_explicit_version;
+ }
+ return $self->{explicit};
+}
+
+sub _minimum_explicit_version {
+ my $self = shift or return undef;
+ my $explicit = $self->Document->find( sub {
+ $_[1]->isa('PPI::Statement::Include') or return '';
+ $_[1]->version or return '';
+ 1;
+ } );
+ return $explicit unless $explicit;
+
+ # Find the highest version
+ my $max = undef;
+ my $element = undef;
+ foreach my $include ( @$explicit ) {
+ my $version = version->new($include->version);
+ if ( $version > $max or not $element ) {
+ $max = $version;
+ $element = $include;
+ }
+ }
+
+ return Perl::MinimumVersion::Reason->new(
+ rule => 'explicit',
+ version => $max,
+ element => $element,
+ );
+}
+
+=pod
+
+=head2 minimum_syntax_version $limit
+
+The C<minimum_syntax_version> method will explicitly test only the
+Document's syntax to determine it's minimum version, to the extent
+that this is possible.
+
+It takes an optional parameter of a L<version> object defining the
+the lowest known current value. For example, if it is already known
+that it must be 5.006 or higher, then you can provide a param of
+qv(5.006) and the method will not run any of the tests below this
+version. This should provide dramatic speed improvements for
+large and/or complex documents.
+
+The limitations of parsing Perl mean that this method may provide
+artifically low results, but should not artificially high results.
+
+For example, if C<minimum_syntax_version> returned 5.006, you can be
+confident it will not run on anything lower, although there is a chance
+that during actual execution it may use some untestable feature that
+creates a dependency on a higher version.
+
+Returns a L<version> object, false if no dependencies could be found,
+or C<undef> on error.
+
+=cut
+
+sub minimum_syntax_version {
+ my $self = _SELF(\@_) or return undef;
+ my $reason = $self->minimum_syntax_reason(@_);
+ return $reason ? $reason->version : $reason;
+}
+
+sub minimum_syntax_reason {
+ my $self = _SELF(\@_) or return undef;
+ my $limit = shift;
+ if ( defined $limit and not _INSTANCE($limit, 'version') ) {
+ $limit = version->new("$limit");
+ }
+ if ( defined $self->{syntax} ) {
+ if ( $self->{syntax}->version >= $limit ) {
+ # Previously discovered minimum is what they want
+ return $self->{syntax};
+ }
+
+ # Rather than return a value BELOW their filter,
+ # which they would not be expecting, return false.
+ return '';
+ }
+
+ # Look for the value
+ my $syntax = $self->_minimum_syntax_version( $limit );
+
+ # If we found a value, it will be stable, cache it.
+ # If we did NOT, don't cache as subsequent runs without
+ # the filter may find a version.
+ if ( $syntax ) {
+ $self->{syntax} = $syntax;
+ return $self->{syntax};
+ }
+
+ return '';
+}
+
+sub _minimum_syntax_version {
+ my $self = shift;
+ my $filter = shift || $self->{default};
+
+ # Always check in descending version order.
+ # By doing it this way, the version of the first check that matches
+ # is also the version of the document as a whole.
+ my @rules = sort {
+ $CHECKS{$b} <=> $CHECKS{$a}
+ } grep {
+ $CHECKS{$_} > $filter
+ } keys %CHECKS;
+
+ foreach my $rule ( @rules ) {
+ my $result = $self->$rule() or next;
+
+ # Create the result object
+ return Perl::MinimumVersion::Reason->new(
+ rule => $rule,
+ version => $CHECKS{$rule},
+ element => _INSTANCE($result, 'PPI::Element'),
+ );
+ }
+
+ # Found nothing of interest
+ return '';
+}
+
+=pod
+
+=head2 minimum_external_version
+
+B<WARNING: This method has not been implemented. Any attempted use will throw
+an exception>
+
+The C<minimum_external_version> examines code for dependencies on other
+external files, and recursively traverses the dependency tree applying the
+same tests to those files as it does to the original.
+
+Returns a C<version> object, false if no dependencies could be found, or
+C<undef> on error.
+
+=cut
+
+sub minimum_external_version {
+ my $self = _SELF(\@_) or return undef;
+ my $reason = $self->minimum_explicit_reason(@_);
+ return $reason ? $reason->version : $reason;
+}
+
+sub minimum_external_reason {
+ my $self = _SELF(\@_) or return undef;
+ unless ( defined $self->{external} ) {
+ $self->{external} = $self->_minimum_external_version;
+ }
+ $self->{external};
+}
+
+sub _minimum_external_version {
+ Carp::croak("Perl::MinimumVersion::minimum_external_version is not implemented");
+}
+
+=pod
+
+=head2 version_markers
+
+This method returns a list of pairs in the form:
+
+ ($version, \@markers)
+
+Each pair represents all the markers that could be found indicating that the
+version was the minimum needed version. C<@markers> is an array of strings.
+Currently, these strings are not as clear as they might be, but this may be
+changed in the future. In other words: don't rely on them as specific
+identifiers.
+
+=cut
+
+sub version_markers {
+ my $self = _SELF(\@_) or return undef;
+
+ my %markers;
+
+ if ( my $explicit = $self->minimum_explicit_version ) {
+ $markers{ $explicit } = [ 'explicit' ];
+ }
+
+ foreach my $check ( keys %CHECKS ) {
+ next unless $self->$check();
+ my $markers = $markers{ $CHECKS{$check} } ||= [];
+ push @$markers, $check;
+ }
+
+ my @rv;
+ my %marker_ver = map { $_ => version->new($_) } keys %markers;
+
+ foreach my $ver ( sort { $marker_ver{$b} <=> $marker_ver{$a} } keys %markers ) {
+ push @rv, $marker_ver{$ver} => $markers{$ver};
+ }
+
+ return @rv;
+}
+
+
+
+
+#####################################################################
+# Version Check Methods
+
+sub _yada_yada_yada {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Token::Operator')
+ and $_[1]->content eq '...'
+ } );
+}
+
+sub _feature_bundle_5_12 {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Include') or return '';
+ $_[1]->pragma eq 'feature' or return '';
+ my @child = $_[1]->schildren;
+ my @args = @child[1..$#child]; # skip 'use', 'feature' and ';'
+ foreach my $arg (@args) {
+ return $arg->content if $arg->content =~ /:5\.12/;
+ }
+ return '';
+ } );
+}
+
+sub _pkg_name_version {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Package') or return '';
+ my @child = $_[1]->schildren();
+ $child[0]->isa('PPI::Token::Word') or return '';
+ $child[0]->content eq 'package' or return '';
+ $child[1]->isa('PPI::Token::Word') or return '';
+ $child[2]->isa('PPI::Token::Number') or return '';
+ return 1;
+ } );
+}
+
+sub _perl_5010_pragmas {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Include')
+ and
+ $MATCHES{_perl_5010_pragmas}->{$_[1]->pragma}
+ } );
+}
+
+sub _perl_5010_operators {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Token::Magic')
+ and
+ $MATCHES{_perl_5010_operators}->{$_[1]->content}
+ } );
+}
+
+sub _perl_5010_magic {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Token::Operator')
+ and
+ $MATCHES{_perl_5010_magic}->{$_[1]->content}
+ } );
+}
+
+sub _perl_5008_pragmas {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Include')
+ and
+ $MATCHES{_perl_5008_pragmas}->{$_[1]->pragma}
+ } );
+}
+
+# FIXME: Needs to be upgraded to return something
+sub _bugfix_magic_errno {
+ my $Document = shift->Document;
+ $Document->find_any( sub {
+ $_[1]->isa('PPI::Token::Magic')
+ and
+ $_[1]->content eq '$^E'
+ } )
+ and
+ $Document->find_any( sub {
+ $_[1]->isa('PPI::Token::Magic')
+ and
+ $_[1]->content eq '$!'
+ } );
+}
+
+# version->new(5.005.004);
+sub _unquoted_versions {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Token::Number') or return '';
+ $_[1]->{_subtype} or return '';
+ $_[1]->{_subtype} eq 'base256' or return '';
+ my $stmt = $_[1]->parent or return '';
+ my $braces = $stmt->parent or return '';
+ $braces->isa('PPI::Structure') or return '';
+ $braces->braces eq '()' or return '';
+ my $new = $braces->previous_sibling or return '';
+ $new->isa('PPI::Token::Word') or return '';
+ $new->content eq 'new' or return '';
+ my $method = $new->previous_sibling or return '';
+ $method->isa('PPI::Token::Operator') or return '';
+ $method->content eq '->' or return '';
+ my $_class = $method->previous_sibling or return '';
+ $_class->isa('PPI::Token::Word') or return '';
+ $_class->content eq 'version' or return '';
+ 1;
+ } );
+}
+
+sub _pragma_utf8 {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Include')
+ and
+ (
+ ($_[1]->module and $_[1]->module eq 'utf8')
+ or
+ ($_[1]->pragma and $_[1]->pragma eq 'utf8')
+ )
+ # This used to be just pragma(), but that was buggy in PPI v1.118
+ } );
+}
+
+# Check for the use of 'use constant { ... }'
+sub _constant_hash {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Include')
+ and
+ $_[1]->type
+ and
+ $_[1]->type eq 'use'
+ and
+ $_[1]->module eq 'constant'
+ and
+ $_[1]->schild(2)->isa('PPI::Structure')
+ } );
+}
+
+sub _perl_5006_pragmas {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Include')
+ and
+ $MATCHES{_perl_5006_pragmas}->{$_[1]->pragma}
+ } );
+}
+
+sub _any_our_variables {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Variable')
+ and
+ $_[1]->type eq 'our'
+ } );
+}
+
+sub _any_binary_literals {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Token::Number')
+ and
+ $_[1]->{_subtype}
+ and
+ $_[1]->{_subtype} eq 'binary'
+ } );
+}
+
+sub _any_version_literals {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Token::Number::Version')
+ } );
+}
+
+
+sub _magic_version {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Token::Magic')
+ and
+ $_[1]->content eq '$^V'
+ } );
+}
+
+sub _any_attributes {
+ shift->Document->find_first( 'Token::Attribute' );
+}
+
+sub _any_CHECK_blocks {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Scheduled')
+ and
+ $_[1]->type eq 'CHECK'
+ } );
+}
+
+sub _any_qr_tokens {
+ shift->Document->find_first( 'Token::QuoteLike::Regexp' );
+}
+
+sub _perl_5005_pragmas {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Include')
+ and
+ $MATCHES{_perl_5005_pragmas}->{$_[1]->pragma}
+ } );
+}
+
+# A number of modules are highly indicative of using techniques
+# that are themselves version-dependant.
+sub _perl_5005_modules {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Include')
+ and
+ $_[1]->module
+ and (
+ $_[1]->module eq 'Tie::Array'
+ or
+ ($_[1]->module =~ /\bException\b/ and
+ $_[1]->module !~ /^(?:CPAN)::/)
+ or
+ $_[1]->module =~ /\bThread\b/
+ or
+ $_[1]->module =~ /^Error\b/
+ or
+ $_[1]->module eq 'base'
+ or
+ $_[1]->module eq 'Errno'
+ )
+ } );
+}
+
+sub _any_tied_arrays {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Sub')
+ and
+ $_[1]->name eq 'TIEARRAY'
+ } )
+}
+
+sub _any_quotelike_regexp {
+ shift->Document->find_first( 'Token::QuoteLike::Regexp' );
+}
+
+sub _any_INIT_blocks {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Scheduled')
+ and
+ $_[1]->type eq 'INIT'
+ } );
+}
+
+# use base 'Exporter' doesn't work reliably everywhere until 5.008
+sub _use_base_exporter {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Include')
+ and
+ $_[1]->module eq 'base'
+ and
+ # Add the "not colon" characters to avoid accidentally
+ # colliding with any other Exporter-named modules
+ $_[1]->content =~ /[^:]\bExporter\b[^:]/
+ } );
+}
+
+# You can't localize a soft reference
+sub _local_soft_reference {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Variable') or return '';
+ $_[1]->type eq 'local' or return '';
+
+ # The second child should be a '$' cast.
+ my @child = $_[1]->schildren;
+ scalar(@child) >= 2 or return '';
+ $child[1]->isa('PPI::Token::Cast') or return '';
+ $child[1]->content eq '$' or return '';
+
+ # The third child should be a block
+ $child[2]->isa('PPI::Structure::Block') or return '';
+
+ # Inside the block should be a string in a statement
+ my $statement = $child[2]->schild(0) or return '';
+ $statement->isa('PPI::Statement') or return '';
+ my $inside = $statement->schild(0) or return '';
+ $inside->isa('PPI::Token::Quote') or return '';
+
+ # This is indeed a localized soft reference
+ return 1;
+ } );
+}
+
+# Carp.pm did not have a $VERSION in 5.6.2
+# Therefore, even "use Carp 0" imposes a 5.8.0 dependency.
+sub _use_carp_version {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement::Include') or return '';
+ $_[1]->module eq 'Carp' or return '';
+
+ my $version = $_[1]->module_version;
+ return !! ( defined $version and length "$version" );
+ } );
+}
+
+sub _three_argument_open {
+ shift->Document->find_first( sub {
+ $_[1]->isa('PPI::Statement') or return '';
+ my @children=$_[1]->children;
+ #@children >= 7 or return '';
+ my $main_element=$children[0];
+ $main_element->isa('PPI::Token::Word') or return '';
+ $main_element->content eq 'open' or return '';
+ my @arguments = parse_arg_list($main_element);
+ if ( scalar @arguments > 2 ) {
+ return 1;
+ }
+ return '';
+ } );
+}
+
+
+sub _substr_4_arg {
+ shift->Document->find_first( sub {
+ my $main_element=$_[1];
+ $main_element->isa('PPI::Token::Word') or return '';
+ $main_element->content eq 'substr' or return '';
+ return '' if is_hash_key($main_element);
+ return '' if is_method_call($main_element);
+ return '' if is_subroutine_name($main_element);
+ return '' if is_included_module_name($main_element);
+ return '' if is_package_declaration($main_element);
+ my @arguments = parse_arg_list($main_element);
+ if ( scalar @arguments > 3 ) {
+ return 1;
+ }
+ return '';
+ } );
+}
+
+sub _mkdir_1_arg {
+ shift->Document->find_first( sub {
+ my $main_element=$_[1];
+ $main_element->isa('PPI::Token::Word') or return '';
+ $main_element->content eq 'mkdir' or return '';
+ return '' if is_hash_key($main_element);
+ return '' if is_method_call($main_element);
+ return '' if is_subroutine_name($main_element);
+ return '' if is_included_module_name($main_element);
+ return '' if is_package_declaration($main_element);
+ my @arguments = parse_arg_list($main_element);
+ if ( scalar @arguments != 2 ) {
+ return 1;
+ }
+ return '';
+ } );
+}
+
+sub _splice_negative_length {
+ shift->Document->find_first( sub {
+ my $main_element=$_[1];
+ $main_element->isa('PPI::Token::Word') or return '';
+ $main_element->content eq 'splice' or return '';
+ return '' if is_hash_key($main_element);
+ return '' if is_method_call($main_element);
+ return '' if is_subroutine_name($main_element);
+ return '' if is_included_module_name($main_element);
+ return '' if is_package_declaration($main_element);
+
+ my @arguments = parse_arg_list($main_element);
+ if ( scalar @arguments < 3 ) {
+ return '';
+ }
+ my $arg=$arguments[2];
+ if (ref($arg) eq 'ARRAY') {
+ $arg=$arg->[0];
+ }
+ if ($arg->isa('PPI::Token::Number')) {
+ if ($arg->literal<0) {
+ return 1;
+ } else {
+ return '';
+ }
+ }
+ return '';
+ } );
+
+}
+
+sub _postfix_foreach {
+ shift->Document->find_first( sub {
+ my $main_element=$_[1];
+ $main_element->isa('PPI::Token::Word') or return '';
+ $main_element->content eq 'foreach' or return '';
+ return '' if is_hash_key($main_element);
+ return '' if is_method_call($main_element);
+ return '' if is_subroutine_name($main_element);
+ return '' if is_included_module_name($main_element);
+ return '' if is_package_declaration($main_element);
+ my $stmnt = $main_element->statement();
+ return '' if !$stmnt;
+ return '' if $stmnt->isa('PPI::Statement::Compound');
+ return 1;
+ } );
+}
+
+# weak references require perl 5.6
+# will not work in case of importing several
+sub _weaken {
+ shift->Document->find_first( sub {
+ (
+ $_[1]->isa('PPI::Statement::Include')
+ and
+ $_[1]->module eq 'Scalar::Util'
+ and
+ $_[1]->content =~ /[^:]\b(?:weaken|isweak)\b[^:]/
+ )
+ or
+ (
+ $_[1]->isa('PPI::Token::Word')
+ and
+ (
+ $_[1]->content eq 'Scalar::Util::isweak'
+ or
+ $_[1]->content eq 'Scalar::Util::weaken'
+ )
+ #and
+ #is_function_call($_[1])
+ )
+ } );
+}
+
+
+
+
+
+#####################################################################
+# Support Functions
+
+# Let sub be a function, object method, and static method
+sub _SELF {
+ my $param = shift;
+ if ( _INSTANCE($param->[0], 'Perl::MinimumVersion') ) {
+ return shift @$param;
+ }
+ if (
+ _CLASS($param->[0])
+ and
+ $param->[0]->isa('Perl::MinimumVersion')
+ ) {
+ my $class = shift @$param;
+ my $options = shift @$param;
+ return $class->new($options);
+ }
+ Perl::MinimumVersion->new(shift @$param);
+}
+
+# Find the maximum version, ignoring problems
+sub _max {
+ defined $_[0] and "$_[0]" eq PMV and shift;
+
+ # Filter and prepare for a Schwartian maximum
+ my @valid = map {
+ [ $_, $_->isa(REASON) ? $_->version : $_ ]
+ } grep {
+ _INSTANCE($_, REASON)
+ or
+ _INSTANCE($_, 'version')
+ } @_ or return '';
+
+ # Find the maximum
+ my $max = shift @valid;
+ foreach my $it ( @valid ) {
+ $max = $it if $it->[1] > $max->[1];
+ }
+
+ return $max->[0];
+}
+
+1;
+
+=pod
+
+=head1 BUGS
+
+B<Perl::MinimumVersion> does a reasonable job of catching the best-known
+explicit version dependencies.
+
+B<However> it is exceedingly easy to add a new syntax check, so if you
+find something this is missing, copy and paste one of the existing
+5 line checking functions, modify it to find what you want, and report it
+to rt.cpan.org, along with the version needed.
+
+I don't even need an entire diff... just the function and version.
+
+=head1 TO DO
+
+B<Write lots more version checkers>
+
+- Perl 5.10 operators and language structures
+
+- Three-argument open
+
+B<Write the explicit version checker>
+
+B<Write the recursive module descend stuff>
+
+B<Check for more 5.12 features (currently only detecting
+C<package NAME VERSION;>, C<...>, and C<use feature ':5.12'>)>
+
+=head1 SUPPORT
+
+All bugs should be filed via the CPAN bug tracker at
+
+L<http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Perl-MinimumVersion>
+
+For other issues, or commercial enhancement or support, contact the author.
+
+=head1 AUTHORS
+
+Adam Kennedy E<lt>adamk@cpan.orgE<gt>
+
+=head1 SEE ALSO
+
+L<http://ali.as/>, L<PPI>, L<version>
+
+=head1 COPYRIGHT
+
+Copyright 2005 - 2010 Adam Kennedy.
+
+This program is free software; you can redistribute
+it and/or modify it under the same terms as Perl itself.
+
+The full text of the license can be found in the
+LICENSE file included with this module.
+
+=cut
diff -urN Perl-MinimumVersion-1.24/t.old/02_main.t Perl-MinimumVersion-1.24/t/02_main.t
--- Perl-MinimumVersion-1.24/t.old/02_main.t 2010-01-21 22:26:15.000000000 +0100
+++ Perl-MinimumVersion-1.24/t/02_main.t 2010-05-03 09:23:30.000000000 +0200
@@ -8,7 +8,7 @@
$^W = 1;
}
-use Test::More tests => 74;
+use Test::More tests => 75;
use version;
use File::Spec::Functions ':ALL';
use PPI;
@@ -210,6 +210,11 @@
"5.006 syntax found when no limit supplied",
);
is(
+ $minver->minimum_syntax_version(5.005),
+ 5.006,
+ "5.006 syntax found when 5.005 limit supplied",
+);
+is(
$minver->minimum_syntax_version(version->new(5.008)),
'',
"no syntax constraints found when 5.008 limit supplied",
@@ -217,7 +222,7 @@
is(
Perl::MinimumVersion->minimum_syntax_version($doc, version->new(5.008)),
'',
- "also works as object method with limit: no constriants found",
+ "also works as object method with limit: no constraints found",
);
}
diff -urN Perl-MinimumVersion-1.24/t.old/03_open_3arg.t Perl-MinimumVersion-1.24/t/03_open_3arg.t
--- Perl-MinimumVersion-1.24/t.old/03_open_3arg.t 2010-01-21 22:26:15.000000000 +0100
+++ Perl-MinimumVersion-1.24/t/03_open_3arg.t 2010-05-03 09:23:30.000000000 +0200
@@ -1,38 +1,38 @@
-#!/usr/bin/perl -w
-
-use strict;
-BEGIN {
- $| = 1;
- $^W = 1;
-}
-
-use Test::More;
-
-#use version;
-use Perl::MinimumVersion;
-my @examples_not3arg = (
- q{close $x;},
- q{open A,'test.txt'},
- q{open INFO, "< datafile" or print "can't open datafile: ",$!;},
- q{open INFO, "< datafile" or die;},
- q{open(INFO, "datafile") || die("can't open datafile: $!");},
- q{open my $fh, ">$output";},
- q/if(open my $fh, $output) {}/,
-);
-my @examples_3arg = (
- q{open A,'<','test.txt';},
- q{open( INFO, ">", $datafile ) || die "Can't create $datafile: $!";},
- q{open( INFO, ">", $datafile )},
- q{open my $fh, '>', $output;},
- q/if(open my $fh, '>', $output) {}/,
- q{open my $fh, '|-', 'test','arg1';},
-);
-plan tests =>(@examples_3arg+@examples_not3arg);
-foreach my $example (@examples_not3arg) {
- my $p = Perl::MinimumVersion->new(\$example);
- is( $p->_three_argument_open, '', $example );
-}
-foreach my $example (@examples_3arg) {
- my $p = Perl::MinimumVersion->new(\$example);
- ok( $p->_three_argument_open, $example );
-}
+#!/usr/bin/perl -w
+
+use strict;
+BEGIN {
+ $| = 1;
+ $^W = 1;
+}
+
+use Test::More;
+
+#use version;
+use Perl::MinimumVersion;
+my @examples_not3arg = (
+ q{close $x;},
+ q{open A,'test.txt'},
+ q{open INFO, "< datafile" or print "can't open datafile: ",$!;},
+ q{open INFO, "< datafile" or die;},
+ q{open(INFO, "datafile") || die("can't open datafile: $!");},
+ q{open my $fh, ">$output";},
+ q/if(open my $fh, $output) {}/,
+);
+my @examples_3arg = (
+ q{open A,'<','test.txt';},
+ q{open( INFO, ">", $datafile ) || die "Can't create $datafile: $!";},
+ q{open( INFO, ">", $datafile )},
+ q{open my $fh, '>', $output;},
+ q/if(open my $fh, '>', $output) {}/,
+ q{open my $fh, '|-', 'test','arg1';},
+);
+plan tests =>(@examples_3arg+@examples_not3arg);
+foreach my $example (@examples_not3arg) {
+ my $p = Perl::MinimumVersion->new(\$example);
+ is( $p->_three_argument_open, '', $example );
+}
+foreach my $example (@examples_3arg) {
+ my $p = Perl::MinimumVersion->new(\$example);
+ ok( $p->_three_argument_open, $example );
+}
diff -urN Perl-MinimumVersion-1.24/t.old/04_substr.t Perl-MinimumVersion-1.24/t/04_substr.t
--- Perl-MinimumVersion-1.24/t.old/04_substr.t 2010-01-21 22:26:15.000000000 +0100
+++ Perl-MinimumVersion-1.24/t/04_substr.t 2010-05-03 09:23:30.000000000 +0200
@@ -1,32 +1,32 @@
-#!/usr/bin/perl -w
-
-use strict;
-BEGIN {
- $| = 1;
- $^W = 1;
-}
-
-use Test::More;
-
-#use version;
-use Perl::MinimumVersion;
-my @examples_not=(
- q{substr 'asdf',1,1 or print 2,2;},
- q{substr('asdf',1,1);},
- q{my $a=substr('asdf',1,1);},
- q{$a->substr('asdf',1,1,'aa');},
-);
-my @examples_yes=(
- q{substr('asdf',1,1,'tt');},
- q{my $a=substr('asdf',1,1,'aa');},
- q/if(substr('asdf',1,1,'aa')) {}/,
-);
-plan tests =>(@examples_yes+@examples_not);
-foreach my $example (@examples_not) {
- my $p = Perl::MinimumVersion->new(\$example);
- is($p->_substr_4_arg,'',$example);
-}
-foreach my $example (@examples_yes) {
- my $p = Perl::MinimumVersion->new(\$example);
- is($p->_substr_4_arg, 'substr', $example);
-}
+#!/usr/bin/perl -w
+
+use strict;
+BEGIN {
+ $| = 1;
+ $^W = 1;
+}
+
+use Test::More;
+
+#use version;
+use Perl::MinimumVersion;
+my @examples_not=(
+ q{substr 'asdf',1,1 or print 2,2;},
+ q{substr('asdf',1,1);},
+ q{my $a=substr('asdf',1,1);},
+ q{$a->substr('asdf',1,1,'aa');},
+);
+my @examples_yes=(
+ q{substr('asdf',1,1,'tt');},
+ q{my $a=substr('asdf',1,1,'aa');},
+ q/if(substr('asdf',1,1,'aa')) {}/,
+);
+plan tests =>(@examples_yes+@examples_not);
+foreach my $example (@examples_not) {
+ my $p = Perl::MinimumVersion->new(\$example);
+ is($p->_substr_4_arg,'',$example);
+}
+foreach my $example (@examples_yes) {
+ my $p = Perl::MinimumVersion->new(\$example);
+ is($p->_substr_4_arg, 'substr', $example);
+}
diff -urN Perl-MinimumVersion-1.24/t.old/05_foreach.t Perl-MinimumVersion-1.24/t/05_foreach.t
--- Perl-MinimumVersion-1.24/t.old/05_foreach.t 2010-01-21 22:26:15.000000000 +0100
+++ Perl-MinimumVersion-1.24/t/05_foreach.t 2010-05-03 09:23:30.000000000 +0200
@@ -1,30 +1,30 @@
-#!/usr/bin/perl -w
-
-use strict;
-BEGIN {
- $| = 1;
- $^W = 1;
-}
-
-use Test::More;
-
-#use version;
-use Perl::MinimumVersion;
-my @examples_not=(
- q'foreach (1,2,3) {}',
- q{print "$_," while $a;},
-);
-my @examples_yes=(
- q{print "$_," foreach split //,"asdf";},
- q{print "$_," foreach (1,2,3,4);},
- q{print "$_," foreach 'asdf';},
-);
-plan tests =>(@examples_yes+@examples_not);
-foreach my $example (@examples_not) {
- my $p = Perl::MinimumVersion->new(\$example);
- is($p->_postfix_foreach, '', $example);
-}
-foreach my $example (@examples_yes) {
- my $p = Perl::MinimumVersion->new(\$example);
- is($p->_postfix_foreach, 'foreach', $example);
-}
+#!/usr/bin/perl -w
+
+use strict;
+BEGIN {
+ $| = 1;
+ $^W = 1;
+}
+
+use Test::More;
+
+#use version;
+use Perl::MinimumVersion;
+my @examples_not=(
+ q'foreach (1,2,3) {}',
+ q{print "$_," while $a;},
+);
+my @examples_yes=(
+ q{print "$_," foreach split //,"asdf";},
+ q{print "$_," foreach (1,2,3,4);},
+ q{print "$_," foreach 'asdf';},
+);
+plan tests =>(@examples_yes+@examples_not);
+foreach my $example (@examples_not) {
+ my $p = Perl::MinimumVersion->new(\$example);
+ is($p->_postfix_foreach, '', $example);
+}
+foreach my $example (@examples_yes) {
+ my $p = Perl::MinimumVersion->new(\$example);
+ is($p->_postfix_foreach, 'foreach', $example);
+}
diff -urN Perl-MinimumVersion-1.24/t.old/06_weaken.t Perl-MinimumVersion-1.24/t/06_weaken.t
--- Perl-MinimumVersion-1.24/t.old/06_weaken.t 2010-01-21 22:26:15.000000000 +0100
+++ Perl-MinimumVersion-1.24/t/06_weaken.t 2010-05-03 09:23:30.000000000 +0200
@@ -1,33 +1,33 @@
-#!/usr/bin/perl -w
-
-use strict;
-BEGIN {
- $| = 1;
- $^W = 1;
-}
-
-use Test::More;
-
-#use version;
-use Perl::MinimumVersion;
-my @examples_not=(
- q{use Scalar::Util;},
- q{use Scalar::Util qw/weakening/;},
-);
-my @examples_yes=(
- q{use Scalar::Util qw/test weaken test/;},
- q{use Scalar::Util qw/weaken/;},
- q{use Scalar::Util qw/isweak/;},
- q{Scalar::Util::weaken($b);},
- q'if(Scalar::Util::isweak($a)) {}',
- q'if(Scalar::Util::isweak $a ) {}',
-);
-plan tests =>(@examples_yes+@examples_not);
-foreach my $example (@examples_not) {
- my $p = Perl::MinimumVersion->new(\$example);
- is( $p->_weaken,'',$example );
-}
-foreach my $example (@examples_yes) {
- my $p = Perl::MinimumVersion->new(\$example);
- ok( $p->_weaken, $example );
-}
+#!/usr/bin/perl -w
+
+use strict;
+BEGIN {
+ $| = 1;
+ $^W = 1;
+}
+
+use Test::More;
+
+#use version;
+use Perl::MinimumVersion;
+my @examples_not=(
+ q{use Scalar::Util;},
+ q{use Scalar::Util qw/weakening/;},
+);
+my @examples_yes=(
+ q{use Scalar::Util qw/test weaken test/;},
+ q{use Scalar::Util qw/weaken/;},
+ q{use Scalar::Util qw/isweak/;},
+ q{Scalar::Util::weaken($b);},
+ q'if(Scalar::Util::isweak($a)) {}',
+ q'if(Scalar::Util::isweak $a ) {}',
+);
+plan tests =>(@examples_yes+@examples_not);
+foreach my $example (@examples_not) {
+ my $p = Perl::MinimumVersion->new(\$example);
+ is( $p->_weaken,'',$example );
+}
+foreach my $example (@examples_yes) {
+ my $p = Perl::MinimumVersion->new(\$example);
+ ok( $p->_weaken, $example );
+}
diff -urN Perl-MinimumVersion-1.24/t.old/07_splice.t Perl-MinimumVersion-1.24/t/07_splice.t
--- Perl-MinimumVersion-1.24/t.old/07_splice.t 2010-01-21 22:26:15.000000000 +0100
+++ Perl-MinimumVersion-1.24/t/07_splice.t 2010-05-03 09:23:30.000000000 +0200
@@ -1,36 +1,36 @@
-#!/usr/bin/perl -w
-
-use strict;
-BEGIN {
- $| = 1;
- $^W = 1;
-}
-
-use Test::More;
-
-#use version;
-use Perl::MinimumVersion;
-my @examples_not=(
- q{splice(@a,1);},
- q{splice @a,1;},
- q{splice @a,1,1;},
- q{splice @a,1,1,@b;},
- q{splice @a,1 or die -1,1;},
- q{$test->splice(@a,1,-1,@b);},
-);
-my @examples_yes=(
- q{splice @a,1,-1;},
- q{splice(@a,1,-1);},
- q{$c=splice(@a,1,-1);},
-);
-plan tests =>(@examples_not+@examples_yes);
-foreach my $example (@examples_not) {
- my $p = Perl::MinimumVersion->new(\$example);
+#!/usr/bin/perl -w
+
+use strict;
+BEGIN {
+ $| = 1;
+ $^W = 1;
+}
+
+use Test::More;
+
+#use version;
+use Perl::MinimumVersion;
+my @examples_not=(
+ q{splice(@a,1);},
+ q{splice @a,1;},
+ q{splice @a,1,1;},
+ q{splice @a,1,1,@b;},
+ q{splice @a,1 or die -1,1;},
+ q{$test->splice(@a,1,-1,@b);},
+);
+my @examples_yes=(
+ q{splice @a,1,-1;},
+ q{splice(@a,1,-1);},
+ q{$c=splice(@a,1,-1);},
+);
+plan tests =>(@examples_not+@examples_yes);
+foreach my $example (@examples_not) {
+ my $p = Perl::MinimumVersion->new(\$example);
is($p->_splice_negative_length, '', $example)
- or do { diag "\$\@: $@" if $@ };
-}
-foreach my $example (@examples_yes) {
- my $p = Perl::MinimumVersion->new(\$example);
+ or do { diag "\$\@: $@" if $@ };
+}
+foreach my $example (@examples_yes) {
+ my $p = Perl::MinimumVersion->new(\$example);
is( $p->_splice_negative_length, 'splice', $example )
- or do { diag "\$\@: $@" if $@ };
-}
+ or do { diag "\$\@: $@" if $@ };
+}
diff -urN Perl-MinimumVersion-1.24/t.old/08_mkdir.t Perl-MinimumVersion-1.24/t/08_mkdir.t
--- Perl-MinimumVersion-1.24/t.old/08_mkdir.t 2010-01-21 22:26:15.000000000 +0100
+++ Perl-MinimumVersion-1.24/t/08_mkdir.t 2010-05-03 09:23:30.000000000 +0200
@@ -1,34 +1,34 @@
-#!/usr/bin/perl -w
-
-use strict;
-BEGIN {
- $| = 1;
- $^W = 1;
-}
-
-use Test::More;
-
-#use version;
-use Perl::MinimumVersion;
-my @examples_not=(
- q{mkdir1('test',1);},
- q{mkdir('test',1);},
- q{mkdir 'test',1;},
- q{$test->mkdir('a');},
-);
-my @examples_yes=(
- q{mkdir('test');},
- q{mkdir 'test';},
- q{$c=mkdir('test');},
-);
-plan tests =>(@examples_not+@examples_yes);
-foreach my $example (@examples_not) {
- my $p = Perl::MinimumVersion->new(\$example);
+#!/usr/bin/perl -w
+
+use strict;
+BEGIN {
+ $| = 1;
+ $^W = 1;
+}
+
+use Test::More;
+
+#use version;
+use Perl::MinimumVersion;
+my @examples_not=(
+ q{mkdir1('test',1);},
+ q{mkdir('test',1);},
+ q{mkdir 'test',1;},
+ q{$test->mkdir('a');},
+);
+my @examples_yes=(
+ q{mkdir('test');},
+ q{mkdir 'test';},
+ q{$c=mkdir('test');},
+);
+plan tests =>(@examples_not+@examples_yes);
+foreach my $example (@examples_not) {
+ my $p = Perl::MinimumVersion->new(\$example);
is( $p->_mkdir_1_arg, '', $example )
- or do { diag "\$\@: $@" if $@ };
-}
-foreach my $example (@examples_yes) {
- my $p = Perl::MinimumVersion->new(\$example);
+ or do { diag "\$\@: $@" if $@ };
+}
+foreach my $example (@examples_yes) {
+ my $p = Perl::MinimumVersion->new(\$example);
is( $p->_mkdir_1_arg, 'mkdir', $example )
- or do { diag "\$\@: $@" if $@ };
-}
+ or do { diag "\$\@: $@" if $@ };
+}
diff -urN Perl-MinimumVersion-1.24/t.old/09_pkg_name_version.t Perl-MinimumVersion-1.24/t/09_pkg_name_version.t
--- Perl-MinimumVersion-1.24/t.old/09_pkg_name_version.t 1970-01-01 01:00:00.000000000 +0100
+++ Perl-MinimumVersion-1.24/t/09_pkg_name_version.t 2010-05-03 09:23:30.000000000 +0200
@@ -0,0 +1,38 @@
+#!/usr/bin/perl -w
+
+use strict;
+BEGIN {
+ $| = 1;
+ $^W = 1;
+}
+
+use Test::More;
+
+#use version;
+use Perl::MinimumVersion;
+my @examples_not=(
+ q{package Foo;},
+ q{package Foo;},
+ q{use Foo 1.2;},
+ q{package Foo::Bar;},
+);
+my @examples_yes=(
+ q{package Foo 1;},
+ q{package Foo::Bar 1;},
+ q{package Foo 1;},
+ q{package Foo 1.;},
+ q{package Foo::Bar::Baz 1.000},
+ q{package Foo::Bar::Baz 1.1.1},
+);
+plan tests =>(@examples_not+@examples_yes);
+foreach my $example (@examples_not) {
+ my $p = Perl::MinimumVersion->new(\$example);
+ is( $p->_pkg_name_version, '', $example )
+ or do { diag "\$\@: $@" if $@ };
+}
+foreach my $example (@examples_yes) {
+ my $p = Perl::MinimumVersion->new(\$example);
+ ok( $p->_pkg_name_version, $example )
+ or do { diag "\$\@: $@" if $@ };
+}
+
diff -urN Perl-MinimumVersion-1.24/t.old/10_yada_yada_yada.t Perl-MinimumVersion-1.24/t/10_yada_yada_yada.t
--- Perl-MinimumVersion-1.24/t.old/10_yada_yada_yada.t 1970-01-01 01:00:00.000000000 +0100
+++ Perl-MinimumVersion-1.24/t/10_yada_yada_yada.t 2010-05-03 09:23:30.000000000 +0200
@@ -0,0 +1,34 @@
+#!/usr/bin/perl -w
+
+use strict;
+BEGIN {
+ $| = 1;
+ $^W = 1;
+}
+
+use Test::More;
+
+#use version;
+use Perl::MinimumVersion;
+my @examples_not=(
+ q{'foo'.'foo'}, # okay, okay, adding close examples is a TODO
+ q{sub foo {}},
+);
+my @examples_yes=(
+ q{...},
+ q{...;},
+ q{if(1){...}},
+ q{sub foo {...}},
+);
+plan tests =>(@examples_not+@examples_yes);
+foreach my $example (@examples_not) {
+ my $p = Perl::MinimumVersion->new(\$example);
+ is( $p->_yada_yada_yada, '', $example )
+ or do { diag "\$\@: $@" if $@ };
+}
+foreach my $example (@examples_yes) {
+ my $p = Perl::MinimumVersion->new(\$example);
+ ok( $p->_yada_yada_yada, $example )
+ or do { diag "\$\@: $@" if $@ };
+}
+
diff -urN Perl-MinimumVersion-1.24/t.old/11_feature_bundle_512.t Perl-MinimumVersion-1.24/t/11_feature_bundle_512.t
--- Perl-MinimumVersion-1.24/t.old/11_feature_bundle_512.t 1970-01-01 01:00:00.000000000 +0100
+++ Perl-MinimumVersion-1.24/t/11_feature_bundle_512.t 2010-05-03 09:23:30.000000000 +0200
@@ -0,0 +1,36 @@
+#!/usr/bin/perl -w
+
+use strict;
+BEGIN {
+ $| = 1;
+ $^W = 1;
+}
+
+use Test::More;
+
+#use version;
+use Perl::MinimumVersion;
+my @examples_not=(
+ q{use feature ':5.8'},
+ q{use feature ':5.10'},
+ q{use feature},
+ q{use feature 'say', ':5.10';},
+);
+my @examples_yes=(
+ q{use feature ':5.8', ':5.12'},
+ q{use feature ':5.12'},
+ q{use feature ':5.12', "say"},
+ q{use feature ':5.12';},
+);
+plan tests =>(@examples_not+@examples_yes);
+foreach my $example (@examples_not) {
+ my $p = Perl::MinimumVersion->new(\$example);
+ is( $p->_feature_bundle_5_12, '', $example )
+ or do { diag "\$\@: $@" if $@ };
+}
+foreach my $example (@examples_yes) {
+ my $p = Perl::MinimumVersion->new(\$example);
+ ok( $p->_feature_bundle_5_12, $example )
+ or do { diag "\$\@: $@" if $@ };
+}
+
diff -urN Perl-MinimumVersion-1.24/t.old/97_meta.t Perl-MinimumVersion-1.24/t/97_meta.t
--- Perl-MinimumVersion-1.24/t.old/97_meta.t 2010-01-21 22:26:15.000000000 +0100
+++ Perl-MinimumVersion-1.24/t/97_meta.t 1970-01-01 01:00:00.000000000 +0100
@@ -1,27 +0,0 @@
-#!/usr/bin/perl
-
-# Test that our META.yml file matches the current specification.
-
-use strict;
-BEGIN {
- $| = 1;
- $^W = 1;
-}
-
-my $MODULE = 'Test::CPAN::Meta 0.12';
-
-# Don't run tests for installs
-use Test::More;
-unless ( $ENV{AUTOMATED_TESTING} or $ENV{RELEASE_TESTING} ) {
- plan( skip_all => "Author tests not required for installation" );
-}
-
-# Load the testing module
-eval "use $MODULE";
-if ( $@ ) {
- $ENV{RELEASE_TESTING}
- ? die( "Failed to load required release-testing module $MODULE" )
- : plan( skip_all => "$MODULE not available for testing" );
-}
-
-meta_yaml_ok();
diff -urN Perl-MinimumVersion-1.24/t.old/98_pod.t Perl-MinimumVersion-1.24/t/98_pod.t
--- Perl-MinimumVersion-1.24/t.old/98_pod.t 2010-01-21 22:26:15.000000000 +0100
+++ Perl-MinimumVersion-1.24/t/98_pod.t 1970-01-01 01:00:00.000000000 +0100
@@ -1,32 +0,0 @@
-#!/usr/bin/perl
-
-# Test that the syntax of our POD documentation is valid
-
-use strict;
-BEGIN {
- $| = 1;
- $^W = 1;
-}
-
-my @MODULES = (
- 'Pod::Simple 3.07',
- 'Test::Pod 1.26',
-);
-
-# Don't run tests for installs
-use Test::More;
-unless ( $ENV{AUTOMATED_TESTING} or $ENV{RELEASE_TESTING} ) {
- plan( skip_all => "Author tests not required for installation" );
-}
-
-# Load the testing modules
-foreach my $MODULE ( @MODULES ) {
- eval "use $MODULE";
- if ( $@ ) {
- $ENV{RELEASE_TESTING}
- ? die( "Failed to load required release-testing module $MODULE" )
- : plan( skip_all => "$MODULE not available for testing" );
- }
-}
-
-all_pod_files_ok();
diff -urN Perl-MinimumVersion-1.24/t.old/99_pmv.t Perl-MinimumVersion-1.24/t/99_pmv.t
--- Perl-MinimumVersion-1.24/t.old/99_pmv.t 2010-01-21 22:26:15.000000000 +0100
+++ Perl-MinimumVersion-1.24/t/99_pmv.t 1970-01-01 01:00:00.000000000 +0100
@@ -1,32 +0,0 @@
-#!/usr/bin/perl
-
-# Test that our declared minimum Perl version matches our syntax
-
-use strict;
-BEGIN {
- $| = 1;
- $^W = 1;
-}
-
-my @MODULES = (
- 'Perl::MinimumVersion 1.20',
- 'Test::MinimumVersion 0.008',
-);
-
-# Don't run tests for installs
-use Test::More;
-unless ( $ENV{AUTOMATED_TESTING} or $ENV{RELEASE_TESTING} ) {
- plan( skip_all => "Author tests not required for installation" );
-}
-
-# Load the testing modules
-foreach my $MODULE ( @MODULES ) {
- eval "use $MODULE";
- if ( $@ ) {
- $ENV{RELEASE_TESTING}
- ? die( "Failed to load required release-testing module $MODULE" )
- : plan( skip_all => "$MODULE not available for testing" );
- }
-}
-
-all_minimum_version_from_metayml_ok();
Reference in New Issue Copy Permalink