#!/usr/bin/perl
use strict;
use warnings;
use CGI;
use CGI::Carp 'fatalsToBrowser';

my $template_dir = '/path/to/template_dir';

my $q=CGI->new();

if ( $q->param() ) {
    show_template();
}
else {
    show_form();
}

sub show_template {
    my $template = $q->param('template');

    open(TMPL,"$template_dir/$template") || die $!;
    my $content = join '',(<TMPL>);
    close(TMPL);

    $content =~ s/<TMPL[^>]*>//gs;

    print $q->header(),
          $content;

    exit(0);
}

sub show_form {
    print $q->header,
          $q->start_html,
          $q->start_form,
          'Template: ',
          $q->textfield('template'),
          $q->submit,
          $q->end_form,
          $q->end_html;

    exit(0);
}
[download]

That way, you can set up a checkbox like this:

<input type="checkbox" name="foo" <TMP_VAR NAME=FOOCHECKED>>
[download]

where FOOCHECKED is either '' or 'checked'

Note - obviously I assume here you know how to taint check if this is on a live server (or to use an IP check to limit access etc) - this is just a rough outline.

.02

cLive ;-)

Good suggestion. I think it's easier not to duplicate HTML::Template's parsing if you already have it on hand though:

sub show_template {
    my $t_file = $q->param('template');

    require HTML::Template;
    my $t = HTML::Template->new_file($t_file);
    # and don't fill in any values
    print $q->header(), $t->output;

    exit(0);
}
[download]

Makeshifts last the longest.

Why not write a quick CGI script to display a template?

This is as much a human issue as it is a technical one.

The designers I'm dealing with are not developers. Setting things up so that they can open a template directly in a browser is easy for them. Easy in this case is Good. Requiring that they copy the template onto a web server, then pull up a form and name the template, adds nuisance work to their plates. Nuisance in this case is Bad.

If I was working with development-savvy page designers, a CGI to pre-process the template mght be an option.

Yuck. If you have to synchronize the template with the code, why use a template at all?

If you ask me, the best solution is to switch to Template Toolkit 2 and do something like this:

[% IF foo_checked ; '<input type=checkbox name="foo" checked>' ; ELSE 
+-%]
<input type=checkbox name="foo">[% END %]
[download]

<!--// IF foo_checked ; '<input type=checkbox name="foo" checked>' ; E
+LSE -->
<input type=checkbox name="foo"><!--// END -->
[download]

Makeshifts last the longest.

Writing harness code at the same time you create your template files also has the added benefit of forcing me to think through the application and template functionality. Once I have a solid understanding of the functionality, it is a breeze to write a simple skeletal framework.

For creating web applications I use CGI::Application. Using this module, realistic harness code is easily created through the mechanism of run-modes. The more realistic the code is from the beginning, the more bug-free the final product will be. To illustrate what I'm talking about, here's an example of what a test harness for application and template development might look like:

  package My::WebApp;
  use base qw/CGI::Application/;

  sub setup {
    my $self = shift;

    $self->start_mode('show_form');

    $self->run_modes(
        show_form    => 'show_form',
        list_results => 'list_results',
        show_detail  => 'show_detail',
    );
  }


  sub show_form {
    my $self = shift;

    my $tmpl = $self->load_tmpl('search_form.tmpl');

    # Set up example data for template
    $tmpl->param('foo_checked' => '1');

    return $tmpl->output();
  }


  sub list_results {
    my $self = shift;

    my $tmpl = $self->load_tmpl('list.tmpl');

    # Set up example data for template
    $tmpl->param('widget_loop' => [
        { widget_name => 'widget_one', widget_id => '1' },
        { widget_name => 'widget_two', widget_id => '2' },
        { widget_name => 'widget_three', widget_id => '3' },
    ]);

    return $tmpl->output();
  }


  sub show_detail {
    my $self = shift;

    my $tmpl = $self->load_tmpl('detail_view.tmpl');

    # Set up example data for template
    $tmpl->param('foo_id' => '1');
    $tmpl->param('foo_name' => 'widget_one');
    $tmpl->param('foo_checked' => 1);

    return $tmpl->output();
  }
[download]

You should look at using HTML::FillInForm to fill out your forms. I use it all the time with HTML::Template with great success.

Just do something like this:

my $q = new CGI();
my $template = new HTML::Template( ... );
my $html = $template->output();

my $fif = new HTML::FillInForm;
my $output = $fif->fill(scalarref => \$html,
                        fobject   => $q);
[download]

That will take your raw HTML, and a CGI query object and find any form fields in your HTML and automatically fill them in (including Select boxes, checkboxes and radio buttons).

Now you don't have to worry about using HTML::Template to fill in your values so your HTML becomes very simple, and your designers will have less <TMPL_VAR> tags to contend with.