++ed by:

1 non-PAUSE user.

osfameron
and 1 contributors

NAME

Sub::Auto - declare individual handlers for AUTLOADed subs, respecting can and inheritance

SYNOPSIS

 use Sub::Auto;

 autosub /^get_(\w+)$/ {
    my ($what, @pars) = @_;
    print "Getting $what...\n";
 }

 autosub /^set_(\w+)_(\w+)$/ {
    my ($adjective, $noun, @pars) = @_;
    print "Setting the $adjective $noun\n";
 }

 autosub handle_foo_events /foo$/ {
    my ($subname, @pars) = @_;
    print "Called $subname to do something to a foo\n";
 }

 get_foo();
 if (__PACKAGE__->can('set_blue_cat')) { ... }

DESCRIPTION

AUTOLOAD, like other languages' method-missing features is a useful feature for those situations when you want to handle sub or method calls dynamically, and can't pre-generate the subroutines with accessor generators.

To be sure, this is almost never the case, but occasionally, AUTOLOAD is convenient.

Well, "convenient" is a strong word, writing sub AUTOLOAD handlers is mildly unpleasant, and doesn't handle inheritance and can by default.

Using Sub::Auto you can:

  • Declare multiple handlers, each responding to calls matching a given regular expression.

  • Optionally name your handler, for clarity, or because you want to call it directly.

  • Ensure that unhandled methods get dealt with by the next class in the inheritance chain.

USAGE

autosub

 autosub [name] /regex/ { ... }

If the regex contains capturing parentheses, then each of those items will be prepended to the sub's argument list. For example:

 autosub /(\w+)_(\w+)/ {
    my ($verb, $noun, @params) = @_;
    print "$verb'ing $noun - " . join ','=>@params;
 }

 jump_up('one', 'two'); # prints "jump'ing up - one,two"

If the matching regex didn't have any capturing parens, the entire method name is passed as the first argument.

The name of the sub is optional. It registers a normal subroutine or method with that name in the current package. Nothing will be automatically prepended to a call to this method!

 autosub foo /(\w+)_(\w+)/ {
    my ($verb, $noun, $one,$two) = @_;
    print $one + $two;
 }

 foo (undef,undef, 1, 2);

SEE ALSO

Class::AutoloadCAN by Ben Tilly, does all the heavy lifting.

Devel::Declare by Matt Trout provides the tasty syntactic sugar.

http://greenokapi.net/blog/2008/07/03/more-perl-hate-and-what-to-do-about-it-autoload/

Class::Accessor or various other method generators that are a saner solution in general than using AUTOLOAD at all.

AUTHOR AND LICENSE

 (c) 2008 osfameron@cpan.org

This module is released under the same terms as Perl itself.