File Coverage

blib/lib/OpenFrame/WebApp/Template.pm

Criterion	Covered	Total	%
statement	10	12	83.3
branch			n/a
condition			n/a
subroutine	4	4	100.0
pod			n/a
total	14	16	87.5

=head1 NAME

OpenFrame::WebApp::Template - abstract class for template processing wrappers

=head1 SYNOPSIS

  # abstract class - does nothing on its own
  use OpenFrame::WebApp::Template::SomeClass;

  my $tmpl = new OpenFrame::WebApp::Template::SomeClass()
    ->file( $local_path )
    ->template_vars( { some => vars } );

  try {
      $ofResponse = $tmpl->process;
  } catch OpenFrame::WebApp::Template::Error with {
      my $e = shift;
      print $e->flag, $e->message;
  }

=cut

package OpenFrame::WebApp::Template;

use strict;
use warnings::register;

use Error qw( :try );
use OpenFrame::Response;
use OpenFrame::WebApp::Error::Abstract;
use OpenFrame::WebApp::Template::Error;

use base qw ( OpenFrame::Object );

our $VERSION = (split(/ /, '$Revision: 1.13 $'))[1];

our $TYPES = {
	      tt2   => 'OpenFrame::WebApp::Template::TT2',
	      petal => 'OpenFrame::WebApp::Template::Petal',
	     };

## get hash of known template types
sub types {
    my $self = shift;
    if (@_) {
	$TYPES = shift;
	return $self;
    } else {
	return $TYPES;
    }
}

## object init
sub init {
    my $self = shift;
    $self->template_vars( {} );
}

## template processor
sub processor {
    my $self = shift;
    if (@_) {
	$self->{template_processor} = shift;
	return $self;
    } else {
	return $self->{template_processor};
    }
}

## override this method
sub default_processor {
    my $self = shift;
    throw OpenFrame::WebApp::Error::Abstract( class => ref($self) );
}

## local path to the template file
sub file {
    my $self = shift;
    if (@_) {
	$self->{template_file} = shift;
	return $self;
    } else {
	return $self->{template_file};
    }
}

## hash of template processing vars
sub template_vars {
    my $self = shift;
    if (@_) {
	$self->{template_vars} = shift;
	return $self;
    } else {
	return $self->{template_vars};
    }
}

## process the template file
sub process {
    my $self = shift;
    my $file = $self->file;

    return ($self->file_not_found) unless (-e $file);

    $self->processor( $self->default_processor ) unless $self->processor;

    my $output = $self->process_template;

    my $response = new OpenFrame::Response;
    $response->code( ofOK );
    $response->message( $output );

    return $response;
}

## override this method
sub process_template {
    my $self = shift;
    throw OpenFrame::WebApp::Error::Abstract( class => ref($self) );
}

## what to do when template file is not found
sub file_not_found {
    my $self = shift;
    throw OpenFrame::WebApp::Template::Error(
					     flag     => eTemplateNotFound,
					     template => $self->file,
					    );
}


1;

__END__