/usr/share/perl5/Catalyst/Manual/Actions.pod is in libcatalyst-manual-perl 5.9007-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 | =head1 NAME
Catalyst::Manual::Actions - Catalyst Reusable Actions
=head1 DESCRIPTION
This section of the manual describes the reusable action system in
Catalyst, how such actions work, descriptions of some existing ones, and
how to write your own. Reusable actions are attributes on Catalyst
methods that allow you to decorate your method with functions running
before or after the method call. This can be used to implement commonly
used action patterns, while still leaving you full freedom to customize
them.
=head1 USING ACTIONS
This is pretty simple. Actions work just like the normal dispatch
attributes you are used to, like Local or Private:
sub Hello :Local :ActionClass('SayBefore') {
$c->res->output( 'Hello '.$c->stash->{what} );
}
In this example, we expect the SayBefore action to magically populate
stash with something relevant before C<Hello> is run. In the next
section we'll show you how to implement it. If you want it in a
namespace other than Catalyst::Action you can prefix the action name
with a '+', for instance '+Foo::SayBefore', or if you just want it under
your application namespace instead, use MyAction, like
MyAction('SayBefore').
=head1 WRITING YOUR OWN ACTIONS
Implementing the action itself is almost as easy. Just use
L<Catalyst::Action> as a base class and decorate the C<execute> call in
the Action class:
package Catalyst::Action::MyAction;
use Moose;
use namespace::autoclean;
extends 'Catalyst::Action';
before 'execute' => sub {
my ( $self, $controller, $c, $test ) = @_;
$c->stash->{what} = 'world';
};
after 'execute' => sub {
my ( $self, $controller, $c, $test ) = @_;
$c->stash->{foo} = 'bar';
};
__PACKAGE__->meta->make_immutable;
Pretty simple, huh?
=head1 ACTION ROLES
You can only have one action class per action, which can be somewhat
inflexible.
The solution to this is to use L<Catalyst::Controller::ActionRole>, which
would make the example above look like this:
package Catalyst::ActionRole::MyActionRole;
use Moose::Role;
before 'execute' => sub {
my ( $self, $controller, $c, $test ) = @_;
$c->stash->{what} = 'world';
};
after 'execute' => sub {
my ( $self, $controller, $c, $test ) = @_;
$c->stash->{foo} = 'bar';
};
1;
and this would be used in a controller like this:
package MyApp::Controller::Foo;
use Moose;
use namespace::autoclean;
BEGIN { extends 'Catalyst::Controller::ActionRole'; }
sub foo : Does('MyActionRole') {
my ($self, $c) = @_;
}
1;
=head1 EXAMPLE ACTIONS
=head2 Catalyst::Action::RenderView
This is meant to decorate end actions. It's similar in operation to
L<Catalyst::Plugin::DefaultEnd>, but allows you to decide on an action
level rather than on an application level where it should be run.
=head2 Catalyst::Action::REST
Provides additional syntax for dispatching based upon the HTTP method
of the request.
=head1 EXAMPLE ACTIONROLES
=head2 Catalyst::ActionRole::ACL
Provides ACLs for role membership by decorating your actions.
=head1 AUTHORS
Catalyst Contributors, see Catalyst.pm
=head1 COPYRIGHT
This library is free software. You can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
|