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();