Including other templates is tricky. Either you have to indent the included template as if it was pasted inline (eg. with a bunch of spaces in front of every line instead of the first level being column zero) or you have to format the include appropriately.

For example, let's say you have a content variable which was made by rendering some templates, you'd like to do something like:

%html
  %body
    #content
      [% content %]

You want the embedded content to be location neutral, ie. start at column zero. Something like:

#myDiv
  %ul
    %li foo

Except this will be rendered AFTER the closing html tag since the combined haml will look like:

%html
  %body
    #content
#myDiv
  %ul
    %li foo

I'm going to try to think of some better way to resolve this, but for now I'm using the Template::Toolkit built in indent filter like so:

%html
  %body
    #content
      [% content | indent('      ') %]

The only downside (apart from the pain of keeping it in sync) is that you end up with the rendered html having some funky indentation after the newlines are stripped, but I can live with that. You can use a number instead of a string as an argument to indent, and it will pad by that many spaces which may turn out to be easier to keep in sync.

I'll let you know if I have any flashes of genius and will also contact the Template::Plugin::Haml and Text::Haml authors.

Thanks to Viacheslav Tykhanovskyi's Text::Haml, we can now enjoy the good clean fun of Haml markup in Perl. Much Perl web templating is done with Template::Toolkit, and using Haml within TT is also now possible thanks to Template::Plugin::Haml by Caleb Cushing. The trouble is, you need to wrap every template in some boilerplate:

[%- USE Haml ; FILTER haml -%]
...
[%- END -%]

So I hacked up a quick solution to using .haml templates directly in Catalyst. First, create a MyApp::View::Haml class:

packageHello::View::Haml;

usestrict;
usewarnings;

usebase'Catalyst::View::TT';

useTemplate::Plugin::Haml;

__PACKAGE__->config(
    TEMPLATE_EXTENSION => '.haml',
    render_die => 1,
);

subrender {
    my ($self, $c, $template, $args) = @_;

    $c->log->debug(qq{Rendering Haml/TT template "$template"}) if$c && $c->debug;

    # args may be passed in or be in the stash
$args = { %{ $c->stash} }
        ifref$argsne'HASH';

    # let the master haml template know which template to render
$args->{haml_template} = $template;

    # do the normal TT render
return$self->SUPER::render($c, 'haml_master.tt', $args);
}

1;

Then you need a haml_master.tt template:

[%- USE Haml ; PROCESS $haml_template | haml -%]

And finally set your config to use the Haml view by default:

default_view => 'Haml'

Et voila - .haml template rendering albeit with only TT style variable interpolation. Getting haml interpolation working might need some change to how the stash is passed to the Text::Haml module.

A controller method might look like this:

subfoo:Global {
    my ($self, $c) = @_;

    $c->stash(foo => 'bar');
    $c->stash(template => 'foo.haml');
}

And foo.haml:

!!! HTML%body%p This is haml inside TT rendering your variables: [% foo %]

Becomes rendered as: