Item Description: Sane source filtering for the rest of us

Review Synopsis:

How many of you have written code that looks something like:

package Some::Class;

use strict;
use warnings;

sub new {
    my $class = shift;

    return bless { @_ }, $class;
}

sub foo {
    my $self = shift;
    $self->{foo} = shift if @_;
    return $self->{foo};
}

sub bar {
    my $self = shift;
    $self->{bar} = shift if @_;
    return $self->{bar};
}

sub baz {
    my $self = shift;
    $self->{baz} = shift if @_;
    return $self->{baz};
}

sub do_something_useful {
    ...
}
[download]

package Some::Class;

use strict;
use warnings;

sub new {
    my $class = shift;

    return bless { @_ }, $class;
}

foreach my $name ( qw( foo bar baz ) ) {
    no strict 'refs';
    *{ __PACKAGE__ . "::$name" } = sub {
        my $self = shift;
        $self->{$name} = shift if @_;
        return $self->{$name};
    };
}

sub do_something_useful {
    ...
}
[download]

<Trumpets sound in the distance /> Module::Compile::TT to the rescue! That code using typeglobs and closures now looks like:

package Some::Class;

use strict;
use warnings;

sub new {
    my $class = shift;

    return bless { @_ }, $class;
}

use tt;

[% FOREACH name IN [ 'foo', 'bar', 'baz' ] %]
sub [% name %] {
    my $self = shift;
    $self->{[% name %]} = shift if @_;
    return $self->{[% name %]};
}
[% END %]

no tt;

sub do_something_useful {
    ...
}
[download]

But, isn't this a source filter? Well, technically, it is. But, there's a major difference between this and Filter::Simple. Module::Compile::TT compiles this once and installs a .pmc file that you can look at and edit. Or, you could just run TT against this module and see what would happen.

Contrast that to Filter::Simple that won't generates potentially anything and you have no (sane) way of finding out what happened.

The real dealbreaker for me is that I feel pretty sure I could take this to any manager I use to work for and they would all be comfortable with that kind of code in their production codebases. This is code that can be maintained by the masses.