NAME
CatalystX::Declare - EXPERIMENTAL Declarative Syntax for Catalyst
Applications
SYNOPSIS
Application
use CatalystX::Declare;
application MyApp::Web with Static::Simple {
$CLASS->config(name => 'My Declarative Web Application');
}
Controllers
use CatalystX::Declare;
controller MyApp::Web::Controller::Foo
with MyApp::Web::ControllerRole::Bar {
use MooseX::Types::Moose qw( Str );
has welcome_message => (
is => 'rw',
isa => Str,
required => 1,
lazy_build => 1,
);
method _build_welcome_message { 'Welcome' }
action base under '/' as '';
under base {
final action welcome {
$ctx->response->body( $self->welcome_message );
}
}
}
Roles
use CatalystX::Declare;
component_role MyApp::Web::ControllerRole::Bar {
use MyApp::Types qw( Username );
around _build_welcome_message { $self->$orig . '!' }
after welcome (Object $ctx) {
$ctx->response->body(join "\n",
$ctx->response->body,
time(),
);
}
final action special_welcome (Username $name) under base {
$ctx->response->body('Hugs to ' . $name);
}
}
DESCRIPTION
This module is EXPERIMENTAL
This module provides a declarative syntax for Catalyst applications. Its
main focus is currently on common and repetitious parts of the
application, such as the application class itself, controllers, and
controller roles.
Not a Source Filter
The used syntax elements are not parsed via source filter mechanism, but
through Devel::Declare, which is a much less fragile deal to handle and
allows extensions to mix without problems. For example, all keywords
added by this module are separete handlers.
Syntax Documentation
The documentation about syntax is in the respective parts of the
distribution below the "CatalystX::Declare::Keyword::" namespace. Here
are the manual pages you will be interested in to familiarize yourself
with this module's syntax extensions:
CatalystX::Declare::Keyword::Application
CatalystX::Declare::Keyword::Controller
CatalystX::Declare::Keyword::Action
CatalystX::Declare::Keyword::Role
Things like models, views, roles for request or response objects, can be
built declaratively with MooseX::Declare, which is used to additionally
provide keywords for "class", "role", "method" and the available method
modifier declarations. This allows for constructs such as:
use CatalystX::Declare;
class Foo {
method bar { 23 }
}
controller MyApp::Web::Controller::Baz {
final action qux under '/' {
$ctx->response->body(Foo->new->bar)
}
}
SEE ALSO
For Usage Information
These links are intended for the common user of this module.
Catalyst::Runtime
Catalyst::Devel
Catalyst::Manual
Although you probably already know Catalyst, since you otherwise
probably wouldn't be here, I include these links for completeness
sake.
Moose
The powerful modern Perl object orientation implementation that is
used as basis for Catalyst. MooseX::Declare, on which
CatalystX::Declare is based, provides a declarative syntax for
Moose.
MooseX::Declare
We inherit almost all functionality from MooseX::Declare to allow
the declaration of traditional classes, roles, methods, modifiers,
etc. Refer to this documentation first for syntax elements that
aren't part of CatalystX::Declare.
MooseX::Method::Signatures
This isn't directly used, but MooseX::Declare utilises this to
provide us with method and modifier declarations. For extended
information on the usage of methods, especially signatures, refer to
this module after looking for an answer in the MooseX::Declare
documentation.
For Developer Information
This section contains links relevant to the implementation of this
module.
Devel::Declare
You could call this is the basic machine room that runs the
interaction with perl. It provides a way to hook into perl's source
code parsing and change small parts on a per-statement basis.
MooseX::MethodAttributes
We use this module to easily communicate the action attributes to
Catalyst. Currently, this is the easiest solution for now but may be
subject to change in the future.
AUTHOR
Robert 'phaylon' Sedlacek,
With contributions from, and many thanks to:
Florian Ragwitz
John Napiorkowski
LICENSE
This program is free software; you can redistribute it and/or modify it
under the same terms as perl itself.