[catagits/Catalyst-Devel.git] / lib / Module / Install / Catalyst.pm

package Module::Install::Catalyst;

use strict;

our @ISA;
require Module::Install::Base;
@ISA = qw/Module::Install::Base/;

use File::Find;
use FindBin;
use File::Copy::Recursive;
use File::Spec ();
use Getopt::Long ();
use Data::Dumper;

my $SAFETY = 0;

our @IGNORE =
  qw/Build Build.PL Changes MANIFEST META.yml Makefile.PL Makefile README
  _build blib lib script t inc .*\.svn \.git _darcs \.bzr \.hg
  debian build-stamp install-stamp configure-stamp/;
our @CLASSES   = ();
our $ENGINE    = 'CGI';
our $SCRIPT    = '';
our $USAGE     = '';
our %PAROPTS   = ();

=head1 NAME

  Module::Install::Catalyst - Module::Install extension for Catalyst

=head1 SYNOPSIS

  use inc::Module::Install;

  name 'MyApp';
  all_from 'lib/MyApp.pm';

  requires 'Catalyst::Runtime' => '5.7014';

  catalyst_ignore('.*temp');
  catalyst_ignore('.*tmp');
  catalyst;
  WriteAll;

=head1 DESCRIPTION

L<Module::Install> extension for Catalyst.

=head1 METHODS

=head2 catalyst

Calls L<catalyst_files> and L<catalyst_par>. Should be the last catalyst*
command called in C<Makefile.PL>.

=cut

sub catalyst {
    my $self = shift;

    if($Module::Install::AUTHOR) {
        $self->include("File::Copy::Recursive");
    }

    print <<EOF;
*** Module::Install::Catalyst
EOF
    $self->catalyst_files;
    $self->catalyst_par;
    print <<EOF;
*** Module::Install::Catalyst finished.
EOF
}

=head2 catalyst_files

Collect a list of all files a Catalyst application consists of and copy it
inside the blib/lib/ directory. Files and directories that match the modules
ignore list are excluded (see L<catalyst_ignore> and L<catalyst_ignore_all>).

=cut

sub catalyst_files {
    my $self = shift;

    chdir $FindBin::Bin;

    my @files;
    opendir CATDIR, '.';
  CATFILES: for my $name ( readdir CATDIR ) {
        for my $ignore (@IGNORE) {
            next CATFILES if $name =~ /^$ignore$/;
            next CATFILES if $name !~ /\w/;
        }
        push @files, $name;
    }
    closedir CATDIR;
    my @path = split '-', $self->name;
    for my $orig (@files) {
        my $path = File::Spec->catdir( 'blib', 'lib', @path, $orig );
        File::Copy::Recursive::rcopy( $orig, $path );
    }
}

=head2 catalyst_ignore_all(\@ignore)

This function replaces the built-in default ignore list with the given list.

=cut

sub catalyst_ignore_all {
    my ( $self, $ignore ) = @_;
    @IGNORE = @$ignore;
}

=head2 catalyst_ignore(@ignore)

Add a regexp to the list of ignored patterns. Can be called multiple times.

=cut

sub catalyst_ignore {
    my ( $self, @ignore ) = @_;
    push @IGNORE, @ignore;
}

=head2 catalyst_par($name)

=cut

# Workaround for a namespace conflict
sub catalyst_par {
    my ( $self, $par ) = @_;
    $par ||= '';
    return if $SAFETY;
    $SAFETY++;
    my $name  = $self->name;
    my $usage = $USAGE;
    $usage =~ s/"/\\"/g;
    my $class_string = join "', '", @CLASSES;
    $class_string = "'$class_string'" if $class_string;
    local $Data::Dumper::Indent = 0;
    local $Data::Dumper::Terse = 1;
    local $Data::Dumper::Pad = ' ';
    my $paropts_string = Dumper(\%PAROPTS) || "{ }";
    $self->postamble(<<EOF);
catalyst_par :: all
\t\$(NOECHO) \$(PERL) -Ilib -Minc::Module::Install -MModule::Install::Catalyst -e"Catalyst::Module::Install::_catalyst_par( '$par', '$name', { CLASSES => [$class_string], PAROPTS => $paropts_string, ENGINE => '$ENGINE', SCRIPT => '$SCRIPT', USAGE => q#$usage# } )"
EOF
    print <<EOF;
Please run "make catalyst_par" to create the PAR package!
EOF
}

=head2 catalyst_par_core($core)

=cut

sub catalyst_par_core {
    my ( $self, $core ) = @_;
    $core ? ( $PAROPTS{'B'} = $core ) : $PAROPTS{'B'}++;
}

=head2 catalyst_par_classes(@clases)

=cut

sub catalyst_par_classes {
    my ( $self, @classes ) = @_;
    push @CLASSES, @classes;
}

=head2 catalyst_par_engine($engine)

=cut

sub catalyst_par_engine {
    my ( $self, $engine ) = @_;
    $ENGINE = $engine;
}

=head2 catalyst_par_multiarch($multiarch)

=cut

sub catalyst_par_multiarch {
    my ( $self, $multiarch ) = @_;
    $multiarch ? ( $PAROPTS{'m'} = $multiarch ) : $PAROPTS{'m'}++;
}

=head2 catalyst_par_options($optstring)

This command can be used in Makefile.PL to customise the PAR creation process.
The parameter "$optstring" contains a string with arguments in identical syntax
as arguments of B<pp> command from L<PAR::Packer> package.

Example:

    # part of your Makefile.PL

    catalyst_par_options("--verbose=2 -f Bleach -z 9");
    # verbose mode; use filter 'Bleach'; zip with compression level 9
    catalyst;

Note1: There is no reason to use catalyst_par_options() command multiple times
as you can spacify in "$optstring" as many options as you want. Still, it
is supported to call catalyst_par_options() more than once. In that case the
specified options are merged (collisions are handled on principle "later wins").
BEWARE: you are discouraged from using parameters -a -A -X -f -F -I -l -M in
multiple catalyst_par_options() as they are not merged but replaced as you would
expected.

Note2: By default the options "-x -p -o=<appname>.par" are set and option "-n"
is unset. This default always overrides whatever you specify by
catalyst_par_options().

=cut

sub catalyst_par_options {
    my ( $self, $optstring ) = @_;
    eval "use PAR::Packer ()";
    if ($@) {
        warn "WARNING: catalyst_par_options ignored - you need PAR::Packer\n"
    }
    else {
        my $p = Getopt::Long::Parser->new(config => ['no_ignore_case']);
        my %o;
        require Text::ParseWords;
        {
            local @ARGV = Text::ParseWords::shellwords($optstring);
            $p->getoptions(\%o, PAR::Packer->options);
        }
        %PAROPTS = ( %PAROPTS, %o);
    }
}

=head2 catalyst_par_script($script)

=cut

sub catalyst_par_script {
    my ( $self, $script ) = @_;
    $SCRIPT = $script;
}

=head2 catalyst_par_usage($usage)

=cut

sub catalyst_par_usage {
    my ( $self, $usage ) = @_;
    $USAGE = $usage;
}

package Catalyst::Module::Install;

use strict;
use FindBin;
use File::Copy::Recursive 'rmove';
use File::Spec ();

sub _catalyst_par {
    my ( $par, $class_name, $opts ) = @_;

    my $ENGINE    = $opts->{ENGINE};
    my $CLASSES   = $opts->{CLASSES} || [];
    my $USAGE     = $opts->{USAGE};
    my $SCRIPT    = $opts->{SCRIPT};
    my $PAROPTS   = $opts->{PAROPTS};

    my $name = $class_name;
    $name =~ s/::/_/g;
    $name = lc $name;
    $par ||= "$name.par";
    my $engine = $ENGINE || 'CGI';

    # Check for PAR
    eval "use PAR ()";
    die "Please install PAR\n" if $@;
    eval "use PAR::Packer ()";
    die "Please install PAR::Packer\n" if $@;
    eval "use App::Packer::PAR ()";
    die "Please install App::Packer::PAR\n" if $@;
    eval "use Module::ScanDeps ()";
    die "Please install Module::ScanDeps\n" if $@;

    my $root = $FindBin::Bin;
    $class_name =~ s/-/::/g;
    my $path = File::Spec->catfile( 'blib', 'lib', split( '::', $class_name ) );
    $path .= '.pm';
    unless ( -f $path ) {
        print qq/Not writing PAR, "$path" doesn't exist\n/;
        return 0;
    }
    print qq/Writing PAR "$par"\n/;
    chdir File::Spec->catdir( $root, 'blib' );

    my $par_pl = 'par.pl';
    unlink $par_pl;

    my $version = $Catalyst::VERSION;
    my $class   = $class_name;

    my $classes = '';
    $classes .= "    require $_;\n" for @$CLASSES;

    unlink $par_pl;

    my $usage = $USAGE || <<"EOF";
Usage:
    [parl] $name\[.par] [script] [arguments]

  Examples:
    parl $name.par $name\_server.pl -r
    myapp $name\_cgi.pl
EOF

    my $script   = $SCRIPT;
    my $tmp_file = IO::File->new("> $par_pl ");
    print $tmp_file <<"EOF";
if ( \$ENV{PAR_PROGNAME} ) {
    my \$zip = \$PAR::LibCache{\$ENV{PAR_PROGNAME}}
        || Archive::Zip->new(__FILE__);
    my \$script = '$script';
    \$ARGV[0] ||= \$script if \$script;
    if ( ( \@ARGV == 0 ) || ( \$ARGV[0] eq '-h' ) || ( \$ARGV[0] eq '-help' )) {
        my \@members = \$zip->membersMatching('.*script/.*\.pl');
        my \$list = "  Available scripts:\\n";
        for my \$member ( \@members ) {
            my \$name = \$member->fileName;
            \$name =~ /(\\w+\\.pl)\$/;
            \$name = \$1;
            next if \$name =~ /^main\.pl\$/;
            next if \$name =~ /^par\.pl\$/;
            \$list .= "    \$name\\n";
        }
        die <<"END";
$usage
\$list
END
    }
    my \$file = shift \@ARGV;
    \$file =~ s/^.*[\\/\\\\]//;
    \$file =~ s/\\.[^.]*\$//i;
    my \$member = eval { \$zip->memberNamed("./script/\$file.pl") };
    die qq/Can't open perl script "\$file"\n/ unless \$member;
    PAR::_run_member( \$member, 1 );
}
else {
    require lib;
    import lib 'lib';
    \$ENV{CATALYST_ENGINE} = '$engine';
    require $class;
    import $class;
    require Catalyst::Helper;
    require Catalyst::Test;
    require Catalyst::Engine::HTTP;
    require Catalyst::Engine::CGI;
    require Catalyst::Controller;
    require Catalyst::Model;
    require Catalyst::View;
    require Getopt::Long;
    require Pod::Usage;
    require Pod::Text;
    $classes
}
EOF
    $tmp_file->close;

    # Create package
    local $SIG{__WARN__} = sub { };

    # STDERR used to be redirected to null, but this hid errors from PAR::Packer
    my %opt = (
        %{$PAROPTS},
        # take user defined options first and override them with harcoded defaults
        'x' => 1,
        'n' => 0,
        'o' => $par,
        'p' => 1,
    );
    # do not replace the whole $opt{'a'} array; just push required default value
    push @{$opt{'a'}}, grep( !/par.pl/, glob '.' );

    App::Packer::PAR->new(
        frontend  => 'Module::ScanDeps',
        backend   => 'PAR::Packer',
        frontopts => \%opt,
        backopts  => \%opt,
        args      => ['par.pl'],
    )->go;

    unlink $par_pl;
    chdir $root;
    rmove( File::Spec->catfile( 'blib', $par ), $par );
    return 1;
}

=head1 AUTHORS

Catalyst Contributors, see Catalyst.pm

=head1 LICENSE

This library is free software. You can redistribute it and/or modify it under
the same terms as Perl itself.

=cut

1;
Commit	Line	Data
134481a2	1	package Module::Install::Catalyst;
	2
	3	use strict;
	4
	5	our @ISA;
	6	require Module::Install::Base;
	7	@ISA = qw/Module::Install::Base/;
	8
	9	use File::Find;
	10	use FindBin;
ead1c47c	11	use File::Copy::Recursive;
134481a2	12	use File::Spec ();
09a0d496	13	use Getopt::Long ();
84a68fcf	14	use Data::Dumper;
134481a2	15
	16	my $SAFETY = 0;
	17
	18	our @IGNORE =
	19	qw/Build Build.PL Changes MANIFEST META.yml Makefile.PL Makefile README
d99c8718	20	_build blib lib script t inc .*\.svn \.git _darcs \.bzr \.hg
d99c8718	21	debian build-stamp install-stamp configure-stamp/;
134481a2	22	our @CLASSES = ();
134481a2	23	our $ENGINE = 'CGI';
2f7a957f	24	our $SCRIPT = '';
2f7a957f	25	our $USAGE = '';
84a68fcf	26	our %PAROPTS = ();
134481a2	27
	28	=head1 NAME
	29
d99c8718	30	Module::Install::Catalyst - Module::Install extension for Catalyst
e7c01705	31
134481a2	32	=head1 SYNOPSIS
e7c01705	33
d99c8718	34	use inc::Module::Install;
e7c01705	35
d99c8718	36	name 'MyApp';
d99c8718	37	all_from 'lib/MyApp.pm';
e7c01705	38
d99c8718	39	requires 'Catalyst::Runtime' => '5.7014';
e7c01705	40
d99c8718	41	catalyst_ignore('.*temp');
	42	catalyst_ignore('.*tmp');
	43	catalyst;
	44	WriteAll;
134481a2	45
	46	=head1 DESCRIPTION
	47
	48	L<Module::Install> extension for Catalyst.
	49
	50	=head1 METHODS
	51
	52	=head2 catalyst
	53
d99c8718	54	Calls L<catalyst_files> and L<catalyst_par>. Should be the last catalyst*
	55	command called in C<Makefile.PL>.
	56
134481a2	57	=cut
	58
	59	sub catalyst {
	60	my $self = shift;
ead1c47c	61
ead1c47c	62	if($Module::Install::AUTHOR) {
e0fd6615	63	$self->include("File::Copy::Recursive");
ead1c47c	64	}
ead1c47c	65
134481a2	66	print <<EOF;
	67	*** Module::Install::Catalyst
	68	EOF
	69	$self->catalyst_files;
	70	$self->catalyst_par;
	71	print <<EOF;
	72	*** Module::Install::Catalyst finished.
	73	EOF
	74	}
	75
	76	=head2 catalyst_files
	77
e7c01705	78	Collect a list of all files a Catalyst application consists of and copy it
e7c01705	79	inside the blib/lib/ directory. Files and directories that match the modules
d99c8718	80	ignore list are excluded (see L<catalyst_ignore> and L<catalyst_ignore_all>).
d99c8718	81
134481a2	82	=cut
	83
	84	sub catalyst_files {
	85	my $self = shift;
	86
	87	chdir $FindBin::Bin;
	88
	89	my @files;
	90	opendir CATDIR, '.';
	91	CATFILES: for my $name ( readdir CATDIR ) {
	92	for my $ignore (@IGNORE) {
	93	next CATFILES if $name =~ /^$ignore$/;
	94	next CATFILES if $name !~ /\w/;
	95	}
	96	push @files, $name;
	97	}
	98	closedir CATDIR;
	99	my @path = split '-', $self->name;
	100	for my $orig (@files) {
	101	my $path = File::Spec->catdir( 'blib', 'lib', @path, $orig );
e8012329	102	File::Copy::Recursive::rcopy( $orig, $path );
134481a2	103	}
	104	}
	105
	106	=head2 catalyst_ignore_all(\@ignore)
	107
d99c8718	108	This function replaces the built-in default ignore list with the given list.
d99c8718	109
134481a2	110	=cut
	111
	112	sub catalyst_ignore_all {
	113	my ( $self, $ignore ) = @_;
	114	@IGNORE = @$ignore;
	115	}
	116
9d4259db	117	=head2 catalyst_ignore(@ignore)
134481a2	118
d99c8718	119	Add a regexp to the list of ignored patterns. Can be called multiple times.
d99c8718	120
134481a2	121	=cut
	122
	123	sub catalyst_ignore {
	124	my ( $self, @ignore ) = @_;
	125	push @IGNORE, @ignore;
	126	}
	127
	128	=head2 catalyst_par($name)
	129
	130	=cut
	131
	132	# Workaround for a namespace conflict
	133	sub catalyst_par {
	134	my ( $self, $par ) = @_;
2f7a957f	135	$par \|\|= '';
134481a2	136	return if $SAFETY;
	137	$SAFETY++;
	138	my $name = $self->name;
	139	my $usage = $USAGE;
	140	$usage =~ s/"/\\"/g;
	141	my $class_string = join "', '", @CLASSES;
	142	$class_string = "'$class_string'" if $class_string;
84a68fcf	143	local $Data::Dumper::Indent = 0;
	144	local $Data::Dumper::Terse = 1;
	145	local $Data::Dumper::Pad = ' ';
	146	my $paropts_string = Dumper(\%PAROPTS) \|\| "{ }";
134481a2	147	$self->postamble(<<EOF);
134481a2	148	catalyst_par :: all
84a68fcf	149	\t\$(NOECHO) \$(PERL) -Ilib -Minc::Module::Install -MModule::Install::Catalyst -e"Catalyst::Module::Install::_catalyst_par( '$par', '$name', { CLASSES => [$class_string], PAROPTS => $paropts_string, ENGINE => '$ENGINE', SCRIPT => '$SCRIPT', USAGE => q#$usage# } )"
134481a2	150	EOF
	151	print <<EOF;
	152	Please run "make catalyst_par" to create the PAR package!
	153	EOF
	154	}
	155
	156	=head2 catalyst_par_core($core)
	157
	158	=cut
	159
	160	sub catalyst_par_core {
	161	my ( $self, $core ) = @_;
84a68fcf	162	$core ? ( $PAROPTS{'B'} = $core ) : $PAROPTS{'B'}++;
134481a2	163	}
	164
	165	=head2 catalyst_par_classes(@clases)
	166
	167	=cut
	168
	169	sub catalyst_par_classes {
	170	my ( $self, @classes ) = @_;
	171	push @CLASSES, @classes;
	172	}
	173
	174	=head2 catalyst_par_engine($engine)
	175
	176	=cut
	177
	178	sub catalyst_par_engine {
	179	my ( $self, $engine ) = @_;
	180	$ENGINE = $engine;
	181	}
	182
	183	=head2 catalyst_par_multiarch($multiarch)
	184
	185	=cut
	186
	187	sub catalyst_par_multiarch {
	188	my ( $self, $multiarch ) = @_;
84a68fcf	189	$multiarch ? ( $PAROPTS{'m'} = $multiarch ) : $PAROPTS{'m'}++;
	190	}
	191
	192	=head2 catalyst_par_options($optstring)
	193
	194	This command can be used in Makefile.PL to customise the PAR creation process.
	195	The parameter "$optstring" contains a string with arguments in identical syntax
	196	as arguments of B<pp> command from L<PAR::Packer> package.
	197
	198	Example:
	199
	200	# part of your Makefile.PL
e7c01705	201
4578b8ae	202	catalyst_par_options("--verbose=2 -f Bleach -z 9");
84a68fcf	203	# verbose mode; use filter 'Bleach'; zip with compression level 9
	204	catalyst;
	205
	206	Note1: There is no reason to use catalyst_par_options() command multiple times
	207	as you can spacify in "$optstring" as many options as you want. Still, it
4578b8ae	208	is supported to call catalyst_par_options() more than once. In that case the
e7c01705	209	specified options are merged (collisions are handled on principle "later wins").
4578b8ae	210	BEWARE: you are discouraged from using parameters -a -A -X -f -F -I -l -M in
e7c01705	211	multiple catalyst_par_options() as they are not merged but replaced as you would
4578b8ae	212	expected.
84a68fcf	213
e7c01705	214	Note2: By default the options "-x -p -o=<appname>.par" are set and option "-n"
4578b8ae	215	is unset. This default always overrides whatever you specify by
4578b8ae	216	catalyst_par_options().
84a68fcf	217
	218	=cut
	219
	220	sub catalyst_par_options {
	221	my ( $self, $optstring ) = @_;
84a68fcf	222	eval "use PAR::Packer ()";
	223	if ($@) {
	224	warn "WARNING: catalyst_par_options ignored - you need PAR::Packer\n"
	225	}
	226	else {
09a0d496	227	my $p = Getopt::Long::Parser->new(config => ['no_ignore_case']);
09a0d496	228	my %o;
2120406d	229	require Text::ParseWords;
09a0d496	230	{
2120406d	231	local @ARGV = Text::ParseWords::shellwords($optstring);
09a0d496	232	$p->getoptions(\%o, PAR::Packer->options);
09a0d496	233	}
84a68fcf	234	%PAROPTS = ( %PAROPTS, %o);
7235d8b3	235	}
134481a2	236	}
	237
	238	=head2 catalyst_par_script($script)
	239
	240	=cut
	241
	242	sub catalyst_par_script {
	243	my ( $self, $script ) = @_;
	244	$SCRIPT = $script;
	245	}
	246
	247	=head2 catalyst_par_usage($usage)
	248
	249	=cut
	250
	251	sub catalyst_par_usage {
	252	my ( $self, $usage ) = @_;
	253	$USAGE = $usage;
	254	}
	255
	256	package Catalyst::Module::Install;
	257
	258	use strict;
	259	use FindBin;
	260	use File::Copy::Recursive 'rmove';
	261	use File::Spec ();
	262
	263	sub _catalyst_par {
	264	my ( $par, $class_name, $opts ) = @_;
	265
	266	my $ENGINE = $opts->{ENGINE};
	267	my $CLASSES = $opts->{CLASSES} \|\| [];
	268	my $USAGE = $opts->{USAGE};
	269	my $SCRIPT = $opts->{SCRIPT};
84a68fcf	270	my $PAROPTS = $opts->{PAROPTS};
134481a2	271
	272	my $name = $class_name;
	273	$name =~ s/::/_/g;
	274	$name = lc $name;
	275	$par \|\|= "$name.par";
	276	my $engine = $ENGINE \|\| 'CGI';
	277
	278	# Check for PAR
	279	eval "use PAR ()";
	280	die "Please install PAR\n" if $@;
	281	eval "use PAR::Packer ()";
	282	die "Please install PAR::Packer\n" if $@;
	283	eval "use App::Packer::PAR ()";
	284	die "Please install App::Packer::PAR\n" if $@;
	285	eval "use Module::ScanDeps ()";
	286	die "Please install Module::ScanDeps\n" if $@;
	287
	288	my $root = $FindBin::Bin;
	289	$class_name =~ s/-/::/g;
	290	my $path = File::Spec->catfile( 'blib', 'lib', split( '::', $class_name ) );
	291	$path .= '.pm';
	292	unless ( -f $path ) {
	293	print qq/Not writing PAR, "$path" doesn't exist\n/;
	294	return 0;
	295	}
	296	print qq/Writing PAR "$par"\n/;
	297	chdir File::Spec->catdir( $root, 'blib' );
	298
	299	my $par_pl = 'par.pl';
	300	unlink $par_pl;
	301
	302	my $version = $Catalyst::VERSION;
	303	my $class = $class_name;
	304
	305	my $classes = '';
	306	$classes .= " require $_;\n" for @$CLASSES;
	307
	308	unlink $par_pl;
	309
	310	my $usage = $USAGE \|\| <<"EOF";
	311	Usage:
	312	[parl] $name\[.par] [script] [arguments]
	313
	314	Examples:
	315	parl $name.par $name\_server.pl -r
	316	myapp $name\_cgi.pl
	317	EOF
	318
	319	my $script = $SCRIPT;
	320	my $tmp_file = IO::File->new("> $par_pl ");
	321	print $tmp_file <<"EOF";
	322	if ( \$ENV{PAR_PROGNAME} ) {
	323	my \$zip = \$PAR::LibCache{\$ENV{PAR_PROGNAME}}
	324	\|\| Archive::Zip->new(__FILE__);
	325	my \$script = '$script';
	326	\$ARGV[0] \|\|= \$script if \$script;
	327	if ( ( \@ARGV == 0 ) \|\| ( \$ARGV[0] eq '-h' ) \|\| ( \$ARGV[0] eq '-help' )) {
	328	my \@members = \$zip->membersMatching('.script/.\.pl');
	329	my \$list = " Available scripts:\\n";
	330	for my \$member ( \@members ) {
	331	my \$name = \$member->fileName;
	332	\$name =~ /(\\w+\\.pl)\$/;
	333	\$name = \$1;
	334	next if \$name =~ /^main\.pl\$/;
335	next if \$name =~ /^par\.pl\$/;
336	\$list .= " \$name\\n";
337	}
338	die <<"END";
339	$usage
340	\$list
341	END
342	}
343	my \$file = shift \@ARGV;
344	\$file =~ s/^.*[\\/\\\\]//;
345	\$file =~ s/\\.[^.]*\$//i;
346	my \$member = eval { \$zip->memberNamed("./script/\$file.pl") };
347	die qq/Can't open perl script "\$file"\n/ unless \$member;
348	PAR::_run_member( \$member, 1 );
349	}
350	else {
351	require lib;
352	import lib 'lib';
353	\$ENV{CATALYST_ENGINE} = '$engine';
354	require $class;
355	import $class;
356	require Catalyst::Helper;
357	require Catalyst::Test;
358	require Catalyst::Engine::HTTP;
359	require Catalyst::Engine::CGI;
360	require Catalyst::Controller;
361	require Catalyst::Model;
362	require Catalyst::View;
363	require Getopt::Long;
364	require Pod::Usage;
365	require Pod::Text;
366	$classes
367	}
368	EOF
369	$tmp_file->close;
370
371	# Create package
372	local $SIG{__WARN__} = sub { };
f42008bb	373
f42008bb	374	# STDERR used to be redirected to null, but this hid errors from PAR::Packer
134481a2	375	my %opt = (
4578b8ae	376	%{$PAROPTS},
4578b8ae	377	# take user defined options first and override them with harcoded defaults
134481a2	378	'x' => 1,
	379	'n' => 0,
	380	'o' => $par,
134481a2	381	'p' => 1,
134481a2	382	);
84a68fcf	383	# do not replace the whole $opt{'a'} array; just push required default value
e7c01705	384	push @{$opt{'a'}}, grep( !/par.pl/, glob '.' );
84a68fcf	385
134481a2	386	App::Packer::PAR->new(
	387	frontend => 'Module::ScanDeps',
	388	backend => 'PAR::Packer',
	389	frontopts => \%opt,
	390	backopts => \%opt,
	391	args => ['par.pl'],
	392	)->go;
	393
134481a2	394	unlink $par_pl;
	395	chdir $root;
	396	rmove( File::Spec->catfile( 'blib', $par ), $par );
	397	return 1;
	398	}
	399
cb536e7b	400	=head1 AUTHORS
134481a2	401
cb536e7b	402	Catalyst Contributors, see Catalyst.pm
134481a2	403
	404	=head1 LICENSE
	405
7cd3b67e	406	This library is free software. You can redistribute it and/or modify it under
134481a2	407	the same terms as Perl itself.
	408
	409	=cut
	410
	411	1;