my $begin = ( $c->get_actions( 'begin', $c->namespace ) )[-1];
return 1 unless $begin;
$begin->dispatch( $c );
- return !@{ $c->error };
+ #If there is an error, all bets off
+ if( @{ $c->error }) {
+ return !@{ $c->error };
+ } else {
+ return $c->state || 1;
+ }
}
sub _AUTO : Private {
my ( $self, $c ) = @_;
my @auto = $c->get_actions( 'auto', $c->namespace );
foreach my $auto (@auto) {
+ # We FORCE the auto action user to explicitly return
+ # true. We need to do this since there's some auto
+ # users (Catalyst::Authentication::Credential::HTTP) that
+ # actually do a detach instead.
+ $c->state(0);
$auto->dispatch( $c );
return 0 unless $c->state;
}
- return 1;
+ return $c->state || 1;
}
sub _ACTION : Private {
{
$c->action->dispatch( $c );
}
- return !@{ $c->error };
+ #If there is an error, all bets off
+ if( @{ $c->error }) {
+ return !@{ $c->error };
+ } else {
+ return $c->state || 1;
+ }
}
sub _END : Private {
push @roles, 'Catalyst::ActionRole::Scheme'
if $args{attributes}->{Scheme};
+
+ push @roles, 'Catalyst::ActionRole::QueryMatching'
+ if $args{attributes}->{Query};
return @roles;
}
# Parse out :Foo(bar) into Foo => bar etc (and arrayify)
- if ( my ( $key, $value ) = ( $attr =~ /^(.*?)(?:\(\s*(.+?)\s*\))?$/ ) )
+ if ( my ( $key, $value ) = ( $attr =~ /^(.*?)(?:\(\s*(.+?)?\s*\))?$/ ) )
{
if ( defined $value ) {
sub _parse_DELETE_attr { Method => 'DELETE' }
sub _parse_OPTIONS_attr { Method => 'OPTIONS' }
sub _parse_HEAD_attr { Method => 'HEAD' }
+sub _parse_PATCH_attr { Method => 'PATCH' }
sub _expand_role_shortname {
my ($self, @shortnames) = @_;
=head2 CaptureArgs
-Please see L<Catalyst::DispatchType::Chained>
+Allowed values for CaptureArgs is a single integer (CaptureArgs(2), meaning two
+allowed) or you can declare a L<Moose>, L<MooseX::Types> or L<Type::Tiny>
+named constraint such as CaptureArgs(Int,Str) would require two args with
+the first being a Integer and the second a string. You may declare your own
+custom type constraints and import them into the controller namespace:
+
+ package MyApp::Controller::Root;
+
+ use Moose;
+ use MooseX::MethodAttributes;
+ use MyApp::Types qw/Int/;
+
+ extends 'Catalyst::Controller';
+
+ sub chain_base :Chained(/) CaptureArgs(1) { }
+
+ sub any_priority_chain :Chained(chain_base) PathPart('') Args(1) { }
+
+ sub int_priority_chain :Chained(chain_base) PathPart('') Args(Int) { }
+
+See L<Catalyst::RouteMatching> for more.
+
+Please see L<Catalyst::DispatchType::Chained> for more.
=head2 ActionClass
the path. However if no Args value is set, assumed to 'slurp' all
remaining path pars under this namespace.
+Allowed values for Args is a single integer (Args(2), meaning two allowed) or you
+can declare a L<Moose>, L<MooseX::Types> or L<Type::Tiny> named constraint such
+as Args(Int,Str) would require two args with the first being a Integer and the
+second a string. You may declare your own custom type constraints and import
+them into the controller namespace:
+
+ package MyApp::Controller::Root;
+
+ use Moose;
+ use MooseX::MethodAttributes;
+ use MyApp::Types qw/Tuple Int Str StrMatch UserId/;
+
+ extends 'Catalyst::Controller';
+
+ sub user :Local Args(UserId) {
+ my ($self, $c, $int) = @_;
+ }
+
+ sub an_int :Local Args(Int) {
+ my ($self, $c, $int) = @_;
+ }
+
+ sub many_ints :Local Args(ArrayRef[Int]) {
+ my ($self, $c, @ints) = @_;
+ }
+
+ sub match :Local Args(StrMatch[qr{\d\d-\d\d-\d\d}]) {
+ my ($self, $c, $int) = @_;
+ }
+
+If you choose not to use imported type constraints (like L<Type::Tiny>, or <MooseX::Types>
+you may use L<Moose> 'stringy' types however just like when you use these types in your
+declared attributes you must quote them:
+
+ sub my_moose_type :Local Args('Int') { ... }
+
+If you use 'reference' type constraints (such as ArrayRef[Int]) that have an unknown
+number of allowed matches, we set this the same way "Args" is. Please keep in mind
+that actions with an undetermined number of args match at lower precedence than those
+with a fixed number. You may use reference types such as Tuple from L<Types::Standard>
+that allows you to fix the number of allowed args. For example Args(Tuple[Int,Int])
+would be determined to be two args (or really the same as Args(Int,Int).) You may
+find this useful for creating custom subtypes with complex matching rules that you
+wish to reuse over many actions.
+
+See L<Catalyst::RouteMatching> for more.
+
+B<Note>: It is highly recommended to use L<Type::Tiny> for your type constraints over
+other options. L<Type::Tiny> exposed a better meta data interface which allows us to
+do more and better types of introspection driving tests and debugging.
+
=head2 Consumes('...')
Matches the current action against the content-type of the request. Typically