Padre::Plugin::Shell::Template - Create new documents from templates.

package Padre::Plugin::Shell::Template;
use base 'Padre::Plugin::Shell::Base';

use 5.008;
use strict;
use warnings;
use Padre::Constant ();
use Padre::Current  ();
use Padre::Util     ();
use Padre::Wx       ();
use File::Which;

our $VERSION = '0.1';

########################################################################
#
sub plugin_menu {
    my ($self) = @_;
    my @menu   = ();
    my %config = $self->get_config();
    my @accel_keys = ( 0 .. 9, 'A' .. 'Z' );

    foreach my $template ( sort keys %config ) {
        my $accel = '';
        if (@accel_keys) {
            my $a = shift @accel_keys;
            $accel = '&' . $a . ' - ';
        }
        push @menu, "$accel$template" => sub { $self->new_from_template($template) };
    }
    push @menu, '---' => undef;
    push @menu, Wx::gettext("&Configure Templates") => sub { $self->edit_config_file() },;

    return @menu;
}

sub example_config {
    my ($self) = @_;

    my $config = "---\n";

    # Start by loading the templates from Padre itself as:
    #   1. they probably exist, and
    #   2. they make good working examples
    my %templates = (
        'pl' => Wx::gettext('Perl 5 Script'),
        'pm' => Wx::gettext('Perl 5 Module'),
        'p6' => Wx::gettext('Perl 6 Script'),
        't'  => Wx::gettext('Perl 5 Test'),
    );
    
    # NOTE: if we have sh then we want to copy the file 
    # (and thus short circuit sh), otherwise leave the command blank.
    my $cmd = (which ('sh')) ? 'cp [% IN %] [% OUT %]' : '';
    
    foreach my $extension ( sort keys %templates ) {
        my $template_pathname = File::Spec->catfile( 
            Padre::Util::sharedir('templates'), "template.$extension" 
            );
        next unless ( -f $template_pathname );
        my $template_name = $templates{$extension};
        $config .= <<"EOT";
$template_name:
  command: '$cmd'
  description: Create a new $template_name
  mimetype: ''
  source_file: $template_pathname
EOT
    }

    # Add something that is not perl/Padre
    # TODO: example for systems without sh
    # TODO: create the example template
    if ( which('sh') ) {
        my $template_pathname = File::Spec->catfile( 
            Padre::Constant::CONFIG_DIR, 'templates', "template.sh" 
            );

        $config .= <<"EOT";
Shell Script:
  command: ''
  description: Create a new Shell Script
  mimetype: 'application/x-shellscript'
  source_file: $template_pathname

EOT
    }
    return $config;
}

sub new_from_template {
    my ( $self, $template ) = @_;
    my %config = $self->get_config();
    if ( exists $config{$template} ) {
        my $command  = $config{$template}{command}  || '';
        my $mimetype = $config{$template}{mimetype} || '';
        my $template_file = $config{$template}{source_file};

        ################################################################
        # Setup the environment
        $self->update_environment_vars();

        my $in_filename  = $self->get_temp_file();
        my $out_filename = $self->get_temp_file();

        # 1. If there is a command then
        #  - get a temporary output file
        #  - call the command with the template and temporary output file
        #  - create new from output file
        #  - rm out file
        if ($command) {
            $command =~ s/\[\% IN \%\]/$template_file/;
            $command =~ s/\[\% OUT \%\]/$out_filename/;
            my $rc = system($command);
            if ( $rc == -1 ) {
                $self->notify_of_error( 
                    Wx::gettext("Failed to run template command.\n") . $! 
                    );
                return;
            }
            $self->new_document_from_file( $out_filename, $mimetype );
        }

        # 2. else If we have a shell & cat then:
        #  - get a temporary file
        #  - wrap things in cat and redirect the output to the temporary file
        #  - create new from temporary out file
        #  - rm out file
        elsif ( which('cat') && which('sh') ) {
            my $template_text = $self->slurp_file($template_file);
            my $IN;
            if ( open $IN, '>', $in_filename ) {
                print $IN <<"EOT";
cat <<PADRE_EOT > $out_filename
$template_text
PADRE_EOT
EOT
                close $IN;

                my $rc = system("sh $in_filename");
                if ( $rc == -1 ) {
                    $self->notify_of_error( 
                        Wx::gettext("Failed to run template command.\n") . $! 
                        );
                    return;
                }
                $self->new_document_from_file( $out_filename, $mimetype );
            }
        }

        # 3. otherwise just create from the static template
        else {
            $self->new_document_from_file( $template_file, $mimetype );
        }

        $self->delete_temp_file($out_filename);
        $self->delete_temp_file($in_filename);
    }
}
1;