lib/Catalyst/DispatchType/Chained.pm

   1 package Catalyst::DispatchType::Chained;
   2
   3 use Moose;
   4 extends 'Catalyst::DispatchType';
   5
   6 use Text::SimpleTable;
   7 use Catalyst::ActionChain;
   8 use Catalyst::Utils;
   9 use URI;
  10 use Scalar::Util ();
  11
  12 has _endpoints => (
  13                    is => 'rw',
  14                    isa => 'ArrayRef',
  15                    required => 1,
  16                    default => sub{ [] },
  17                   );
  18
  19 has _actions => (
  20                  is => 'rw',
  21                  isa => 'HashRef',
  22                  required => 1,
  23                  default => sub{ {} },
  24                 );
  25
  26 has _children_of => (
  27                      is => 'rw',
  28                      isa => 'HashRef',
  29                      required => 1,
  30                      default => sub{ {} },
  31                     );
  32
  33 no Moose;
  34
  35 # please don't perltidy this. hairy code within.
  36
  37 =head1 NAME
  38
  39 Catalyst::DispatchType::Chained - Path Part DispatchType
  40
  41 =head1 SYNOPSIS
  42
  43 Path part matching, allowing several actions to sequentially take care of processing a request:
  44
  45   #   root action - captures one argument after it
  46   sub foo_setup : Chained('/') PathPart('foo') CaptureArgs(1) {
  47       my ( $self, $c, $foo_arg ) = @_;
  48       ...
  49   }
  50
  51   #   child action endpoint - takes one argument
  52   sub bar : Chained('foo_setup') Args(1) {
  53       my ( $self, $c, $bar_arg ) = @_;
  54       ...
  55   }
  56
  57 =head1 DESCRIPTION
  58
  59 Dispatch type managing default behaviour.  For more information on
  60 dispatch types, see:
  61
  62 =over 4
  63
  64 =item * L<Catalyst::Manual::Intro> for how they affect application authors
  65
  66 =item * L<Catalyst::DispatchType> for implementation information.
  67
  68 =back
  69
  70 =head1 METHODS
  71
  72 =head2 $self->list($c)
  73
  74 Debug output for Path Part dispatch points
  75
  76 =cut
  77
  78 sub list {
  79     my ( $self, $c ) = @_;
  80
  81     return unless $self->_endpoints;
  82
  83     my $column_width = Catalyst::Utils::term_width() - 35 - 9;
  84     my $paths = Text::SimpleTable->new(
  85        [ 35, 'Path Spec' ], [ $column_width, 'Private' ],
  86     );
  87
  88     my $has_unattached_actions;
  89     my $unattached_actions = Text::SimpleTable->new(
  90         [ 35, 'Private' ], [ $column_width, 'Missing parent' ],
  91     );
  92
  93     ENDPOINT: foreach my $endpoint (
  94                   sort { $a->reverse cmp $b->reverse }
  95                            @{ $self->_endpoints }
  96                   ) {
  97         my $args = $endpoint->attributes->{Args}->[0];
  98         my @parts = (defined($args) ? (("*") x $args) : '...');
  99         my @parents = ();
 100         my $parent = "DUMMY";
 101         my $curr = $endpoint;
 102         while ($curr) {
 103             if (my $cap = $curr->attributes->{CaptureArgs}) {
 104                 unshift(@parts, (("*") x $cap->[0]));
 105             }
 106             if (my $pp = $curr->attributes->{PartPath}) {
 107                 unshift(@parts, $pp->[0])
 108                     if (defined $pp->[0] && length $pp->[0]);
 109             }
 110             $parent = $curr->attributes->{Chained}->[0];
 111             $curr = $self->_actions->{$parent};
 112             unshift(@parents, $curr) if $curr;
 113         }
 114         if ($parent ne '/') {
 115             $has_unattached_actions = 1;
 116             $unattached_actions->row('/' . ($parents[0] || $endpoint)->reverse, $parent);
 117             next ENDPOINT;
 118         }
 119         my @rows;
 120         foreach my $p (@parents) {
 121             my $name = "/${p}";
 122             if (my $cap = $p->attributes->{CaptureArgs}) {
 123                 $name .= ' ('.$cap->[0].')';
 124             }
 125             unless ($p eq $parents[0]) {
 126                 $name = "-> ${name}";
 127             }
 128             push(@rows, [ '', $name ]);
 129         }
 130         push(@rows, [ '', (@rows ? "=> " : '')."/${endpoint}" ]);
 131         $rows[0][0] = join('/', '', @parts) || '/';
 132         $paths->row(@$_) for @rows;
 133     }
 134
 135     $c->log->debug( "Loaded Chained actions:\n" . $paths->draw . "\n" );
 136     $c->log->debug( "Unattached Chained actions:\n", $unattached_actions->draw . "\n" )
 137         if $has_unattached_actions;
 138 }
 139
 140 =head2 $self->match( $c, $path )
 141
 142 Calls C<recurse_match> to see if a chain matches the C<$path>.
 143
 144 =cut
 145
 146 sub match {
 147     my ( $self, $c, $path ) = @_;
 148
 149     my $request = $c->request;
 150     return 0 if @{$request->args};
 151
 152     my @parts = split('/', $path);
 153
 154     my ($chain, $captures, $parts) = $self->recurse_match($c, '/', \@parts);
 155
 156     if ($parts && @$parts) {
 157         for my $arg (@$parts) {
 158             $arg =~ s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg;
 159             push @{$request->args}, $arg;
 160         }
 161     }
 162
 163     return 0 unless $chain;
 164
 165     my $action = Catalyst::ActionChain->from_chain($chain);
 166
 167     $request->action("/${action}");
 168     $request->match("/${action}");
 169     $request->captures($captures);
 170     $c->action($action);
 171     $c->namespace( $action->namespace );
 172
 173     return 1;
 174 }
 175
 176 =head2 $self->recurse_match( $c, $parent, \@path_parts )
 177
 178 Recursive search for a matching chain.
 179
 180 =cut
 181
 182 sub recurse_match {
 183     my ( $self, $c, $parent, $path_parts ) = @_;
 184     my $children = $self->_children_of->{$parent};
 185     return () unless $children;
 186     my $best_action;
 187     my @captures;
 188     TRY: foreach my $try_part (sort { length($b) <=> length($a) }
 189                                    keys %$children) {
 190                                # $b then $a to try longest part first
 191         my @parts = @$path_parts;
 192         if (length $try_part) { # test and strip PathPart
 193             next TRY unless
 194               ($try_part eq join('/', # assemble equal number of parts
 195                               splice( # and strip them off @parts as well
 196                                 @parts, 0, scalar(@{[split('/', $try_part)]})
 197                               ))); # @{[]} to avoid split to @_
 198         }
 199         my @try_actions = @{$children->{$try_part}};
 200         TRY_ACTION: foreach my $action (@try_actions) {
 201             if (my $capture_attr = $action->attributes->{CaptureArgs}) {
 202
 203                 # Short-circuit if not enough remaining parts
 204                 next TRY_ACTION unless @parts >= $capture_attr->[0];
 205
 206                 my @captures;
 207                 my @parts = @parts; # localise
 208
 209                 # strip CaptureArgs into list
 210                 push(@captures, splice(@parts, 0, $capture_attr->[0]));
 211
 212                 # try the remaining parts against children of this action
 213                 my ($actions, $captures, $action_parts) = $self->recurse_match(
 214                                              $c, '/'.$action->reverse, \@parts
 215                                            );
 216                 #    No best action currently
 217                 # OR The action has less parts
 218                 # OR The action has equal parts but less captured data (ergo more defined)
 219                 if ($actions    &&
 220                     (!$best_action                                 ||
 221                      $#$action_parts < $#{$best_action->{parts}}   ||
 222                      ($#$action_parts == $#{$best_action->{parts}} &&
 223                       $#$captures < $#{$best_action->{captures}}))){
 224                     $best_action = {
 225                         actions => [ $action, @$actions ],
 226                         captures=> [ @captures, @$captures ],
 227                         parts   => $action_parts
 228                         };
 229                 }
 230             }
 231             else {
 232                 {
 233                     local $c->req->{arguments} = [ @{$c->req->args}, @parts ];
 234                     next TRY_ACTION unless $action->match($c);
 235                 }
 236
 237                 # Default args is blank, not 0, since Args()
 238                 my $args_attr = $action->attributes->{Args}->[0];
 239                 $args_attr = '' unless defined $args_attr;
 240
 241                 #    No best action currently
 242                 # OR This one matches with fewer parts left than the current best action,
 243                 #    And therefore is a better match
 244                 # OR No parts and this expects 0
 245                 #    The current best action might also be Args(0),
 246                 #    but we couldn't chose between then anyway so we'll take the last seen
 247
 248                 if (!$best_action                       ||
 249                     @parts < @{$best_action->{parts}}   ||
 250                     (!@parts && $args_attr eq 0)){
 251                     $best_action = {
 252                         actions => [ $action ],
 253                         captures=> [],
 254                         parts   => \@parts
 255                     }
 256                 }
 257             }
 258         }
 259     }
 260     return @$best_action{qw/actions captures parts/} if $best_action;
 261     return ();
 262 }
 263
 264 =head2 $self->register( $c, $action )
 265
 266 Calls register_path for every Path attribute for the given $action.
 267
 268 =cut
 269
 270 sub register {
 271     my ( $self, $c, $action ) = @_;
 272
 273     my @chained_attr = @{ $action->attributes->{Chained} || [] };
 274
 275     return 0 unless @chained_attr;
 276
 277     if (@chained_attr > 1) {
 278         Catalyst::Exception->throw(
 279           "Multiple Chained attributes not supported registering ${action}"
 280         );
 281     }
 282     my $chained_to = $chained_attr[0];
 283
 284     Catalyst::Exception->throw(
 285       "Actions cannot chain to themselves registering /${action}"
 286     ) if ($chained_to eq '/' . $action);
 287
 288     my $children = ($self->_children_of->{ $chained_to } ||= {});
 289
 290     my @path_part = @{ $action->attributes->{PathPart} || [] };
 291
 292     my $part = $action->name;
 293
 294     if (@path_part == 1 && defined $path_part[0]) {
 295         $part = $path_part[0];
 296     } elsif (@path_part > 1) {
 297         Catalyst::Exception->throw(
 298           "Multiple PathPart attributes not supported registering " . $action->reverse()
 299         );
 300     }
 301
 302     if ($part =~ m(^/)) {
 303         Catalyst::Exception->throw(
 304           "Absolute parameters to PathPart not allowed registering " . $action->reverse()
 305         );
 306     }
 307
 308     $action->attributes->{PartPath} = [ $part ];
 309
 310     unshift(@{ $children->{$part} ||= [] }, $action);
 311
 312     $self->_actions->{'/'.$action->reverse} = $action;
 313
 314     if (exists $action->attributes->{Args}) {
 315         my $args = $action->attributes->{Args}->[0];
 316         if (defined($args) and not (
 317             Scalar::Util::looks_like_number($args) and
 318             int($args) == $args
 319         )) {
 320             require Data::Dumper;
 321             local $Data::Dumper::Terse = 1;
 322             local $Data::Dumper::Indent = 0;
 323             $args = Data::Dumper::Dumper($args);
 324             Catalyst::Exception->throw(
 325               "Invalid Args($args) for action " . $action->reverse() .
 326               " (use 'Args' or 'Args(<number>)'"
 327             );
 328         }
 329     }
 330
 331     unless ($action->attributes->{CaptureArgs}) {
 332         unshift(@{ $self->_endpoints }, $action);
 333     }
 334
 335     return 1;
 336 }
 337
 338 =head2 $self->uri_for_action($action, $captures)
 339
 340 Get the URI part for the action, using C<$captures> to fill
 341 the capturing parts.
 342
 343 =cut
 344
 345 sub uri_for_action {
 346     my ( $self, $action, $captures ) = @_;
 347
 348     return undef unless ($action->attributes->{Chained}
 349                            && !$action->attributes->{CaptureArgs});
 350
 351     my @parts = ();
 352     my @captures = @$captures;
 353     my $parent = "DUMMY";
 354     my $curr = $action;
 355     while ($curr) {
 356         if (my $cap = $curr->attributes->{CaptureArgs}) {
 357             return undef unless @captures >= $cap->[0]; # not enough captures
 358             if ($cap->[0]) {
 359                 unshift(@parts, splice(@captures, -$cap->[0]));
 360             }
 361         }
 362         if (my $pp = $curr->attributes->{PartPath}) {
 363             unshift(@parts, $pp->[0])
 364                 if (defined($pp->[0]) && length($pp->[0]));
 365         }
 366         $parent = $curr->attributes->{Chained}->[0];
 367         $curr = $self->_actions->{$parent};
 368     }
 369
 370     return undef unless $parent eq '/'; # fail for dangling action
 371
 372     return undef if @captures; # fail for too many captures
 373
 374     return join('/', '', @parts);
 375
 376 }
 377
 378 =head2 $c->expand_action($action)
 379
 380 Return a list of actions that represents a chained action. See
 381 L<Catalyst::Dispatcher> for more info. You probably want to
 382 use the expand_action it provides rather than this directly.
 383
 384 =cut
 385
 386 sub expand_action {
 387     my ($self, $action) = @_;
 388
 389     return unless $action->attributes && $action->attributes->{Chained};
 390
 391     my @chain;
 392     my $curr = $action;
 393
 394     while ($curr) {
 395         push @chain, $curr;
 396         my $parent = $curr->attributes->{Chained}->[0];
 397         $curr = $self->_actions->{$parent};
 398     }
 399
 400     return Catalyst::ActionChain->from_chain([reverse @chain]);
 401 }
 402
 403 __PACKAGE__->meta->make_immutable;
 404
 405 =head1 USAGE
 406
 407 =head2 Introduction
 408
 409 The C<Chained> attribute allows you to chain public path parts together
 410 by their private names. A chain part's path can be specified with
 411 C<PathPart> and can be declared to expect an arbitrary number of
 412 arguments. The endpoint of the chain specifies how many arguments it
 413 gets through the C<Args> attribute. C<:Args(0)> would be none at all,
 414 C<:Args> without an integer would be unlimited. The path parts that
 415 aren't endpoints are using C<CaptureArgs> to specify how many parameters
 416 they expect to receive. As an example setup:
 417
 418   package MyApp::Controller::Greeting;
 419   use base qw/ Catalyst::Controller /;
 420
 421   #   this is the beginning of our chain
 422   sub hello : PathPart('hello') Chained('/') CaptureArgs(1) {
 423       my ( $self, $c, $integer ) = @_;
 424       $c->stash->{ message } = "Hello ";
 425       $c->stash->{ arg_sum } = $integer;
 426   }
 427
 428   #   this is our endpoint, because it has no :CaptureArgs
 429   sub world : PathPart('world') Chained('hello') Args(1) {
 430       my ( $self, $c, $integer ) = @_;
 431       $c->stash->{ message } .= "World!";
 432       $c->stash->{ arg_sum } += $integer;
 433
 434       $c->response->body( join "<br/>\n" =>
 435           $c->stash->{ message }, $c->stash->{ arg_sum } );
 436   }
 437
 438 The debug output provides a separate table for chained actions, showing
 439 the whole chain as it would match and the actions it contains. Here's an
 440 example of the startup output with our actions above:
 441
 442   ...
 443   [debug] Loaded Path Part actions:
 444   .-----------------------+------------------------------.
 445   | Path Spec             | Private                      |
 446   +-----------------------+------------------------------+
 447   | /hello/*/world/*      | /greeting/hello (1)          |
 448   |                       | => /greeting/world           |
 449   '-----------------------+------------------------------'
 450   ...
 451
 452 As you can see, Catalyst only deals with chains as whole paths and
 453 builds one for each endpoint, which are the actions with C<:Chained> but
 454 without C<:CaptureArgs>.
 455
 456 Let's assume this application gets a request at the path
 457 C</hello/23/world/12>. What happens then? First, Catalyst will dispatch
 458 to the C<hello> action and pass the value C<23> as an argument to it
 459 after the context. It does so because we have previously used
 460 C<:CaptureArgs(1)> to declare that it has one path part after itself as
 461 its argument. We told Catalyst that this is the beginning of the chain
 462 by specifying C<:Chained('/')>. Also note that instead of saying
 463 C<:PathPart('hello')> we could also just have said C<:PathPart>, as it
 464 defaults to the name of the action.
 465
 466 After C<hello> has run, Catalyst goes on to dispatch to the C<world>
 467 action. This is the last action to be called: Catalyst knows this is an
 468 endpoint because we did not specify a C<:CaptureArgs>
 469 attribute. Nevertheless we specify that this action expects an argument,
 470 but at this point we're using C<:Args(1)> to do that. We could also have
 471 said C<:Args> or left it out altogether, which would mean this action
 472 would get all arguments that are there. This action's C<:Chained>
 473 attribute says C<hello> and tells Catalyst that the C<hello> action in
 474 the current controller is its parent.
 475
 476 With this we have built a chain consisting of two public path parts.
 477 C<hello> captures one part of the path as its argument, and also
 478 specifies the path root as its parent. So this part is
 479 C</hello/$arg>. The next part is the endpoint C<world>, expecting one
 480 argument. It sums up to the path part C<world/$arg>. This leads to a
 481 complete chain of C</hello/$arg/world/$arg> which is matched against the
 482 requested paths.
 483
 484 This example application would, if run and called by e.g.
 485 C</hello/23/world/12>, set the stash value C<message> to "Hello" and the
 486 value C<arg_sum> to "23". The C<world> action would then append "World!"
 487 to C<message> and add C<12> to the stash's C<arg_sum> value.  For the
 488 sake of simplicity no view is shown. Instead we just put the values of
 489 the stash into our body. So the output would look like:
 490
 491   Hello World!
 492   35
 493
 494 And our test server would have given us this debugging output for the
 495 request:
 496
 497   ...
 498   [debug] "GET" request for "hello/23/world/12" from "127.0.0.1"
 499   [debug] Path is "/greeting/world"
 500   [debug] Arguments are "12"
 501   [info] Request took 0.164113s (6.093/s)
 502   .------------------------------------------+-----------.
 503   | Action                                   | Time      |
 504   +------------------------------------------+-----------+
 505   | /greeting/hello                          | 0.000029s |
 506   | /greeting/world                          | 0.000024s |
 507   '------------------------------------------+-----------'
 508   ...
 509
 510 What would be common uses of this dispatch technique? It gives the
 511 possibility to split up logic that contains steps that each depend on
 512 each other. An example would be, for example, a wiki path like
 513 C</wiki/FooBarPage/rev/23/view>. This chain can be easily built with
 514 these actions:
 515
 516   sub wiki : PathPart('wiki') Chained('/') CaptureArgs(1) {
 517       my ( $self, $c, $page_name ) = @_;
 518       #  load the page named $page_name and put the object
 519       #  into the stash
 520   }
 521
 522   sub rev : PathPart('rev') Chained('wiki') CaptureArgs(1) {
 523       my ( $self, $c, $revision_id ) = @_;
 524       #  use the page object in the stash to get at its
 525       #  revision with number $revision_id
 526   }
 527
 528   sub view : PathPart Chained('rev') Args(0) {
 529       my ( $self, $c ) = @_;
 530       #  display the revision in our stash. Another option
 531       #  would be to forward a compatible object to the action
 532       #  that displays the default wiki pages, unless we want
 533       #  a different interface here, for example restore
 534       #  functionality.
 535   }
 536
 537 It would now be possible to add other endpoints, for example C<restore>
 538 to restore this specific revision as the current state.
 539
 540 You don't have to put all the chained actions in one controller. The
 541 specification of the parent through C<:Chained> also takes an absolute
 542 action path as its argument. Just specify it with a leading C</>.
 543
 544 If you want, for example, to have actions for the public paths
 545 C</foo/12/edit> and C</foo/12>, just specify two actions with
 546 C<:PathPart('foo')> and C<:Chained('/')>. The handler for the former
 547 path needs a C<:CaptureArgs(1)> attribute and a endpoint with
 548 C<:PathPart('edit')> and C<:Chained('foo')>. For the latter path give
 549 the action just a C<:Args(1)> to mark it as endpoint. This sums up to
 550 this debugging output:
 551
 552   ...
 553   [debug] Loaded Path Part actions:
 554   .-----------------------+------------------------------.
 555   | Path Spec             | Private                      |
 556   +-----------------------+------------------------------+
 557   | /foo/*                | /controller/foo_view         |
 558   | /foo/*/edit           | /controller/foo_load (1)     |
 559   |                       | => /controller/edit          |
 560   '-----------------------+------------------------------'
 561   ...
 562
 563 Here's a more detailed specification of the attributes belonging to
 564 C<:Chained>:
 565
 566 =head2 Attributes
 567
 568 =over 8
 569
 570 =item PathPart
 571
 572 Sets the name of this part of the chain. If it is specified without
 573 arguments, it takes the name of the action as default. So basically
 574 C<sub foo :PathPart> and C<sub foo :PathPart('foo')> are identical.
 575 This can also contain slashes to bind to a deeper level. An action
 576 with C<sub bar :PathPart('foo/bar') :Chained('/')> would bind to
 577 C</foo/bar/...>. If you don't specify C<:PathPart> it has the same
 578 effect as using C<:PathPart>, it would default to the action name.
 579
 580 =item PathPrefix
 581
 582 Sets PathPart to the path_prefix of the current controller.
 583
 584 =item Chained
 585
 586 Has to be specified for every child in the chain. Possible values are
 587 absolute and relative private action paths or a single slash C</> to
 588 tell Catalyst that this is the root of a chain. The attribute
 589 C<:Chained> without arguments also defaults to the C</> behavior.
 590 Relative action paths may use C<../> to refer to actions in parent
 591 controllers.
 592
 593 Because you can specify an absolute path to the parent action, it
 594 doesn't matter to Catalyst where that parent is located. So, if your
 595 design requests it, you can redispatch a chain through any controller or
 596 namespace you want.
 597
 598 Another interesting possibility gives C<:Chained('.')>, which chains
 599 itself to an action with the path of the current controller's namespace.
 600 For example:
 601
 602   #   in MyApp::Controller::Foo
 603   sub bar : Chained CaptureArgs(1) { ... }
 604
 605   #   in MyApp::Controller::Foo::Bar
 606   sub baz : Chained('.') Args(1) { ... }
 607
 608 This builds up a chain like C</bar/*/baz/*>. The specification of C<.>
 609 as the argument to Chained here chains the C<baz> action to an action
 610 with the path of the current controller namespace, namely
 611 C</foo/bar>. That action chains directly to C</>, so the C</bar/*/baz/*>
 612 chain comes out as the end product.
 613
 614 =item ChainedParent
 615
 616 Chains an action to another action with the same name in the parent
 617 controller. For Example:
 618
 619   # in MyApp::Controller::Foo
 620   sub bar : Chained CaptureArgs(1) { ... }
 621
 622   # in MyApp::Controller::Foo::Moo
 623   sub bar : ChainedParent Args(1) { ... }
 624
 625 This builds a chain like C</bar/*/bar/*>.
 626
 627 =item CaptureArgs
 628
 629 Must be specified for every part of the chain that is not an
 630 endpoint. With this attribute Catalyst knows how many of the following
 631 parts of the path (separated by C</>) this action wants to capture as
 632 its arguments. If it doesn't expect any, just specify
 633 C<:CaptureArgs(0)>.  The captures get passed to the action's C<@_> right
 634 after the context, but you can also find them as array references in
 635 C<$c-E<gt>request-E<gt>captures-E<gt>[$level]>. The C<$level> is the
 636 level of the action in the chain that captured the parts of the path.
 637
 638 An action that is part of a chain (that is, one that has a C<:Chained>
 639 attribute) but has no C<:CaptureArgs> attribute is treated by Catalyst
 640 as a chain end.
 641
 642 =item Args
 643
 644 By default, endpoints receive the rest of the arguments in the path. You
 645 can tell Catalyst through C<:Args> explicitly how many arguments your
 646 endpoint expects, just like you can with C<:CaptureArgs>. Note that this
 647 also affects whether this chain is invoked on a request. A chain with an
 648 endpoint specifying one argument will only match if exactly one argument
 649 exists in the path.
 650
 651 You can specify an exact number of arguments like C<:Args(3)>, including
 652 C<0>. If you just say C<:Args> without any arguments, it is the same as
 653 leaving it out altogether: The chain is matched regardless of the number
 654 of path parts after the endpoint.
 655
 656 Just as with C<:CaptureArgs>, the arguments get passed to the action in
 657 C<@_> after the context object. They can also be reached through
 658 C<$c-E<gt>request-E<gt>arguments>.
 659
 660 =back
 661
 662 =head2 Auto actions, dispatching and forwarding
 663
 664 Note that the list of C<auto> actions called depends on the private path
 665 of the endpoint of the chain, not on the chained actions way. The
 666 C<auto> actions will be run before the chain dispatching begins. In
 667 every other aspect, C<auto> actions behave as documented.
 668
 669 The C<forward>ing to other actions does just what you would expect. But if
 670 you C<detach> out of a chain, the rest of the chain will not get called
 671 after the C<detach>.
 672
 673 =head1 AUTHORS
 674
 675 Catalyst Contributors, see Catalyst.pm
 676
 677 =head1 COPYRIGHT
 678
 679 This library is free software. You can redistribute it and/or modify it under
 680 the same terms as Perl itself.
 681
 682 =cut
 683
 684 1;