view release on metacpan or  search on metacpan

lib/Dist/Zilla/Plugin/MakeMaker/Awesome.pm  view on Meta::CPAN

    : '';
}}
my {{ $fallback_prereqs }}

unless ( eval { ExtUtils::MakeMaker->VERSION('6.63_03') } ) {
  delete $WriteMakefileArgs{TEST_REQUIRES};
  delete $WriteMakefileArgs{BUILD_REQUIRES};
  $WriteMakefileArgs{PREREQ_PM} = \%FallbackPrereqs;
}

delete $WriteMakefileArgs{CONFIGURE_REQUIRES}
  unless eval { ExtUtils::MakeMaker->VERSION(6.52) };

WriteMakefile(%WriteMakefileArgs);

{{ $share_dir_block[1] }}

{{ $footer }}
TEMPLATE

  return $template;
}

around BUILDARGS => sub
{
    my $orig = shift;
    my $class = shift;

    my $args = $class->$orig(@_);

    my $delimiter = delete $args->{delimiter};
    if (defined $delimiter and length($delimiter))
    {
        foreach my $arg (grep exists $args->{$_}, qw(WriteMakefile_arg_strs header_strs footer_strs))
        {
            s/^\Q$delimiter\E// foreach @{$args->{$arg}};
        }
    }

    return $args;
};

around dump_config => sub
{
    my ($orig, $self) = @_;
    my $config = $self->$orig;

    my $data = {
        blessed($self) ne __PACKAGE__ ? ( version => $VERSION ) : (),
    };
    $config->{+__PACKAGE__} = $data if keys %$data;

    $config->{'Dist::Zilla::Plugin::MakeMaker'}{make_path} ||= $self->make_path;
    $config->{'Dist::Zilla::Plugin::MakeMaker'}{version} ||= Dist::Zilla::Plugin::MakeMaker->VERSION;
    $config->{'Dist::Zilla::Role::TestRunner'}{version} ||= Dist::Zilla::Role::TestRunner->VERSION;

    return $config;
};

has WriteMakefile_arg_strs => (
    is => 'ro', isa => ArrayRef[Str],
    traits => ['Array'],
    lazy => 1,
    default => sub { [] },
    documentation => "Additional arguments passed to ExtUtils::MakeMaker's WriteMakefile()",
);

has WriteMakefile_args => (
    isa           => HashRef,
    traits        => ['Hash'],
    handles       => {
        WriteMakefile_args => 'elements',
        delete_WriteMakefile_arg => 'delete',
        WriteMakefile_arg => 'get',
    },
    lazy          => 1,
    builder       => '_build_WriteMakefile_args',
    documentation => "The arguments passed to ExtUtils::MakeMaker's WriteMakefile()",
);

sub _build_WriteMakefile_args {
    my ($self) = @_;

    (my $name = $self->zilla->name) =~ s/-/::/g;
    my $test_files = $self->test_files;

    my $perl_prereq = $self->min_perl_version;

    my $prereqs_dump = sub {
        $self->zilla->prereqs->requirements_for(@_)
        ->clone
        ->clear_requirement('perl')
        ->as_string_hash;
    };

    my %require_prereqs = map
        +($_ => $prereqs_dump->($_, 'requires')),
        qw(configure build test runtime);

    # EUMM may soon be able to support this, but until we decide to inject a
    # higher configure-requires version, we should at least warn the user
    # https://github.com/Perl-Toolchain-Gang/ExtUtils-MakeMaker/issues/215
    foreach my $phase (qw(configure build test runtime)) {
        if (my @version_ranges = pairgrep { defined $b && !version::is_lax($b) } %{ $require_prereqs{$phase} }
                and $self->eumm_version < '7.1101') {
            $self->log_fatal([
                'found version range in %s prerequisites, which ExtUtils::MakeMaker cannot parse (must specify eumm_version of at least 7.1101): %s %s',
                $phase, $_->[0], $_->[1]
            ]) foreach pairs @version_ranges;
        }
    }

    my @authors = eval { Dist::Zilla->VERSION('7.000') } ? $self->zilla->authors : @{ $self->zilla->authors };
    my $exe_files = $self->exe_files;

    my %WriteMakefile = (
        DISTNAME  => $self->zilla->name,
        NAME      => $name,
        ( AUTHOR  => @authors > 1 && ($self->eumm_version >= 6.5702 || $perl_prereq >= 5.013005)
                     ? \@authors
                     : join(q{, }, @authors) ),

lib/Dist/Zilla/Plugin/MakeMaker/Awesome.pm  view on Meta::CPAN

}

has exe_files => (
    is            => 'ro',
    isa           => ArrayRef[Str],
    lazy          => 1,
    builder       => '_build_exe_files',
    documentation => "The list of filenames given to ExtUtils::MakeMaker's EXE_FILES (in munged form)",
);

sub _build_exe_files {
    my ($self) = @_;

    my @exe_files = map $_->name, @{ $self->zilla->find_files(':ExecFiles') };

    return \@exe_files;
}

has share_dir_block => (
    is            => 'ro',
    isa           => ArrayRef[Str],
    auto_deref    => 1,
    lazy          => 1,
    builder       => '_build_share_dir_block',
    documentation => "The share dir block used in `MakeFile_PL_template'",
);

sub _build_share_dir_block {
    my ($self) = @_;

    my @share_dir_block = (q{}, q{});

    my $share_dir_map = $self->zilla->_share_dir_map;
    if ( keys %$share_dir_map ) {
        # split in two to foil CPANTS prereq_matches_use
        my $preamble = qq{use File::Shar}.qq{eDir::Install;\n};
        $preamble .= qq{\$File::ShareDir::Install::INCLUDE_DOTFILES = 1;\n};
        $preamble .= qq{\$File::ShareDir::Install::INCLUDE_DOTDIRS = 1;\n};
        if ( my $dist_share_dir = $share_dir_map->{dist} ) {
            $dist_share_dir = quotemeta $dist_share_dir;
            $preamble .= qq{install_share dist => "$dist_share_dir";\n};
        }

        if ( my $mod_map = $share_dir_map->{module} ) {
            for my $mod ( keys %$mod_map ) {
                my $mod_share_dir = quotemeta $mod_map->{$mod};
                $preamble .= qq{install_share module => "$mod", "$mod_share_dir";\n};
            }
        }
        @share_dir_block = (
            $preamble,
            qq{\{\npackage\nMY;\nuse File::ShareDir::Install qw(postamble);\n\}\n},

        );
    }

    return \@share_dir_block;
}

has header_strs => (
    is => 'ro', isa => ArrayRef[Str],
    traits => ['Array'],
    lazy => 1,
    default => sub { [] },
    documentation => "Additional code lines to include at the beginning of Makefile.PL",
);

has header_file => (
    is => 'ro', isa => Str,
    documentation => 'Additional header content to include from a file',
);

has header => (
    is            => 'ro',
    isa           => Str,
    lazy          => 1,
    builder       => '_build_header',
    documentation => "A string included at the beginning of Makefile.PL",
);

sub _build_header {
    my $self = shift;
    join "\n",
        @{$self->header_strs},
        ( $self->header_file
            ? do {
                my $abs_file = path($self->zilla->root, $self->header_file);
                $self->log_fatal([ 'header_file %s does not exist!', $self->header_file ])
                    if not $abs_file->exists;
                $abs_file->slurp_utf8
            }
            : () );
}

has footer_strs => (
    is => 'ro', isa => ArrayRef[Str],
    traits => ['Array'],
    lazy => 1,
    default => sub { [] },
    documentation => "Additional code lines to include at the end of Makefile.PL",
);

has footer_file => (
    is => 'ro', isa => Str,
    documentation => 'Additional footer content to include from a file',
);

has footer => (
    is            => 'ro',
    isa           => Str,
    lazy          => 1,
    builder       => '_build_footer',
    documentation => "A string included at the end of Makefile.PL",
);

sub _build_footer {
    my $self = shift;
    join "\n",
        @{$self->footer_strs},
        ( $self->footer_file
            ? do {
                my $abs_file = path($self->zilla->root, $self->footer_file);
                $self->log_fatal([ 'footer_file %s does not exist!', $self->footer_file ])
                    if not $abs_file->exists;
                $abs_file->slurp_utf8
            }
            : () );
}

sub register_prereqs {
    my ($self) = @_;

    $self->zilla->register_prereqs(
        { phase => 'configure' },
        'ExtUtils::MakeMaker' => $self->eumm_version || 0,
    );

    return unless keys %{ $self->zilla->_share_dir_map };

    $self->zilla->register_prereqs(
        { phase => 'configure', type => 'requires' },
        'File::ShareDir::Install' => 0.06,
    );

    return {};
}

sub gather_files
{
    my $self = shift;

    require Dist::Zilla::File::InMemory;
    my $file = Dist::Zilla::File::InMemory->new({
        name    => 'Makefile.PL',
        content => $self->MakeFile_PL_template,     # template evaluated later
    });