X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=catagits%2FCatalyst-Manual.git;a=blobdiff_plain;f=lib%2FCatalyst%2FManual%2FActions.pod;h=667f1167188245892f035586415321924392cdd5;hp=6cd5949f65f9af438f109690a3535b69c375bfe6;hb=02bb2b5a140dc22d7d002fcdce868656d704676a;hpb=cb93c9d7a46377666f9593736dcb87fad8f9d82e

diff --git a/lib/Catalyst/Manual/Actions.pod b/lib/Catalyst/Manual/Actions.pod
index 6cd5949..667f116 100644
--- a/lib/Catalyst/Manual/Actions.pod
+++ b/lib/Catalyst/Manual/Actions.pod
@@ -1,31 +1,33 @@
 =head1 NAME
 
-Catalyst::Manual::Actions - Catalyst Reusable Actions 
+Catalyst::Manual::Actions - Catalyst Reusable Actions
 
 =head1 DESCRIPTION
 
 This section of the manual describes the reusable action system in
-Catalyst, how they 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.
+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. It works just like the normal dispatch attributes
-you are used to, like Local or Private:
+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} );
-  }
+    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 another
-namespace 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').
+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
 
@@ -33,35 +35,88 @@ 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::SayBefore;
+    package Catalyst::Action::MyAction;
+    use Moose;
+    use namespace::autoclean;
 
-  use base 'Catalyst::Action';
+    extends 'Catalyst::Action';
 
-  sub execute {
-    my $self = shift;
-    my ( $controller, $c, $test ) = @_;
-    $c->stash->{what} = 'world';
-    $self->NEXT::execute( @_ );
-  };
+    before 'execute' => sub {
+        my ( $self, $controller, $c, $test ) = @_;
+        $c->stash->{what} = 'world';
+    };
 
-  1;
+    after 'execute' => sub {
+        my ( $self, $controller, $c, $test ) = @_;
+        $c->stash->{foo} = 'bar';
+    };
 
-If you want to do something after the action, just put it after the
-C<execute> call. Pretty simple, huh?
+    __PACKAGE__->meta->make_immutable;
 
-=head1 ACTIONS
+Pretty simple, huh?
 
-=head2 Catalyst::Action::RenderView
+=head1 ACTION ROLES
 
-This is meant to decorate end actions. It's similar in operation to 
+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 L<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.
 
-=head1 AUTHOR
+=head2 L<Catalyst::Action::REST>
+
+Provides additional syntax for dispatching based upon the HTTP method
+of the request.
+
+=head1 EXAMPLE ACTIONROLES
 
-The Catalyst Core Team - see http://catalyst.perl.org/
+=head2 L<Catalyst::ActionRole::ACL>
+
+Provides ACLs for role membership by decorating your actions.
+
+=head1 AUTHORS
+
+Catalyst Contributors, see Catalyst.pm
 
 =head1 COPYRIGHT
 
-This program is free software. You can redistribute it and/or modify it
-under the same terms as Perl itself.
+This library is free software. You can redistribute it and/or modify it under
+the same terms as Perl itself.
+
+=cut