—
—
—
—
—
—
—
—
—
—
—
—
—
—
—

              
package Module::Starter::Plugin::Template;
use warnings;
use strict;
use Carp qw( confess );
HideShow 10 lines of Pod
=head1 NAME
Module::Starter::Plugin::Template - module starter with templates
=head1 VERSION
Version 1.57
=cut
our $VERSION = '1.57';
HideShow 25 lines of Pod
=head1 SYNOPSIS
 use Module::Starter qw(
   Module::Starter::Simple
   Module::Starter::Plugin::Template
 );
 Module::Starter->create_distro(%args);
=head1 DESCRIPTION
This plugin is designed to be added to a Module::Starter::Simple-compatible
Module::Starter class.  It adds stub methods for template retrieval and
rendering, and it replaces all of Simple's _guts methods with methods that will
retrieve and render the apropriate templates.
=head1 CLASS METHODS
=head2 C<< new(%args) >>
This plugin calls the C<new> supermethod and then initializes the template
store and renderer.  (See C<templates> and C<renderer> below.)
=cut
sub new {
    my $class = shift;
    my $self  = $class->SUPER::new(@_);
    $self->{templates} = { $self->templates };
    $self->{renderer} = $self->renderer;
    return bless $self => $class;
}
HideShow 11 lines of Pod
=head1 OBJECT METHODS
=head2 C<< templates() >>
This method is used to initialize the template store on the Module::Starter
object.  It returns a hash of templates; each key is a filename and each value
is the body of the template.  The filename F<Module.pm> is used for the module
template.
=cut
sub templates {
    confess 'attempted to use abstract base templates method';
}
HideShow 7 lines of Pod
=head2 C<< renderer() >>
This method is used to initialize the template renderer.  Its result is stored
in the object's C<renderer> entry.  The implementation will determine its use.
=cut
sub renderer {
    confess 'attempted to use abstract base renderer method';
}
HideShow 7 lines of Pod
=head2 C<< render($template, \%options) >>
The C<render> method will render the template passed to it, using the
data in the Module::Starter object and in the hash of passed parameters.
=cut
sub render {
    my $self = shift;
    my $template = shift;
    my $options = shift;
    confess 'attempted to use abstract base render method';
}
HideShow 23 lines of Pod
=head2 _guts methods
All of the C<FILE_guts> methods from Module::Starter::Simple are subclassed to
look something like this:
    sub file_guts {
        my $self = shift;
        my %options;
        @options{qw(first second third)} = @_;
        my $template = $self->{templates}{filename};
        $self->render($template, \%options);
    }
These methods will need to be rewritten when (as is likely)
Module::Starter::Simple's _guts methods are refactored into a registry.
=over 4
=item module_guts
=cut
sub module_guts {
    my $self = shift;
    my %options;
    @options{qw(module rtname)} = @_;
    my $template = $self->{templates}{'Module.pm'};
    $self->render($template, \%options);
}
HideShow 4 lines of Pod
=item Makefile_PL_guts
=cut
sub Makefile_PL_guts {
    my $self = shift;
    my %options;
    @options{qw(main_module main_pm_file)} = @_;
    my $template = $self->{templates}{'Makefile.PL'};
    $self->render($template, \%options);
}
HideShow 4 lines of Pod
=item MI_Makefile_PL_guts
=cut
sub MI_Makefile_PL_guts {
    my $self = shift;
    my %options;
    @options{qw(main_module main_pm_file)} = @_;
    my $template = $self->{templates}{'MI_Makefile.PL'};
    $self->render($template, \%options);
}
HideShow 4 lines of Pod
=item Build_PL_guts
=cut
sub Build_PL_guts {
    my $self = shift;
    my %options;
    @options{qw(main_module main_pm_file)} = @_;
    my $template = $self->{templates}{'Build.PL'};
    $self->render($template, \%options);
}
HideShow 4 lines of Pod
=item Changes_guts
=cut
sub Changes_guts {
    my $self = shift;
    my $template = $self->{templates}{'Changes'};
    $self->render($template);
}
HideShow 4 lines of Pod
=item README_guts
=cut
sub README_guts {
    my $self = shift;
    my %options;
    @options{qw(build_instructions)} = @_;
    my $template = $self->{templates}{'README'};
    $self->render($template, \%options);
}
HideShow 4 lines of Pod
=item t_guts
=cut
sub t_guts {
    my $self = shift;
    my %options;
    $options{modules} = [ @_ ];
    my %t_files;
    foreach (grep { /\.t$/ } keys %{$self->{templates}}) {
        my $template = $self->{templates}{$_};
        $t_files{$_} = $self->render($template, \%options);
    }
    return %t_files;
}
HideShow 4 lines of Pod
=item MANIFEST_guts
=cut
sub MANIFEST_guts {
    my $self = shift;
    my %options;
    $options{files} = [ sort @_ ];
    my $template = $self->{templates}{MANIFEST};
    $self->render($template, \%options);
}
HideShow 4 lines of Pod
=item item ignores_guts
=cut
sub ignores_guts {
    my $self = shift;
    my $template = $self->{templates}{ignores};
    $self->render($template);
}
HideShow 22 lines of Pod
=back
=head1 AUTHOR
Ricardo SIGNES, C<< <rjbs at cpan.org> >>
=head1 Bugs
Please report any bugs or feature requests to
C<bug-module-starter at rt.cpan.org>, or through the web interface at
L<http://rt.cpan.org>.  I will be notified, and then you'll automatically be
notified of progress on your bug as I make changes.
=head1 COPYRIGHT
Copyright 2005-2007 Ricardo SIGNES, All Rights Reserved.
This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.
=cut
# vi:et:sw=4 ts=4
1;