NAME

Module::Setup::Helper - build in your application helper support

SYNOPSIS

script/helper.pl is your helper script

use strict;
use warnings;

my $type = shift @ARGV;
my $helper = "YourApp::Helper::$type";
eval "use $helper";

$helper->new(
    argv    => [ @ARGV ],
    options => {
        # Module::Setup's options
    },
    helper => {
        option => 'FOO_OPTION',
    },
)->run;

lib/YourApp/Helper.pm is your application helper base class.

package YourApp::Helper;
use strict;
use warnings;
use base 'Module::Setup::Helper';

# make your application's options name prefix
sub helper_option_prefix { 'yourapp' }

sub helper_base_init {
    my $self = shift;

    # auto detect app module name by Makefile.PL
    open my $fh, '<', 'Makefile.PL' or die $!;
    local $/;
    my $makefile = <$fh>;
    my($module) = $makefile =~ /all_from 'lib/(.+).pm'/;
    unless ($module) {
        return $self->{options}->{module} = shift @{ $self->{argv} };
    }
    $module =~ s{/}{::}g;
    $self->{options}->{module} = $module;
}



1;

lib/YourApp/Helper/Controller.pm is your application helper for controller

package YourApp::Helper::Controller;
use strict;
use warnings;
use base 'YourApp::Helper';

sub generate_path_option_names { qw/ target / }
sub is_append_files { 1 } # append type helper

sub helper_flavor_init {
    my $self = shift;

    # auto detect target name by @ARGV
    my $target = $self->{argv}->[0];
    die 'required target name' unless $target;
    $self->{helper}->{target} = $target;
}

1;

__DATA__
---
file: lib/____var-module_path-var____/Controller/____var-yourapp_target_path-var____.pm
template: |
  package [% module %]::Controller::[% yourapp_target %];
  use base 'YourApp::Controller';

  my $option = '[% yourapp_option %]';

  ... some code

  1;
file: t/100_controller/____var-yourapp_target_path-var____.t
template: |
  use Test::More tests => 1;
  use_ok '[% yourapp_app %]::Controller::[% yourapp_target %]';

run the script/helper.pl

$ perl ./script/helper.pl Controller Search
$ cat lib/Foo/Controller/Search.pm
package Foo::Controller::Search;
use base 'YourApp::Controller';

my $option = 'FOO_OPTION';

... some code

1;
$ cat t/100_controller/Search.t
  use Test::More tests => 1;
  use_ok 'Foo::Controller::Search';

Helper Hook Point

helper_option_prefix (required)

When using config of helper by template, prefix specified here is used.

sub helper_option_prefix { 'foo' }

in your flavor's template

[% foo_bar %]
# use the $self->{helper}->{bar}

is_append_files

When this function returns truth, flavor is added to the existing application.

sub is_append_files { 1 } # default is false

It is the same work as the time helper of adding Controller of Catalyst.

helper_base_init

helper initialize phase for your application helper base class

# default
sub helper_base_init {
    my $self = shift;
    $self->{options}->{module} = shift @{ $self->{argv} };
}

you can set the base module name

helper_flavor_init

helper initialize phase for flavor class

sub helper_flavor_init {
    my $self = shift;
    $self->{helper} = {
        # some options for helper
    };
}

you can set the target module name, or more options for helper

$helper->{helper}->{setup_template_vars_callback}

you can set the callback for setup_template_vars phase

sub helper_flavor_init {
    my $self = shift;
    # set callback handler for setup_template_vars hook point
    $self->{helper}->{setup_template_vars_callback} = sub {
        my($setup, $vars) = @_;
        $vars->{callback_var} = 'this is callback var';
        $vars->{callback_path} = 'callback/path';
    };
}

example is t/Helper/Basic/Callback.pm

helper_default_plugins

Plugin which helper uses is listed.

# default
sub helper_default_plugins { qw/ Template Helper / }

before_run

It is a phase just before helper actually starts Module::Setup.

cpanm Module::Setup

perl -MCPAN -e shell
install Module::Setup