| CatalystX::Declare - EXPERIMENTAL Declarative Syntax for Catalyst Applications |
CatalystX::Declare - EXPERIMENTAL Declarative Syntax for Catalyst Applications
use CatalystX::Declare;
application MyApp::Web with Static::Simple {
$CLASS->config(name => 'My Declarative Web Application');
}
See also: the CatalystX::Declare::Keyword::Application manpage, class in the MooseX::Declare manpage
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 );
}
}
}
See also: the CatalystX::Declare::Keyword::Controller manpage, the CatalystX::Declare::Keyword::Action manpage, the CatalystX::Declare::Keyword::Component manpage, class in the MooseX::Declare manpage
use CatalystX::Declare;
controller_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);
}
}
See also: the CatalystX::Declare::Keyword::Role manpage, the CatalystX::Declare::Keyword::Action manpage, class in the MooseX::Declare manpage
use CatalystX::Declare;
view MyApp::Web::View::TT
extends Catalyst::View::TT {
$CLASS->config(
TEMPLATE_EXTENSION => '.html',
);
}
See also: the CatalystX::Declare::Keyword::View manpage, the CatalystX::Declare::Keyword::Component manpage, class in the MooseX::Declare manpage
use CatalystX::Declare;
model MyApp::Web::Model::DBIC::Schema
extends Catalyst::Model::DBIC::Schema {
$CLASS->config(
schema_class => 'MyApp::Schema',
);
}
See also: the CatalystX::Declare::Keyword::Model manpage, the CatalystX::Declare::Keyword::Component manpage, class in the MooseX::Declare manpage
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.
The used syntax elements are not parsed via source filter mechanism, but through the Devel::Declare manpage, 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.
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:
Things like models, views, roles for request or response objects, can be built
declaratively with the MooseX::Declare manpage, 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)
}
}
These links are intended for the common user of this module.
Although you probably already know Catalyst, since you otherwise probably wouldn't be here, I include these links for completeness sake.
The powerful modern Perl object orientation implementation that is used as basis for Catalyst. the MooseX::Declare manpage, on which the CatalystX::Declare manpage is based, provides a declarative syntax for Moose.
We inherit almost all functionality from the MooseX::Declare manpage to allow the declaration of traditional classes, roles, methods, modifiers, etc. Refer to this documentation first for syntax elements that aren't part of the CatalystX::Declare manpage.
This isn't directly used, but the MooseX::Declare manpage 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 the MooseX::Declare manpage documentation.
This section contains links relevant to the implementation of this module.
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.
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.
With contributions from, and many thanks to:
This program is free software; you can redistribute it and/or modify it under the same terms as perl itself.
| CatalystX::Declare - EXPERIMENTAL Declarative Syntax for Catalyst Applications |