[catagits/Catalyst-Devel.git] / lib / Catalyst / Helper.pm

package Catalyst::Helper;

use Moose;
use Config;
use File::Spec;
use File::Path;
use FindBin;
use IO::File;
use POSIX 'strftime';
use Template;
use Catalyst::Devel;
use Catalyst::Utils;
use Catalyst::Exception;
use Path::Class qw/dir file/;
use File::ShareDir qw/dist_dir/;
use MooseX::Types::Moose qw/Str Bool Int/;

with 'MooseX::Getopt';


my %cache;

=head1 NAME

Catalyst::Helper - Bootstrap a Catalyst application

=head1 SYNOPSIS

  catalyst.pl <myappname>

=cut


## this stays in Helper.pm #####################################################
sub get_sharedir_file {
    my ($self, @filename) = @_;
    my $dist_dir;
    if (-d dir("inc", ".author") { # Can't use sharedir if we're in a checkout
                            # this feels horrible, better ideas?
        $dist_dir = 'share';
    }
    else {
        $dist_dir = dist_dir('Catalyst-Devel');
    }
    my $file = file( $dist_dir, @filename);
    my $contents = $file->slurp;
    return $contents;
}

# Do not touch this method, *EVER*, it is needed for back compat.
sub get_file {
    my ( $self, $class, $file ) = @_;
    unless ( $cache{$class} ) {
        local $/;
        $cache{$class} = eval "package $class; <DATA>";
    }
    my $data = $cache{$class};
    Carp::confess("Could not get data from __DATA__ segment for $class")
        unless $data;
    my @files = split /^__(.+)__\r?\n/m, $data;
    shift @files;
    while (@files) {
        my ( $name, $content ) = splice @files, 0, 2;
        return $content if $name eq $file;
    }
    return 0;
}

################################################################################


sub mk_dir {
    my ( $self, $dir ) = @_;
    if ( -d $dir ) {
        print qq/ exists "$dir"\n/;
        return 0;
    }
    if ( mkpath [$dir] ) {
        print qq/created "$dir"\n/;
        return 1;
    }

    Catalyst::Exception->throw( message => qq/Couldn't create "$dir", "$!"/ );
}

sub mk_file {
    my ( $self, $file, $content ) = @_;
    if ( -e $file && -s _ ) {
        print qq/ exists "$file"\n/;
        return 0
          unless ( $self->{'.newfiles'}
            || $self->{scripts}
            || $self->{makefile} );
        if ( $self->{'.newfiles'} ) {
            if ( my $f = IO::File->new("< $file") ) {
                my $oldcontent = join( '', (<$f>) );
                return 0 if $content eq $oldcontent;
            }
            $file .= '.new';
        }
    }
    if ( my $f = IO::File->new("> $file") ) {
        binmode $f;
        print $f $content;
        print qq/created "$file"\n/;
        return 1;
    }

    Catalyst::Exception->throw( message => qq/Couldn't create "$file", "$!"/ );
}

sub next_test {
    my ( $self, $tname ) = @_;
    if ($tname) { $tname = "$tname.t" }
    else {
        my $name   = $self->{name};
        my $prefix = $name;
        $prefix =~ s/::/-/g;
        $prefix         = $prefix;
        $tname          = $prefix . '.t';
        $self->{prefix} = $prefix;
        $prefix         = lc $prefix;
        $prefix =~ s/-/\//g;
        $self->{uri} = "/$prefix";
    }
    my $dir  = $self->{test_dir};
    my $type = lc $self->{type};
    $self->mk_dir($dir);
    return File::Spec->catfile( $dir, "$type\_$tname" );
}

# Do not touch this method, *EVER*, it is needed for back compat. ##############
## addendum: we had to split this method so we could have backwards
## compatability.  otherwise, we'd have no way to pass stuff from __DATA__ 
sub render_file {
    my ( $self, $file, $path, $vars ) = @_;
    my $template = $self->get_file( ( caller(0) )[0], $file );
    $self->render_file_contents($template, $path, $vars);
}
################################################################################

sub render_sharedir_file {
    my ( $self, $file, $path, $vars ) = @_;
    my $template = $self->get_sharedir_file( $file );
    $self->render_file_contents($template, $path, $vars);
}

sub render_file_contents {
    my ( $self, $template, $path, $vars ) = @_;
    $vars ||= {};
    my $t = Template->new;
    return 0 unless $template;
    my $output;
    $t->process( \$template, { %{$self}, %$vars }, \$output )
      || Catalyst::Exception->throw(
        message => qq/Couldn't process "$template", / . $t->error() );
    $self->mk_file( $path, $output );
}

# DIE DIE DIE
sub _mk_information {
    my $self = shift;
    print qq/Change to application directory and Run "perl Makefile.PL" to make sure your install is complete\n/;
}

sub _mk_dirs {
    my $self = shift;
    $self->mk_dir( $self->{dir} );
    $self->mk_dir( $self->{script} );
    $self->{lib} = File::Spec->catdir( $self->{dir}, 'lib' );
    $self->mk_dir( $self->{lib} );
    $self->{root} = File::Spec->catdir( $self->{dir}, 'root' );
    $self->mk_dir( $self->{root} );
    $self->{static} = File::Spec->catdir( $self->{root}, 'static' );
    $self->mk_dir( $self->{static} );
    $self->{images} = File::Spec->catdir( $self->{static}, 'images' );
    $self->mk_dir( $self->{images} );
    $self->{t} = File::Spec->catdir( $self->{dir}, 't' );
    $self->mk_dir( $self->{t} );

    $self->{class} = File::Spec->catdir( split( /\:\:/, $self->{name} ) );
    $self->{mod} = File::Spec->catdir( $self->{lib}, $self->{class} );
    $self->mk_dir( $self->{mod} );

    if ( $self->{short} ) {
        $self->{m} = File::Spec->catdir( $self->{mod}, 'M' );
        $self->mk_dir( $self->{m} );
        $self->{v} = File::Spec->catdir( $self->{mod}, 'V' );
        $self->mk_dir( $self->{v} );
        $self->{c} = File::Spec->catdir( $self->{mod}, 'C' );
        $self->mk_dir( $self->{c} );
    }
    else {
        $self->{m} = File::Spec->catdir( $self->{mod}, 'Model' );
        $self->mk_dir( $self->{m} );
        $self->{v} = File::Spec->catdir( $self->{mod}, 'View' );
        $self->mk_dir( $self->{v} );
        $self->{c} = File::Spec->catdir( $self->{mod}, 'Controller' );
        $self->mk_dir( $self->{c} );
    }
    my $name = $self->{name};
    $self->{rootname} =
      $self->{short} ? "$name\::C::Root" : "$name\::Controller::Root";
    $self->{base} = File::Spec->rel2abs( $self->{dir} );
}

# DIE DIE DIE
sub _mk_appclass {
    my $self = shift;
    my $mod  = $self->{mod};
    $self->render_sharedir_file( File::Spec->catfile('lib', 'MyApp.pm.tt'), "$mod.pm" );
}

# DIE DIE DIE
sub _mk_rootclass {
    my $self = shift;
    $self->render_sharedir_file( File::Spec->catfile('lib', 'MyApp', 'Controller', 'Root.pm.tt'),
        File::Spec->catfile( $self->{c}, "Root.pm" ) );
}

# DIE DIE DIE
sub _mk_makefile {
    my $self = shift;
    $self->{path} = File::Spec->catfile( 'lib', split( '::', $self->{name} ) );
    $self->{path} .= '.pm';
    my $dir = $self->{dir};
    $self->render_sharedir_file( 'Makefile.PL.tt', "$dir\/Makefile.PL" );

    if ( $self->{makefile} ) {

        # deprecate the old Build.PL file when regenerating Makefile.PL
        $self->_deprecate_file(
            File::Spec->catdir( $self->{dir}, 'Build.PL' ) );
    }
}

# DIE DIE DIE
sub _mk_config {
    my $self      = shift;
    my $dir       = $self->{dir};
    my $appprefix = $self->{appprefix};
    $self->render_sharedir_file( 'myapp.conf.tt',
        File::Spec->catfile( $dir, "$appprefix.conf" ) );
}

# DIE DIE DIE
sub _mk_readme {
    my $self = shift;
    my $dir  = $self->{dir};
    $self->render_sharedir_file( 'README.tt', "$dir\/README" );
}

# DIE DIE DIE
sub _mk_changes {
    my $self = shift;
    my $dir  = $self->{dir};
    my $time = strftime('%Y-%m-%d %H:%M:%S', localtime time);
    $self->render_sharedir_file( 'Changes.tt', "$dir\/Changes", { time => $time } );
}

sub _mk_apptest {
    my $self = shift;
    my $t    = $self->{t};
    $self->render_sharedir_file( File::Spec->catfile('t', '01app.t.tt'),         "$t\/01app.t" );
    $self->render_sharedir_file( File::Spec->catfile('t', '02pod.t.tt'),         "$t\/02pod.t" );
    $self->render_sharedir_file( File::Spec->catfile('t', '03podcoverage.t.tt'), "$t\/03podcoverage.t" );
}

sub _mk_cgi {
    my $self      = shift;
    my $script    = $self->{script};
    my $appprefix = $self->{appprefix};
    $self->render_sharedir_file( File::Spec->catfile('script', 'myapp_cgi.pl.tt'), "$script\/$appprefix\_cgi.pl" );
    chmod 0700, "$script/$appprefix\_cgi.pl";
}

sub _mk_fastcgi {
    my $self      = shift;
    my $script    = $self->{script};
    my $appprefix = $self->{appprefix};
    $self->render_sharedir_file( File::Spec->catfile('script', 'myapp_fastcgi.pl.tt'), "$script\/$appprefix\_fastcgi.pl" );
    chmod 0700, "$script/$appprefix\_fastcgi.pl";
}

sub _mk_server {
    my $self      = shift;
    my $script    = $self->{script};
    my $appprefix = $self->{appprefix};
    $self->render_sharedir_file( File::Spec->catfile('script', 'myapp_server.pl.tt'), "$script\/$appprefix\_server.pl" );
    chmod 0700, "$script/$appprefix\_server.pl";
}

sub _mk_test {
    my $self      = shift;
    my $script    = $self->{script};
    my $appprefix = $self->{appprefix};
    $self->render_sharedir_file( File::Spec->catfile('script', 'myapp_test.pl.tt'), "$script/$appprefix\_test.pl" );
    chmod 0700, "$script/$appprefix\_test.pl";
}

sub _mk_create {
    my $self      = shift;
    my $script    = $self->{script};
    my $appprefix = $self->{appprefix};
    $self->render_sharedir_file( File::Spec->catfile('script', 'myapp_create.pl.tt'), "$script\/$appprefix\_create.pl" );
    chmod 0700, "$script/$appprefix\_create.pl";
}

# DIE DIE DIE
sub _mk_compclass {
    my $self = shift;
    my $file = $self->{file};
    return $self->render_sharedir_file( 'myapp_compclass.pl.tt', "$file" );
}

# DIE DIE DIE
sub _mk_comptest {
    my $self = shift;
    my $test = $self->{test};
    $self->render_sharedir_file( 'comptest.tt', "$test" );  ## wtf do i rename this to?
}

sub _mk_images {
    my $self   = shift;
    my $images = $self->{images};
    my @images =
      qw/catalyst_logo btn_120x50_built btn_120x50_built_shadow
      btn_120x50_powered btn_120x50_powered_shadow btn_88x31_built
      btn_88x31_built_shadow btn_88x31_powered btn_88x31_powered_shadow/;
    for my $name (@images) {
        my $image = $self->get_sharedir_file("root", "static", "images", "$name.png.bin");
        $self->mk_file( File::Spec->catfile( $images, "$name.png" ), $image );
    }
}

# DIE DIE DIE
sub _mk_favicon {
    my $self    = shift;
    my $root    = $self->{root};
    my $favicon = $self->get_sharedir_file( 'root', 'favicon.ico.bin' );
    my $dest = File::Spec->catfile( $root, "favicon.ico" );
    $self->mk_file( $dest, $favicon );

}

sub _deprecate_file {
    my ( $self, $file ) = @_;
    if ( -e $file ) {
        my $oldcontent;
        if ( my $f = IO::File->new("< $file") ) {
            $oldcontent = join( '', (<$f>) );
        }
        my $newfile = $file . '.deprecated';
        if ( my $f = IO::File->new("> $newfile") ) {
            binmode $f;
            print $f $oldcontent;
            print qq/created "$newfile"\n/;
            unlink $file;
            print qq/removed "$file"\n/;
            return 1;
        }
        Catalyst::Exception->throw(
            message => qq/Couldn't create "$file", "$!"/ );
    }
}

=head1 DESCRIPTION

This module is used by B<catalyst.pl> to create a set of scripts for a
new catalyst application. The scripts each contain documentation and
will output help on how to use them if called incorrectly or in some
cases, with no arguments.

It also provides some useful methods for a Helper module to call when
creating a component. See L</METHODS>.

=head1 SCRIPTS

=head2 _create.pl

Used to create new components for a catalyst application at the
development stage.

=head2 _server.pl

The catalyst test server, starts an HTTPD which outputs debugging to
the terminal.

=head2 _test.pl

A script for running tests from the command-line.

=head2 _cgi.pl

Run your application as a CGI.

=head2 _fastcgi.pl

Run the application as a fastcgi app. Either by hand, or call this
from FastCgiServer in your http server config.

=head1 HELPERS

The L</_create.pl> script creates application components using Helper
modules. The Catalyst team provides a good number of Helper modules
for you to use. You can also add your own.

Helpers are classes that provide two methods.

    * mk_compclass - creates the Component class
    * mk_comptest  - creates the Component test

So when you call C<scripts/myapp_create.pl view MyView TT>, create
will try to execute Catalyst::Helper::View::TT->mk_compclass and
Catalyst::Helper::View::TT->mk_comptest.

See L<Catalyst::Helper::View::TT> and
L<Catalyst::Helper::Model::DBIC::Schema> for examples.

All helper classes should be under one of the following namespaces.

    Catalyst::Helper::Model::
    Catalyst::Helper::View::
    Catalyst::Helper::Controller::

=head2 COMMON HELPERS

=over

=item *

L<Catalyst::Helper::Model::DBIC::Schema> - DBIx::Class models

=item *

L<Catalyst::Helper::View::TT> - Template Toolkit view

=item *

L<Catalyst::Helper::Model::LDAP>

=item *

L<Catalyst::Helper::Model::Adaptor> - wrap any class into a Catalyst model

=back

=head3 NOTE

The helpers will read author name from /etc/passwd by default. + To override, please export the AUTHOR variable.

=head1 METHODS

=head2 mk_compclass

This method in your Helper module is called with C<$helper>
which is a L<Catalyst::Helper> object, and whichever other arguments
the user added to the command-line. You can use the $helper to call methods
described below.

If the Helper module does not contain a C<mk_compclass> method, it
will fall back to calling L</render_file>, with an argument of
C<compclass>.

=head2 mk_comptest

This method in your Helper module is called with C<$helper>
which is a L<Catalyst::Helper> object, and whichever other arguments
the user added to the command-line. You can use the $helper to call methods
described below.

If the Helper module does not contain a C<mk_compclass> method, it
will fall back to calling L</render_file>, with an argument of
C<comptest>.

=head2 mk_stuff

This method is called if the user does not supply any of the usual
component types C<view>, C<controller>, C<model>. It is passed the
C<$helper> object (an instance of L<Catalyst::Helper>), and any other
arguments the user typed.

There is no fallback for this method.

=head1 INTERNAL METHODS

These are the methods that the Helper classes can call on the
<$helper> object passed to them.

=head2 render_file ($file, $path, $vars)

Render and create a file from a template in DATA using Template
Toolkit. $file is the relevent chunk of the __DATA__ section, $path is
the path to the file and $vars is the hashref as expected by
L<Template Toolkit|Template>.

=head2 get_file ($class, $file)

Fetch file contents from the DATA section. This is used internally by
L</render_file>.  $class is the name of the class to get the DATA
section from.  __PACKAGE__ or ( caller(0) )[0] might be sensible
values for this.

=head2 mk_app

Create the main application skeleton. This is called by L<catalyst.pl>.

=head2 mk_component ($app)

This method is called by L<create.pl> to make new components
for your application.

=head3 mk_dir ($path)

Surprisingly, this function makes a directory.

=head2 mk_file ($file, $content)

Writes content to a file. Called by L</render_file>.

=head2 next_test ($test_name)

Calculates the name of the next numbered test file and returns it.
Don't give the number or the .t suffix for the test name.

=head2 Dir

Alias for L<Path::Class::Dir>

=cut

=head2 get_sharedir_file

Method for getting a file out of share/

=cut

=head2 render_file_contents

Process a L<Template::Toolkit> template.

=cut

=head2 render_sharedir_file

Render a template/image file from our share directory

=cut


=head1 NOTE

The helpers will read author name from /etc/passwd by default.
To override, please export the AUTHOR variable.

=head1 SEE ALSO

L<Catalyst::Manual>, L<Catalyst::Test>, L<Catalyst::Request>,
L<Catalyst::Response>, L<Catalyst>

=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.

=begin pod_to_ignore

=cut

1;
Commit	Line	Data
68ccb5e5	1	package Catalyst::Helper;
68ccb5e5	2
143cd997	3	use Moose;
68ccb5e5	4	use Config;
	5	use File::Spec;
	6	use File::Path;
68ccb5e5	7	use FindBin;
2415f774	8	use IO::File;
2415f774	9	use POSIX 'strftime';
68ccb5e5	10	use Template;
9ffb6b83	11	use Catalyst::Devel;
68ccb5e5	12	use Catalyst::Utils;
68ccb5e5	13	use Catalyst::Exception;
afd739f1	14	use Path::Class qw/dir file/;
afd739f1	15	use File::ShareDir qw/dist_dir/;
143cd997	16	use MooseX::Types::Moose qw/Str Bool Int/;
	17
	18	with 'MooseX::Getopt';
239b5fc0	19
68ccb5e5	20
	21	my %cache;
	22
	23	=head1 NAME
	24
	25	Catalyst::Helper - Bootstrap a Catalyst application
	26
	27	=head1 SYNOPSIS
	28
fab70e0a	29	catalyst.pl <myappname>
68ccb5e5	30
	31	=cut
	32
faae88e5	33
143cd997	34	## this stays in Helper.pm #####################################################
afd739f1	35	sub get_sharedir_file {
afd739f1	36	my ($self, @filename) = @_;
76b106bc	37	my $dist_dir;
143cd997	38	if (-d dir("inc", ".author") { # Can't use sharedir if we're in a checkout
76b106bc	39	# this feels horrible, better ideas?
	40	$dist_dir = 'share';
	41	}
	42	else {
	43	$dist_dir = dist_dir('Catalyst-Devel');
	44	}
	45	my $file = file( $dist_dir, @filename);
afd739f1	46	my $contents = $file->slurp;
	47	return $contents;
	48	}
	49
faae88e5	50	# Do not touch this method, EVER, it is needed for back compat.
68ccb5e5	51	sub get_file {
03082a71	52	my ( $self, $class, $file ) = @_;
	53	unless ( $cache{$class} ) {
	54	local $/;
	55	$cache{$class} = eval "package $class; <DATA>";
	56	}
	57	my $data = $cache{$class};
0acedf59	58	Carp::confess("Could not get data from __DATA__ segment for $class")
0acedf59	59	unless $data;
03082a71	60	my @files = split /^__(.+)__\r?\n/m, $data;
	61	shift @files;
	62	while (@files) {
	63	my ( $name, $content ) = splice @files, 0, 2;
	64	return $content if $name eq $file;
	65	}
	66	return 0;
68ccb5e5	67	}
68ccb5e5	68
143cd997	69	################################################################################
03082a71	70
68ccb5e5	71
68ccb5e5	72	sub mk_dir {
	73	my ( $self, $dir ) = @_;
	74	if ( -d $dir ) {
	75	print qq/ exists "$dir"\n/;
	76	return 0;
	77	}
	78	if ( mkpath [$dir] ) {
	79	print qq/created "$dir"\n/;
	80	return 1;
	81	}
	82
	83	Catalyst::Exception->throw( message => qq/Couldn't create "$dir", "$!"/ );
	84	}
	85
68ccb5e5	86	sub mk_file {
68ccb5e5	87	my ( $self, $file, $content ) = @_;
06f62452	88	if ( -e $file && -s _ ) {
68ccb5e5	89	print qq/ exists "$file"\n/;
	90	return 0
	91	unless ( $self->{'.newfiles'}
	92	\|\| $self->{scripts}
	93	\|\| $self->{makefile} );
	94	if ( $self->{'.newfiles'} ) {
	95	if ( my $f = IO::File->new("< $file") ) {
	96	my $oldcontent = join( '', (<$f>) );
	97	return 0 if $content eq $oldcontent;
	98	}
	99	$file .= '.new';
	100	}
	101	}
	102	if ( my $f = IO::File->new("> $file") ) {
	103	binmode $f;
	104	print $f $content;
	105	print qq/created "$file"\n/;
	106	return 1;
	107	}
	108
	109	Catalyst::Exception->throw( message => qq/Couldn't create "$file", "$!"/ );
	110	}
	111
68ccb5e5	112	sub next_test {
	113	my ( $self, $tname ) = @_;
	114	if ($tname) { $tname = "$tname.t" }
	115	else {
	116	my $name = $self->{name};
	117	my $prefix = $name;
	118	$prefix =~ s/::/-/g;
	119	$prefix = $prefix;
	120	$tname = $prefix . '.t';
	121	$self->{prefix} = $prefix;
	122	$prefix = lc $prefix;
	123	$prefix =~ s/-/\//g;
	124	$self->{uri} = "/$prefix";
	125	}
	126	my $dir = $self->{test_dir};
	127	my $type = lc $self->{type};
	128	$self->mk_dir($dir);
	129	return File::Spec->catfile( $dir, "$type\_$tname" );
	130	}
	131
b78e897c	132	# Do not touch this method, EVER, it is needed for back compat. ##############
7025ed89	133	## addendum: we had to split this method so we could have backwards
7025ed89	134	## compatability. otherwise, we'd have no way to pass stuff from __DATA__
68ccb5e5	135	sub render_file {
68ccb5e5	136	my ( $self, $file, $path, $vars ) = @_;
7025ed89	137	my $template = $self->get_file( ( caller(0) )[0], $file );
06f62452	138	$self->render_file_contents($template, $path, $vars);
7025ed89	139	}
b78e897c	140	################################################################################
7025ed89	141
	142	sub render_sharedir_file {
	143	my ( $self, $file, $path, $vars ) = @_;
	144	my $template = $self->get_sharedir_file( $file );
e97273a4	145	$self->render_file_contents($template, $path, $vars);
7025ed89	146	}
	147
	148	sub render_file_contents {
	149	my ( $self, $template, $path, $vars ) = @_;
68ccb5e5	150	$vars \|\|= {};
68ccb5e5	151	my $t = Template->new;
68ccb5e5	152	return 0 unless $template;
	153	my $output;
	154	$t->process( \$template, { %{$self}, %$vars }, \$output )
	155	\|\| Catalyst::Exception->throw(
7025ed89	156	message => qq/Couldn't process "$template", / . $t->error() );
68ccb5e5	157	$self->mk_file( $path, $output );
	158	}
	159
b78e897c	160	# DIE DIE DIE
45d74601	161	sub _mk_information {
	162	my $self = shift;
	163	print qq/Change to application directory and Run "perl Makefile.PL" to make sure your install is complete\n/;
	164	}
	165
68ccb5e5	166	sub _mk_dirs {
	167	my $self = shift;
	168	$self->mk_dir( $self->{dir} );
	169	$self->mk_dir( $self->{script} );
	170	$self->{lib} = File::Spec->catdir( $self->{dir}, 'lib' );
	171	$self->mk_dir( $self->{lib} );
	172	$self->{root} = File::Spec->catdir( $self->{dir}, 'root' );
	173	$self->mk_dir( $self->{root} );
	174	$self->{static} = File::Spec->catdir( $self->{root}, 'static' );
	175	$self->mk_dir( $self->{static} );
	176	$self->{images} = File::Spec->catdir( $self->{static}, 'images' );
	177	$self->mk_dir( $self->{images} );
	178	$self->{t} = File::Spec->catdir( $self->{dir}, 't' );
	179	$self->mk_dir( $self->{t} );
	180
	181	$self->{class} = File::Spec->catdir( split( /\:\:/, $self->{name} ) );
	182	$self->{mod} = File::Spec->catdir( $self->{lib}, $self->{class} );
	183	$self->mk_dir( $self->{mod} );
	184
	185	if ( $self->{short} ) {
	186	$self->{m} = File::Spec->catdir( $self->{mod}, 'M' );
	187	$self->mk_dir( $self->{m} );
	188	$self->{v} = File::Spec->catdir( $self->{mod}, 'V' );
	189	$self->mk_dir( $self->{v} );
	190	$self->{c} = File::Spec->catdir( $self->{mod}, 'C' );
	191	$self->mk_dir( $self->{c} );
	192	}
	193	else {
	194	$self->{m} = File::Spec->catdir( $self->{mod}, 'Model' );
	195	$self->mk_dir( $self->{m} );
	196	$self->{v} = File::Spec->catdir( $self->{mod}, 'View' );
	197	$self->mk_dir( $self->{v} );
	198	$self->{c} = File::Spec->catdir( $self->{mod}, 'Controller' );
	199	$self->mk_dir( $self->{c} );
	200	}
	201	my $name = $self->{name};
	202	$self->{rootname} =
	203	$self->{short} ? "$name\::C::Root" : "$name\::Controller::Root";
	204	$self->{base} = File::Spec->rel2abs( $self->{dir} );
	205	}
	206
b78e897c	207	# DIE DIE DIE
68ccb5e5	208	sub _mk_appclass {
	209	my $self = shift;
	210	my $mod = $self->{mod};
c485fb09	211	$self->render_sharedir_file( File::Spec->catfile('lib', 'MyApp.pm.tt'), "$mod.pm" );
68ccb5e5	212	}
68ccb5e5	213
b78e897c	214	# DIE DIE DIE
68ccb5e5	215	sub _mk_rootclass {
68ccb5e5	216	my $self = shift;
c485fb09	217	$self->render_sharedir_file( File::Spec->catfile('lib', 'MyApp', 'Controller', 'Root.pm.tt'),
68ccb5e5	218	File::Spec->catfile( $self->{c}, "Root.pm" ) );
	219	}
	220
b78e897c	221	# DIE DIE DIE
68ccb5e5	222	sub _mk_makefile {
	223	my $self = shift;
	224	$self->{path} = File::Spec->catfile( 'lib', split( '::', $self->{name} ) );
	225	$self->{path} .= '.pm';
	226	my $dir = $self->{dir};
d5ff5c0f	227	$self->render_sharedir_file( 'Makefile.PL.tt', "$dir\/Makefile.PL" );
68ccb5e5	228
	229	if ( $self->{makefile} ) {
	230
	231	# deprecate the old Build.PL file when regenerating Makefile.PL
	232	$self->_deprecate_file(
	233	File::Spec->catdir( $self->{dir}, 'Build.PL' ) );
	234	}
	235	}
	236
b78e897c	237	# DIE DIE DIE
68ccb5e5	238	sub _mk_config {
	239	my $self = shift;
	240	my $dir = $self->{dir};
	241	my $appprefix = $self->{appprefix};
d5ff5c0f	242	$self->render_sharedir_file( 'myapp.conf.tt',
a4e6d745	243	File::Spec->catfile( $dir, "$appprefix.conf" ) );
68ccb5e5	244	}
68ccb5e5	245
b78e897c	246	# DIE DIE DIE
68ccb5e5	247	sub _mk_readme {
	248	my $self = shift;
	249	my $dir = $self->{dir};
d5ff5c0f	250	$self->render_sharedir_file( 'README.tt', "$dir\/README" );
68ccb5e5	251	}
68ccb5e5	252
b78e897c	253	# DIE DIE DIE
68ccb5e5	254	sub _mk_changes {
	255	my $self = shift;
	256	my $dir = $self->{dir};
5b1ec88b	257	my $time = strftime('%Y-%m-%d %H:%M:%S', localtime time);
d5ff5c0f	258	$self->render_sharedir_file( 'Changes.tt', "$dir\/Changes", { time => $time } );
68ccb5e5	259	}
	260
	261	sub _mk_apptest {
	262	my $self = shift;
	263	my $t = $self->{t};
c485fb09	264	$self->render_sharedir_file( File::Spec->catfile('t', '01app.t.tt'), "$t\/01app.t" );
	265	$self->render_sharedir_file( File::Spec->catfile('t', '02pod.t.tt'), "$t\/02pod.t" );
	266	$self->render_sharedir_file( File::Spec->catfile('t', '03podcoverage.t.tt'), "$t\/03podcoverage.t" );
68ccb5e5	267	}
	268
	269	sub _mk_cgi {
	270	my $self = shift;
	271	my $script = $self->{script};
	272	my $appprefix = $self->{appprefix};
c485fb09	273	$self->render_sharedir_file( File::Spec->catfile('script', 'myapp_cgi.pl.tt'), "$script\/$appprefix\_cgi.pl" );
68ccb5e5	274	chmod 0700, "$script/$appprefix\_cgi.pl";
	275	}
	276
	277	sub _mk_fastcgi {
	278	my $self = shift;
	279	my $script = $self->{script};
	280	my $appprefix = $self->{appprefix};
c485fb09	281	$self->render_sharedir_file( File::Spec->catfile('script', 'myapp_fastcgi.pl.tt'), "$script\/$appprefix\_fastcgi.pl" );
68ccb5e5	282	chmod 0700, "$script/$appprefix\_fastcgi.pl";
	283	}
	284
	285	sub _mk_server {
	286	my $self = shift;
	287	my $script = $self->{script};
	288	my $appprefix = $self->{appprefix};
c485fb09	289	$self->render_sharedir_file( File::Spec->catfile('script', 'myapp_server.pl.tt'), "$script\/$appprefix\_server.pl" );
68ccb5e5	290	chmod 0700, "$script/$appprefix\_server.pl";
	291	}
	292
	293	sub _mk_test {
	294	my $self = shift;
	295	my $script = $self->{script};
	296	my $appprefix = $self->{appprefix};
c485fb09	297	$self->render_sharedir_file( File::Spec->catfile('script', 'myapp_test.pl.tt'), "$script/$appprefix\_test.pl" );
68ccb5e5	298	chmod 0700, "$script/$appprefix\_test.pl";
	299	}
	300
	301	sub _mk_create {
	302	my $self = shift;
	303	my $script = $self->{script};
	304	my $appprefix = $self->{appprefix};
c485fb09	305	$self->render_sharedir_file( File::Spec->catfile('script', 'myapp_create.pl.tt'), "$script\/$appprefix\_create.pl" );
68ccb5e5	306	chmod 0700, "$script/$appprefix\_create.pl";
	307	}
	308
b78e897c	309	# DIE DIE DIE
68ccb5e5	310	sub _mk_compclass {
	311	my $self = shift;
	312	my $file = $self->{file};
5517035e	313	return $self->render_sharedir_file( 'myapp_compclass.pl.tt', "$file" );
68ccb5e5	314	}
68ccb5e5	315
b78e897c	316	# DIE DIE DIE
68ccb5e5	317	sub _mk_comptest {
	318	my $self = shift;
	319	my $test = $self->{test};
5517035e	320	$self->render_sharedir_file( 'comptest.tt', "$test" ); ## wtf do i rename this to?
68ccb5e5	321	}
	322
	323	sub _mk_images {
	324	my $self = shift;
	325	my $images = $self->{images};
	326	my @images =
	327	qw/catalyst_logo btn_120x50_built btn_120x50_built_shadow
	328	btn_120x50_powered btn_120x50_powered_shadow btn_88x31_built
	329	btn_88x31_built_shadow btn_88x31_powered btn_88x31_powered_shadow/;
	330	for my $name (@images) {
3f2f19ec	331	my $image = $self->get_sharedir_file("root", "static", "images", "$name.png.bin");
68ccb5e5	332	$self->mk_file( File::Spec->catfile( $images, "$name.png" ), $image );
	333	}
	334	}
	335
b78e897c	336	# DIE DIE DIE
68ccb5e5	337	sub _mk_favicon {
	338	my $self = shift;
	339	my $root = $self->{root};
f023d4a1	340	my $favicon = $self->get_sharedir_file( 'root', 'favicon.ico.bin' );
afd739f1	341	my $dest = File::Spec->catfile( $root, "favicon.ico" );
afd739f1	342	$self->mk_file( $dest, $favicon );
68ccb5e5	343
	344	}
	345
	346	sub _deprecate_file {
	347	my ( $self, $file ) = @_;
	348	if ( -e $file ) {
	349	my $oldcontent;
	350	if ( my $f = IO::File->new("< $file") ) {
	351	$oldcontent = join( '', (<$f>) );
	352	}
	353	my $newfile = $file . '.deprecated';
	354	if ( my $f = IO::File->new("> $newfile") ) {
	355	binmode $f;
	356	print $f $oldcontent;
	357	print qq/created "$newfile"\n/;
	358	unlink $file;
	359	print qq/removed "$file"\n/;
	360	return 1;
	361	}
	362	Catalyst::Exception->throw(
	363	message => qq/Couldn't create "$file", "$!"/ );
	364	}
	365	}
	366
fab70e0a	367	=head1 DESCRIPTION
	368
	369	This module is used by B<catalyst.pl> to create a set of scripts for a
	370	new catalyst application. The scripts each contain documentation and
	371	will output help on how to use them if called incorrectly or in some
	372	cases, with no arguments.
	373
	374	It also provides some useful methods for a Helper module to call when
	375	creating a component. See L</METHODS>.
	376
	377	=head1 SCRIPTS
	378
	379	=head2 _create.pl
	380
	381	Used to create new components for a catalyst application at the
	382	development stage.
	383
	384	=head2 _server.pl
	385
	386	The catalyst test server, starts an HTTPD which outputs debugging to
	387	the terminal.
	388
	389	=head2 _test.pl
	390
	391	A script for running tests from the command-line.
	392
	393	=head2 _cgi.pl
	394
	395	Run your application as a CGI.
	396
	397	=head2 _fastcgi.pl
	398
	399	Run the application as a fastcgi app. Either by hand, or call this
	400	from FastCgiServer in your http server config.
	401
68ccb5e5	402	=head1 HELPERS
68ccb5e5	403
fab70e0a	404	The L</_create.pl> script creates application components using Helper
	405	modules. The Catalyst team provides a good number of Helper modules
	406	for you to use. You can also add your own.
	407
68ccb5e5	408	Helpers are classes that provide two methods.
	409
	410	* mk_compclass - creates the Component class
	411	* mk_comptest - creates the Component test
	412
fab70e0a	413	So when you call C<scripts/myapp_create.pl view MyView TT>, create
fab70e0a	414	will try to execute Catalyst::Helper::View::TT->mk_compclass and
68ccb5e5	415	Catalyst::Helper::View::TT->mk_comptest.
68ccb5e5	416
c4c50c2d	417	See L<Catalyst::Helper::View::TT> and
c4c50c2d	418	L<Catalyst::Helper::Model::DBIC::Schema> for examples.
68ccb5e5	419
	420	All helper classes should be under one of the following namespaces.
	421
	422	Catalyst::Helper::Model::
	423	Catalyst::Helper::View::
	424	Catalyst::Helper::Controller::
	425
675fef06	426	=head2 COMMON HELPERS
bc8d7994	427
	428	=over
	429
	430	=item *
	431
	432	L<Catalyst::Helper::Model::DBIC::Schema> - DBIx::Class models
	433
	434	=item *
	435
	436	L<Catalyst::Helper::View::TT> - Template Toolkit view
	437
	438	=item *
	439
	440	L<Catalyst::Helper::Model::LDAP>
	441
	442	=item *
	443
	444	L<Catalyst::Helper::Model::Adaptor> - wrap any class into a Catalyst model
	445
	446	=back
	447
	448	=head3 NOTE
	449
675fef06	450	The helpers will read author name from /etc/passwd by default. + To override, please export the AUTHOR variable.
bc8d7994	451
	452	=head1 METHODS
	453
fab70e0a	454	=head2 mk_compclass
	455
	456	This method in your Helper module is called with C<$helper>
	457	which is a L<Catalyst::Helper> object, and whichever other arguments
	458	the user added to the command-line. You can use the $helper to call methods
	459	described below.
	460
	461	If the Helper module does not contain a C<mk_compclass> method, it
	462	will fall back to calling L</render_file>, with an argument of
	463	C<compclass>.
	464
	465	=head2 mk_comptest
	466
	467	This method in your Helper module is called with C<$helper>
	468	which is a L<Catalyst::Helper> object, and whichever other arguments
	469	the user added to the command-line. You can use the $helper to call methods
	470	described below.
	471
	472	If the Helper module does not contain a C<mk_compclass> method, it
	473	will fall back to calling L</render_file>, with an argument of
	474	C<comptest>.
	475
	476	=head2 mk_stuff
	477
	478	This method is called if the user does not supply any of the usual
	479	component types C<view>, C<controller>, C<model>. It is passed the
	480	C<$helper> object (an instance of L<Catalyst::Helper>), and any other
	481	arguments the user typed.
	482
	483	There is no fallback for this method.
	484
bc8d7994	485	=head1 INTERNAL METHODS
fab70e0a	486
	487	These are the methods that the Helper classes can call on the
	488	<$helper> object passed to them.
	489
28eb1300	490	=head2 render_file ($file, $path, $vars)
fab70e0a	491
28eb1300	492	Render and create a file from a template in DATA using Template
	493	Toolkit. $file is the relevent chunk of the __DATA__ section, $path is
	494	the path to the file and $vars is the hashref as expected by
	495	L<Template Toolkit\|Template>.
fab70e0a	496
28eb1300	497	=head2 get_file ($class, $file)
fab70e0a	498
fab70e0a	499	Fetch file contents from the DATA section. This is used internally by
28eb1300	500	L</render_file>. $class is the name of the class to get the DATA
	501	section from. __PACKAGE__ or ( caller(0) )[0] might be sensible
	502	values for this.
fab70e0a	503
	504	=head2 mk_app
	505
	506	Create the main application skeleton. This is called by L<catalyst.pl>.
	507
28eb1300	508	=head2 mk_component ($app)
fab70e0a	509
	510	This method is called by L<create.pl> to make new components
	511	for your application.
	512
28eb1300	513	=head3 mk_dir ($path)
fab70e0a	514
	515	Surprisingly, this function makes a directory.
	516
28eb1300	517	=head2 mk_file ($file, $content)
fab70e0a	518
	519	Writes content to a file. Called by L</render_file>.
	520
28eb1300	521	=head2 next_test ($test_name)
fab70e0a	522
fab70e0a	523	Calculates the name of the next numbered test file and returns it.
28eb1300	524	Don't give the number or the .t suffix for the test name.
fab70e0a	525
c6dbb300	526	=head2 Dir
	527
	528	Alias for L<Path::Class::Dir>
	529
	530	=cut
	531
	532	=head2 get_sharedir_file
	533
	534	Method for getting a file out of share/
	535
	536	=cut
	537
	538	=head2 render_file_contents
	539
	540	Process a L<Template::Toolkit> template.
	541
	542	=cut
	543
	544	=head2 render_sharedir_file
	545
	546	Render a template/image file from our share directory
	547
	548	=cut
	549
	550
68ccb5e5	551	=head1 NOTE
	552
	553	The helpers will read author name from /etc/passwd by default.
	554	To override, please export the AUTHOR variable.
	555
	556	=head1 SEE ALSO
	557
	558	L<Catalyst::Manual>, L<Catalyst::Test>, L<Catalyst::Request>,
	559	L<Catalyst::Response>, L<Catalyst>
	560
f64c718c	561	=head1 AUTHORS
68ccb5e5	562
f64c718c	563	Catalyst Contributors, see Catalyst.pm
68ccb5e5	564
	565	=head1 LICENSE
	566
7cd3b67e	567	This library is free software. You can redistribute it and/or modify
68ccb5e5	568	it under the same terms as Perl itself.
68ccb5e5	569
64d4433e	570	=begin pod_to_ignore
64d4433e	571
68ccb5e5	572	=cut
	573
	574	1;
68ccb5e5	575