diff --git a/Perl-MinimumVersion-25.patch b/Perl-MinimumVersion-25.patch new file mode 100644 index 0000000..f4d44bf --- /dev/null +++ b/Perl-MinimumVersion-25.patch @@ -0,0 +1,2107 @@ +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 + ++B, C<...>, and C)> ++ + =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 takes Perl source code and calculates the minimum ++version of perl required to be able to run it. Because it is based on ++L, 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. ++ ++Future plans are to also add support for tracing module dependencies. ++ ++Using C 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 constructor creates a new version checking object for a ++L. You can also provide the document to be read as a ++file name, or as a C reference containing the code. ++ ++Returns a new C object, or C 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 accessor can be used to get the L object ++back out of the version checker. ++ ++=cut ++ ++sub Document { ++ $_[0]->{Document} ++} ++ ++ ++ ++ ++ ++##################################################################### ++# Main Methods ++ ++=pod ++ ++=head2 minimum_version ++ ++The C method is the primary method for finding the ++minimum perl version required based on C factors in the document. ++ ++At the present time, this is just syntax and explicit version checks, ++as L is not yet completed. ++ ++Returns a L object, or C 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 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 object, false if no dependencies could be found, ++or C 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 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 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 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 object, false if no dependencies could be found, ++or C 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 ++ ++The C 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 object, false if no dependencies could be found, or ++C 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 does a reasonable job of catching the best-known ++explicit version dependencies. ++ ++B 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 ++ ++- Perl 5.10 operators and language structures ++ ++- Three-argument open ++ ++B ++ ++B ++ ++B, C<...>, and C)> ++ ++=head1 SUPPORT ++ ++All bugs should be filed via the CPAN bug tracker at ++ ++L ++ ++For other issues, or commercial enhancement or support, contact the author. ++ ++=head1 AUTHORS ++ ++Adam Kennedy Eadamk@cpan.orgE ++ ++=head1 SEE ALSO ++ ++L, L, L ++ ++=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(); diff --git a/perl-Perl-MinimumVersion.spec b/perl-Perl-MinimumVersion.spec index 3ddb72e..e8ed4ea 100644 --- a/perl-Perl-MinimumVersion.spec +++ b/perl-Perl-MinimumVersion.spec @@ -1,11 +1,12 @@ Name: perl-Perl-MinimumVersion Version: 1.24 -Release: 1%{?dist} +Release: 2%{?dist} Summary: Find a minimum required version of perl for Perl code License: GPL+ or Artistic Group: Development/Libraries URL: http://search.cpan.org/dist/Perl-MinimumVersion/ Source0: http://search.cpan.org/CPAN/authors/id/A/AD/ADAMK/Perl-MinimumVersion-%{version}.tar.gz +Patch0: Perl-MinimumVersion-25.patch BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n) Requires: perl(:MODULE_COMPAT_%(eval "`%{__perl} -V:version`"; echo $version)) @@ -33,6 +34,7 @@ Find a minimum required version of perl for Perl code %prep %setup -q -n Perl-MinimumVersion-%{version} +%patch0 -p1 %build %{__perl} Makefile.PL INSTALLDIRS=vendor @@ -60,6 +62,10 @@ make test AUTOMATED_TESTING=1 %{_mandir}/man3/* %changelog +* Mon May 3 2010 Marcela Mašláňová - 1.24-2 +- for the meantime apply changes from trunk. Other builds using + this package should succed with perl-5.12. + * Mon Mar 01 2010 Ralf Corsépius - 1.24-1 - Upstream update. - Adjust BR's.