X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=catagits%2FCatalyst-Runtime.git;a=blobdiff_plain;f=lib%2FCatalyst%2FAction.pm;h=881c120e8dbd126fec459affddbc88704e51583a;hp=649ea78160109da8936061fa6af6fd11acb10ef4;hb=342d21698a97962c51114b6ebc6bb8626511cfc6;hpb=cfd04b0cabf99346090fe4e3312e393364e571ef diff --git a/lib/Catalyst/Action.pm b/lib/Catalyst/Action.pm index 649ea78..881c120 100644 --- a/lib/Catalyst/Action.pm +++ b/lib/Catalyst/Action.pm @@ -1,69 +1,216 @@ package Catalyst::Action; -use strict; -use base qw/Class::Accessor::Fast/; +=head1 NAME + +Catalyst::Action - Catalyst Action + +=head1 SYNOPSIS -__PACKAGE__->mk_accessors(qw/code namespace reverse prefix/); +
+ + $c->forward( $action->private_path ); + +=head1 DESCRIPTION + +This class represents a Catalyst Action. You can access the object for the +currently dispatched action via $c->action. See the L +for more information on how actions are dispatched. Actions are defined in +L subclasses. + +=cut + +use Moose; +use Scalar::Util 'looks_like_number'; +with 'MooseX::Emulate::Class::Accessor::Fast'; +use namespace::clean -except => 'meta'; + +has class => (is => 'rw'); +has namespace => (is => 'rw'); +has 'reverse' => (is => 'rw'); +has attributes => (is => 'rw'); +has name => (is => 'rw'); +has code => (is => 'rw'); +has private_path => ( + reader => 'private_path', + isa => 'Str', + lazy => 1, + required => 1, + default => sub { '/'.shift->reverse }, +); use overload ( # Stringify to reverse for debug output etc. q{""} => sub { shift->{reverse} }, - # Codulate to encapsulated action coderef - '&{}' => sub { shift->{code} }, + # Codulate to execute to invoke the encapsulated action coderef + '&{}' => sub { my $self = shift; sub { $self->execute(@_); }; }, + + # Make general $stuff still work + fallback => 1, ); -=head1 NAME -Catalyst::Action - Catalyst Action -=head1 SYNOPSIS +no warnings 'recursion'; -See L. +sub dispatch { # Execute ourselves against a context + my ( $self, $c ) = @_; + return $c->execute( $self->class, $self ); +} -=head1 DESCRIPTION +sub execute { + my $self = shift; + $self->code->(@_); +} -=head1 METHODS +sub match { + my ( $self, $c ) = @_; + #would it be unreasonable to store the number of arguments + #the action has as its own attribute? + #it would basically eliminate the code below. ehhh. small fish + return 1 unless exists $self->attributes->{Args}; + my $args = $self->attributes->{Args}[0]; + return 1 unless defined($args) && length($args); + return scalar( @{ $c->req->args } ) == $args; +} -=over 4 +sub match_captures { 1 } -=item code +sub compare { + my ($a1, $a2) = @_; -=item execute + my ($a1_args) = @{ $a1->attributes->{Args} || [] }; + my ($a2_args) = @{ $a2->attributes->{Args} || [] }; -=cut + $_ = looks_like_number($_) ? $_ : ~0 + for $a1_args, $a2_args; -sub execute { # Execute ourselves against a context - my ( $self, $c ) = @_; - return $c->execute( $self->namespace, $self ); + return $a1_args <=> $a2_args; } -=item namespace - -=item reverse +sub number_of_args { + my ( $self ) = @_; + return 0 unless exists $self->attributes->{Args}; + return $self->attributes->{Args}[0]; +} -=item new +sub number_of_captures { + my ( $self ) = @_; -=cut + return 0 unless exists $self->attributes->{CaptureArgs}; + return $self->attributes->{CaptureArgs}[0] || 0; +} -sub new { # Dumbass constructor - my ( $class, $attrs ) = @_; - return bless { %{ $attrs || {} } }, $class; +sub scheme { + return exists $_[0]->attributes->{Scheme} ? $_[0]->attributes->{Scheme}[0] : undef; } -=back +sub list_extra_info { + my $self = shift; + return { + Args => $self->attributes->{Args}[0], + CaptureArgs => $self->number_of_captures, + } +} + +__PACKAGE__->meta->make_immutable; + +1; + +__END__ + +=head1 METHODS + +=head2 attributes -=head1 AUTHOR +The sub attributes that are set for this action, like Local, Path, Private +and so on. This determines how the action is dispatched to. -Matt S. Trout +=head2 class + +Returns the name of the component where this action is defined. +Derived by calling the L +method on each component. + +=head2 code + +Returns a code reference to this action. + +=head2 dispatch( $c ) + +Dispatch this action against a context. + +=head2 execute( $controller, $c, @args ) + +Execute this action's coderef against a given controller with a given +context and arguments + +=head2 match( $c ) + +Check Args attribute, and makes sure number of args matches the setting. +Always returns true if Args is omitted. + +=head2 match_captures ($c, $captures) + +Can be implemented by action class and action role authors. If the method +exists, then it will be called with the request context and an array reference +of the captures for this action. + +Returning true from this method causes the chain match to continue, returning +makes the chain not match (and alternate, less preferred chains will be attempted). + + +=head2 compare + +Compares 2 actions based on the value of the C attribute, with no C +having the highest precedence. + +=head2 namespace + +Returns the private namespace this action lives in. + +=head2 reverse + +Returns the private path for this action. + +=head2 private_path + +Returns absolute private path for this action. Unlike C, the +C of an action is always suitable for passing to C. + +=head2 name + +Returns the sub name of this action. + +=head2 number_of_args + +Returns the number of args this action expects. This is 0 if the action doesn't take any arguments and undef if it will take any number of arguments. + +=head2 number_of_captures + +Returns the number of captures this action expects for L actions. + +=head2 list_extra_info + +A HashRef of key-values that an action can provide to a debugging screen + +=head2 scheme + +Any defined scheme for the action + +=head2 meta + +Provided by Moose. + +=head1 AUTHORS + +Catalyst Contributors, see Catalyst.pm =head1 COPYRIGHT -This program is free software, you can redistribute it and/or modify it under +This library is free software. You can redistribute it and/or modify it under the same terms as Perl itself. =cut - -1;