To use it when defining routes, easily:


package MyApp;

use Dancer;
use Dancer::Plugin::REST;


This exports the resource keyword, which can be used as such:


resource camel => (
create => sub {},
get => sub {},
update => sub {},
delete => sub {},
);


This automatically creates the following route handlers:

• post /camel (create)
• post /camel.:format (create)
• get /camel/:id (read)
• get /camel/:id.:format (read)
• put /camel/:id (update)
• put /camel/:id.:format (update)
• del /camel/:id (delete)
• del /camel/:id.:format (delete)

The format param can be used in requests such as


GET /camel/larry.xml


Next to that, this module exports a whole bunch of error handler methods, such as

• status_unauthorized
• status_ok
• status_length_required
• status_not_found
• status_forbidden

which can be used to make life easier:


return status_unauthorized("Not Larry") unless $user->is_larry;


If the code of the status you are using is equal or higher than 100, your error message will be the value of key 'error' ( { error => "Not Larry" } ) - otherwise it's just a verbatim. Of course it's expected that since you're working with REST, you're serialising your return values.

Some nitpicks:

• "get" should be called "read" for CRUD (create read update delete)


• The POD is incorrect.

I earlier issued a pull request of a fork where I update the POD problem and renamed "get" to "read" as well as swapping the meaning of POST and PUT. I believed PUT should be CREATE, and POST update, even though this later proved to be incorrect. I hope the changes to POD will however be added. It's trivial, but correct.

Closing words
This is one of those nifty little modules that makes writing a RESTful webapp just that little bit easier and makes your code more organised. I can recommend it!

Shortly after YAPC::EU::2010 I received a RT request from Andreas Koenig alerting me to the issue. At YAPC I had heard about this utility called Dist::Zilla which was supposed to make the managing of distributions a lot easier.

Off to CPAN. D::Z took a while to install but the install itself had no problems. I started reading the CPAN page and read Dist::Zilla::Tutorial. Since this was however limited, I directed my attention to the tutorial on dzil.org.

This tutorial has the style of a 'make your own adventure' children's book which was amusing. I found out that I could either start anew or switch my current distrubution over.

I decided to start anew and ran

$ dzil setup

to configure dzil (the Dist::Zilla::App commandline utility) - it creates ~/dzil.ini.
followed by

$ dzil new Postscript-TextDecode

which created the Postscript-TextDecode directory for me, with in it dzil.ini and lib/Postscript/TextDecode.pm.

After that I pasted my existing code into TextDecode.pm and created t/Postscript-TextDecode.t. I could remove $VERSION since I now define that in dist.ini.

After some fiddling, $ dzil test did the testing and $ dzil release uploaded a gzipped tarball onto the PAUSE server.

In between all this, I encountered the following hurdles:

• dzil test and dzil build won't work without [@Classic] in the dist.ini. I do not know why.
• the documentation on dzil.org seems...incomplete, or at least appears to assume the reader has in-depth knowledge of the distribution creation process, while I am relatively new to this

Still, it did not cost me huge amounts of time and in the long run this utility should really simplify the creation and maintenance of new modules. Not bad at all. And from what I've seen on CPAN, it's very easy to extend.

If I've missed obvious things, please direct me so I may learn.

So far it has been fun - I've done some Perl evangelising and handed out Round Tuits to random people (thanks for those Tuits, Wendy).

The overall view of Perl is the same ol' "Perl is line noise and the language hasn't seen changes in 10 years lol". While a rebuttal is easy, it's somewhat disheartening but not unexpected.

Other than that, not a bad tech festival.