#!perl

use strict;

use warnings;

# This test was generated by Dist::Zilla::Plugin::Test::ReportPrereqs 0.027

use Test::More tests => 1;

use ExtUtils::MakeMaker;

use File::Spec;

# from $version::LAX

my $lax_version_re =

    qr/(?: undef | (?: (?:[0-9]+) (?: \. | (?:\.[0-9]+) (?:_[0-9]+)? )?

            |

            (?:\.[0-9]+) (?:_[0-9]+)?

        ) | (?:

            v (?:[0-9]+) (?: (?:\.[0-9]+)+ (?:_[0-9]+)? )?

            |

            (?:[0-9]+)? (?:\.[0-9]+){2,} (?:_[0-9]+)?

        )

    )/x;

# hide optional CPAN::Meta modules from prereq scanner

# and check if they are available

my $cpan_meta = "CPAN::Meta";

my $cpan_meta_pre = "CPAN::Meta::Prereqs";

my $HAS_CPAN_META = eval "require $cpan_meta; $cpan_meta->VERSION('2.120900')" && eval "require $cpan_meta_pre"; ## no critic

# Verify requirements?

my $DO_VERIFY_PREREQS = 1;

sub _max {

    my $max = shift;

    $max = ( $_ > $max ) ? $_ : $max for @_;

    return $max;

}

sub _merge_prereqs {

    my ($collector, $prereqs) = @_;

    # CPAN::Meta::Prereqs object

    if (ref $collector eq $cpan_meta_pre) {

        return $collector->with_merged_prereqs(

            CPAN::Meta::Prereqs->new( $prereqs )

        );

    }

    # Raw hashrefs

    for my $phase ( keys %$prereqs ) {

        for my $type ( keys %{ $prereqs->{$phase} } ) {

            for my $module ( keys %{ $prereqs->{$phase}{$type} } ) {

                $collector->{$phase}{$type}{$module} = $prereqs->{$phase}{$type}{$module};

            }

        }

    }

    return $collector;

}

my @include = qw(

);

my @exclude = qw(

);

# Add static prereqs to the included modules list

my $static_prereqs = do './t/00-report-prereqs.dd';

# Merge all prereqs (either with ::Prereqs or a hashref)

my $full_prereqs = _merge_prereqs(

    ( $HAS_CPAN_META ? $cpan_meta_pre->new : {} ),

    $static_prereqs

);

# Add dynamic prereqs to the included modules list (if we can)

my ($source) = grep { -f } 'MYMETA.json', 'MYMETA.yml';

my $cpan_meta_error;

if ( $source && $HAS_CPAN_META

    && (my $meta = eval { CPAN::Meta->load_file($source) } )

) {

    $full_prereqs = _merge_prereqs($full_prereqs, $meta->prereqs);

}

else {

    $cpan_meta_error = $@;    # capture error from CPAN::Meta->load_file($source)

    $source = 'static metadata';

}

my @full_reports;

my @dep_errors;

my $req_hash = $HAS_CPAN_META ? $full_prereqs->as_string_hash : $full_prereqs;

# Add static includes into a fake section

for my $mod (@include) {

    $req_hash->{other}{modules}{$mod} = 0;

}

for my $phase ( qw(configure build test runtime develop other) ) {

    next unless $req_hash->{$phase};

    next if ($phase eq 'develop' and not $ENV{AUTHOR_TESTING});

    for my $type ( qw(requires recommends suggests conflicts modules) ) {

        next unless $req_hash->{$phase}{$type};

        my $title = ucfirst($phase).' '.ucfirst($type);

        my @reports = [qw/Module Want Have/];

        for my $mod ( sort keys %{ $req_hash->{$phase}{$type} } ) {

            next if $mod eq 'perl';

            next if grep { $_ eq $mod } @exclude;

            my $file = $mod;

            $file =~ s{::}{/}g;

            $file .= ".pm";

            my ($prefix) = grep { -e File::Spec->catfile($_, $file) } @INC;

            my $want = $req_hash->{$phase}{$type}{$mod};

            $want = "undef" unless defined $want;

            $want = "any" if !$want && $want == 0;

            my $req_string = $want eq 'any' ? 'any version required' : "version '$want' required";

            if ($prefix) {

                my $have = MM->parse_version( File::Spec->catfile($prefix, $file) );

                $have = "undef" unless defined $have;

                push @reports, [$mod, $want, $have];

                if ( $DO_VERIFY_PREREQS && $HAS_CPAN_META && $type eq 'requires' ) {

                    if ( $have !~ /\A$lax_version_re\z/ ) {

                        push @dep_errors, "$mod version '$have' cannot be parsed ($req_string)";

                    }

                    elsif ( ! $full_prereqs->requirements_for( $phase, $type )->accepts_module( $mod => $have ) ) {

                        push @dep_errors, "$mod version '$have' is not in required range '$want'";

                    }

                }

            }

            else {

                push @reports, [$mod, $want, "missing"];

                if ( $DO_VERIFY_PREREQS && $type eq 'requires' ) {

                    push @dep_errors, "$mod is not installed ($req_string)";

                }

            }

        }

        if ( @reports ) {

            push @full_reports, "=== $title ===\n\n";

            my $ml = _max( map { length $_->[0] } @reports );

            my $wl = _max( map { length $_->[1] } @reports );

            my $hl = _max( map { length $_->[2] } @reports );

            if ($type eq 'modules') {

                splice @reports, 1, 0, ["-" x $ml, "", "-" x $hl];

                push @full_reports, map { sprintf("    %*s %*s\n", -$ml, $_->[0], $hl, $_->[2]) } @reports;

            }

            else {

                splice @reports, 1, 0, ["-" x $ml, "-" x $wl, "-" x $hl];

                push @full_reports, map { sprintf("    %*s %*s %*s\n", -$ml, $_->[0], $wl, $_->[1], $hl, $_->[2]) } @reports;

            }

            push @full_reports, "\n";

        }

    }

}

if ( @full_reports ) {

    diag "\nVersions for all modules listed in $source (including optional ones):\n\n", @full_reports;

}

if ( $cpan_meta_error || @dep_errors ) {

    diag "\n*** WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING ***\n";

}

if ( $cpan_meta_error ) {

    my ($orig_source) = grep { -f } 'MYMETA.json', 'MYMETA.yml';

    diag "\nCPAN::Meta->load_file('$orig_source') failed with: $cpan_meta_error\n";

}

if ( @dep_errors ) {

    diag join("\n",

        "\nThe following REQUIRED prerequisites were not satisfied:\n",

        @dep_errors,

        "\n"

    );

}

pass;

# vim: ts=4 sts=4 sw=4 et: