NAME

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

SYNOPSIS

script/helper.pl is your helper script

use strict;
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.

use strict;
# 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

use strict;
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
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.