File Coverage

blib/lib/Test/Version.pm

Criterion	Covered	Total	%
statement	139	143	97.2
branch	71	78	91.0
condition	20	26	76.9
subroutine	13	13	100.0
pod	2	2	100.0
total	245	262	93.5

package Test::Version;
use 5.006;
use strict;
use warnings;
use Carp;

our $VERSION = '2.09'; # VERSION

use parent 'Exporter';
use Test::Builder;
use version 0.86 qw( is_lax is_strict );
use File::Find::Rule::Perl;
use Test::More;
use Module::Metadata 1.000020;

our @EXPORT = qw( version_all_ok ); ## no critic (Modules::ProhibitAutomaticExportation)
our @EXPORT_OK = qw( version_ok );

my $cfg;

sub import { ## no critic qw( Subroutines::RequireArgUnpacking Subroutines::RequireFinalReturn )
  my @exports;
  foreach my $param ( @_ ) {
    unless ( ref( $param ) eq 'HASH' ) {
      push @exports, $param;
    } else {
      $cfg = $param
    }
  }

  $cfg->{is_strict}
    = defined $cfg->{is_strict}           ? $cfg->{is_strict}
    :                                       0
    ;

  $cfg->{has_version}
    = defined $cfg->{has_version}         ? $cfg->{has_version}
    :                                       1
    ;

  $cfg->{consistent}
    = defined $cfg->{consistent}          ? $cfg->{consistent}
    :                                       0
    ;

  $cfg->{filename_match}
    = defined $cfg->{filename_match}      ? $cfg->{filename_match}
    :                                       []
    ;

  $cfg->{multiple}
    = defined $cfg->{multiple}            ? $cfg->{multiple}
    :                                       0
    ;

  unless(ref($cfg->{filename_match}) eq 'ARRAY') {
          $cfg->{filename_match} = [$cfg->{filename_match}];
  }

  my $mmv = version->parse( $Module::Metadata::VERSION );
  my $rec = version->parse( '1.000020'  );
  if ( $mmv >= $rec && ! defined $cfg->{ignore_unindexable} ) {
    $cfg->{ignore_unindexable} = 1;
  }

  __PACKAGE__->export_to_level( 1, @exports );
}

my $version_counter = 0;
my $version_number;
my $consistent = 1;
my %versions;

my $test = Test::Builder->new;

our $_IN_VERSION_ALL_OK = 0;
our %FILE_FIND_RULE_EXTRAS = (
  untaint => 1,
  #
  # the untainting pattern for Windows used by File::Find seems to be wrong.
  #
  #  - cwd returns an absolute directory will usually return a volume (e.g. 'C:')
  #  - windows file systems frequently include directorieswith parans and spaces in them
  #    I am a little dubious that accepting them is safe.  The alternative is that
  #    this module would not be installable in a lot of environments, and I honestly
  #    don't believe that many people are using Test::Version in taint mode on Windows
  #    anyway, so I am weighing the risk as worth it.
  #  - windows has short names with tildes in them (e.g. "FOO~1").  Tilde is not a
  #    special character in windows shells anyway, so I think we should be safe there.
  #
  ($^O eq 'MSWin32' ? (untaint_pattern => qr|^(([a-zA-Z]:)?[-+@\w./\~\(\) ]+)$|x) : ()),
);


sub version_ok {
  my ( $file, $name ) = @_;
  $file ||= '';
  $name ||= "check version in '$file'";

  croak 'No file passed to version_ok().' unless $file;

  croak "'$file' doesn't exist." unless -e $file;

  my $info = Module::Metadata->new_from_file( $file );
  if ( $cfg->{ignore_unindexable} && ! $info->is_indexable) {
    $test->skip( "$file not indexable" );
    return 0;
  }

  if(@{ $cfg->{filename_match} } > 0) {
    my $match = 0;
    foreach my $pattern (@{ $cfg->{filename_match} }) {

      if(ref($pattern) eq 'Regexp') {
        $match = 1 if $file =~ $pattern;
      }

      elsif(ref($pattern) eq 'CODE') {
        $match = 1 if $pattern->($file);
      }

      else {
        $match = 1 if $file eq $pattern;
      }

      last if $match;
    }
    unless ($match) {
      $test->skip( "$file does not match filename_match" );
      return 0;
    }
  }

  my $ok = 1;
  my @diag;
  my @packages = $cfg->{multiple} ? $info->packages_inside : ($info->name);

  unless($_IN_VERSION_ALL_OK) {
    $consistent = 1;
    $version_number  = undef;
  }

  unless($cfg->{has_version}) {
    @packages = grep { $info->version($_) } @packages;
    unless(@packages) {
      $test->skip(qq{No versions were found in "$file" and has_version is false});
      $consistent = 0;
      $versions{$file}->{$info->name} = undef;
      return 1;
    }
  }

  unless(@packages) {
    $ok = 0;
    push @diag, "No packages found in '$file'";
  }

  foreach my $package (@packages) {

    my $version = $info->version($package);

    $versions{$file}->{$package} = $version;

    if (not defined $version) {
      $consistent = 0;
    }

    $version_counter++;

    unless ( $version ) {
      $ok = 0;
      push @diag, "No version was found in '$file' ($package).";
      next;
    }

    unless (defined $version_number) {
      $version_number = $version;
    }
    if ($version ne $version_number) {
      $consistent = 0;
    }

    unless ( is_lax( $version ) ) {
      $ok = 0;
      push @diag, "The version '$version' found in '$file' ($package) is invalid.";
      next;
    }

    if ( $cfg->{is_strict} ) {
      unless ( is_strict( $version ) ) {
        $ok = 0;
        push @diag, "The version '$version' found in '$file' ($package) is not strict.";
        next;
      }
    }
  }

  unless($_IN_VERSION_ALL_OK) {
    if($ok && ! $consistent && $cfg->{consistent}) {
      $ok = 0;
      push @diag, "The versions found in '$file' are inconsistent.";
    }
  }

  $test->ok( $ok, $name );
  $test->diag($_) for @diag;
  return $ok;
}

sub version_all_ok {
  my ( $dir, $name ) = @_;

  $version_counter = 0;
  $version_number  = undef;
  $consistent      = 1;
  %versions        = ();

  $dir
    = defined $dir ? $dir
    : -d 'blib'    ? 'blib'
    :                'lib'
    ;

  croak $dir . ' does not exist, or is not a directory' unless -d $dir;

  # Report failure location correctly - GH #1
  local $Test::Builder::Level = $Test::Builder::Level + 1; ## no critic (Variables::ProhibitPackageVars)

  $name ||= "all modules in $dir have valid versions";

  my @files = File::Find::Rule->perl_module->extras(\%FILE_FIND_RULE_EXTRAS)->in($dir);

  {
    local $_IN_VERSION_ALL_OK = 1;
    foreach my $file ( @files ) {
      version_ok( $file );
    }
  }

  if ($cfg->{consistent} and not $consistent) {
    $test->ok( 0, $name );
    $test->diag('The version numbers in this distribution are not the same');
    foreach my $file (sort keys %versions) {
      foreach my $package (sort keys %{ $versions{$file} }) {
        my $version = $versions{$file}->{$package};
        $test->diag(sprintf "%10s %s (%s)", defined $version ? $version : 'undef', $file, $package);
      }
    }
    return;
  }

  # has at least 1 version in the dist
  if ( not $cfg->{has_version} and $version_counter < 1 ) {
    $test->ok( 0, $name );
    $test->diag(
      'Your dist has no valid versions defined. '
      . 'Must have at least one version'
      );
  }
  else {
    $test->ok( 1, $name );
  }

  return;
}
1;

# ABSTRACT: Check to see that version's in modules are sane

__END__