+---

+date: 2009-11-09T00:00:00Z

+summary: In which I share my enthusiasm for Devel::Declare.

+title: Modules I like Devel::Declare

+---

+

+For [$work](http://linkfluence.net/), I've been working on a job queue system, using Moose, Catalyst (for a REST API) and DBIx::Class to store the jobs and some meta (yeah I know, there is not enough job queue system already, the world really needs a new one ...).

+

+Basicaly, I've got a XXX::Worker class that all the workers extends. This class provide methods for fetching job, add a new job, mark a job as fail, retry, ...

+

+The main loop in the XXX::Worker class look like this:

+

+```perl

+# $context is a hashref with some info the job or method may need

+while (1) {

+ my @jobs = $self->fetch_jobs();

+ foreach my $job (@jobs) {

+ my $method = $job->{funcname};

+ $self->$method($context, $job);

+ }

+ $self->wait;

+}

+```

+

+and the worker look like this

+

+```perl

+package MyWorker;

+use Moose;

+extends 'XXX::Worker';

+

+sub foo {

+ my ($self, $context, $job) = @_;

+

+ # do something

+ $self->job_success();

+}

+```

+

+But as I'm using Moose, I want to add more sugar to the syntax, so writing a new worker would be really more easy.

+

+Here comes [Devel::Declare](http://search.cpan.org/perldoc?Devel::Declare).

+

+The syntax I want for my worker is this one:

+

+```perl

+work foo {

+ $self->logger->info("start to work on job");

+ # do something with $job

+};

+

+work bar {

+ # do something with $job

+};

+

+success foo {

+ $self->logger->info("woot job success");

+};

+

+fail bar {

+ $self->logger->info("ho noez this one failed");

+};

+```

+

+Where with `work` I write the code the writer will execute on a task, `success`, a specific code that will be executed after a job is marked as successfull, and `fail` for when the job fail.

+

+I will show how to add the `work` keyword. I start by writing a new package:

+

+```perl

+package XXX::Meta;

+

+use Moose;

+use Moose::Exporter;

+use Moose::Util::MetaRole;

+

+use Devel::Declare;

+

+use XXX::Meta::Class;

+use XXX::Keyword::Work;

+

+Moose::Exporter->setup_import_methods();

+

+sub init_meta {

+ my ($me, %options) = @_;

+

+ my $for = $options{for_class};

+

+ XXX::Keyword::Work->install_methodhandler(into => $for,);

+

+ Moose::Util::MetaRole::apply_metaclass_roles(

+ for_class => $for,

+ metaclass_roles => ['XXX::Meta::Class'],

+ );

+

+}

+

+1;

+```

+

+The `init_meta` method is provided by Moose: (from the POD)

+

+> The `init_meta` method sets up the metaclass object for the class specified by `for_class`. This method injects a a meta accessor into the class so you can get at this object. It also sets the class's superclass to base_class, with Moose::Object as the default.

+

+So I inject into the class that will use XXX::Meta a new metaclass, XXX::Meta::Class.

+

+Let's take a look to XXX::Meta::Class:

+

+```perl

+package XXX::Meta::Class;

+

+use Moose::Role;

+use Moose::Meta::Class;

+use MooseX::Types::Moose qw(Str ArrayRef ClassName Object);

+

+has work_metaclass => (

+ is => 'ro',

+ isa => Object,

+ builder => '_build_metaclass',

+ lazy => 1,

+);

+

+has 'local_work' => (

+ traits => ['Array'],

+ is => 'ro',

+ isa => ArrayRef [Str],

+ required => 1,

+ default => sub { [] },

+ auto_deref => 1,

+ handles => {'_add_work' => 'push',}

+);

+

+sub _build_metaclass {

+ my $self = shift;

+ return Moose::Meta::Class->create_anon_class(

+ superclasses => [$self->method_metaclass],

+ cache => 1,

+ );

+}

+

+sub add_local_method {

+ my ($self, $method, $name, $code) = @_;

+

+ my $method_name = $method . "_" . $name;

+ my $body = $self->work_metaclass->name->wrap(

+ $code,

+ original_body => $code,

+ name => $method_name,

+ package_name => $self->name,

+ );

+

+ my $method_add = "_add_" . $method;

+ $self->add_method($method_name, $body);

+ $self->$method_add($method_name);

+}

+

+1;

+```

+

+Here I add to the `->meta` provided by Moose `local_work`, which is an array that contains all my `work` methods. So each time I do something like

+

+```perl

+work foo {};

+

+work bar {};

+```

+

+in my worker, I add this method to **->meta->local_work**.

+

+And the class for our keyword work:

+

+```perl

+package XXX::Keyword::Work;

+

+use strict;

+use warnings;

+

+use Devel::Declare ();

+use Sub::Name;

+

+use base 'Devel::Declare::Context::Simple';

+

+sub install_methodhandler {

+ my $class = shift;

+ my %args = @_;

+ {

+ no strict 'refs';

+ *{$args{into} . '::work'} = sub (&) { };

+ }

+

+ my $ctx = $class->new(%args);

+ Devel::Declare->setup_for(

+ $args{into},

+ { work => {

+ const => sub { $ctx->parser(@_) }

+ },

+ }

+ );

+}

+

+sub parser {

+ my $self = shift;

+ $self->init(@_);

+

+ $self->skip_declarator;

+ my $name = $self->strip_name;

+ $self->strip_proto;

+ $self->strip_attrs;

+

+ my $inject = $self->scope_injector_call();

+ $self->inject_if_block(

+ $inject . " my (\$self, \$content, \$job) = \@_; ");

+

+ my $pack = Devel::Declare::get_curstash_name;

+ Devel::Declare::shadow_sub(

+ "${pack}::work",

+ sub (&) {

+ my $work_method = shift;

+ $pack->meta->add_local_method('work', $name, $work_method);

+ }

+ );

+ return;

+}

+

+1;

+```

+

+The `install_methodhandler` add the `work` keyword, with a block of code. This code is sent to the parser, that will add more sugar. With the inject_if_block, I inject the following line

+

+```perl

+my ($self, $context, $job) = @_;

+```

+

+as this will always be my 3 arguments for a work method.

+

+Now, for each new worker, I write something like this:

+

+```perl

+package MyWorker;

+use Moose;

+extends 'XXX::Worker';

+use XXX::Meta;

+

+work foo {};

+```

+

+The next step is too find the best way to reduce the first four lines to two.

+

+(some of this code is ripped from other modules that use Devel::Declare. The best way to learn what you can do with this module is to read code from other modules that use it)