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=fb5c9c6ca9662c2bb82db9e2b76e1904f47b89eb;hp=581d03cf5c3f192405e1f242503ddb9709407c97;hb=760d121ecfcc1ad7c28342a6912a472fe30e5fe0;hpb=fbcc39ad23f2bbecf5d84c9ba581e6af86fcd460 diff --git a/lib/Catalyst/Action.pm b/lib/Catalyst/Action.pm index 581d03c..fb5c9c6 100644 --- a/lib/Catalyst/Action.pm +++ b/lib/Catalyst/Action.pm @@ -1,69 +1,226 @@ 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/); +
+ + $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 -See L. +no warnings 'recursion'; -=head1 DESCRIPTION +sub dispatch { # Execute ourselves against a context + my ( $self, $c ) = @_; + return $c->execute( $self->class, $self ); +} -=head1 METHODS +sub execute { + my $self = shift; + $self->code->(@_); +} -=over 4 +sub match_captures { + my ( $self, $c, $captures ) = @_; + ## It would seem that now that we can match captures, we could remove a lot + ## of the capture_args to args mapping all around. I gave it a go, but was + ## not trival, contact jnap on irc for what I tried if you want to try. + ## return $self->_match_has_expected_capture_args($captures) && + return $self->_match_has_expected_http_method($c->req->method); +} -=item code +sub match { + my ( $self, $c ) = @_; + return $self->_match_has_expected_args($c->req->args) && + $self->_match_has_expected_http_method($c->req->method); +} -=item execute +sub _match_has_expected_args { + my ($self, $req_args) = @_; + return 1 unless exists $self->attributes->{Args}; + my $args = $self->attributes->{Args}[0]; + return 1 unless defined($args) && length($args); + return scalar( @{$req_args} ) == $args; +} -=cut +sub _match_has_expected_capture_args { + my ($self, $req_args) = @_; + return 1 unless exists $self->attributes->{CaptureArgs}; + my $args = $self->attributes->{CaptureArgs}[0]; + return 1 unless defined($args) && length($args); + return scalar( @{$req_args} ) == $args; +} -sub execute { # Execute ourselves against a context - my ( $self, $c ) = @_; - return $c->execute( $self->namespace, $self ); +sub _match_has_expected_http_method { + my ($self, $method) = @_; + my @methods = @{ $self->attributes->{Method} || [] }; + if(scalar @methods) { + my $result = scalar(grep { lc($_) eq lc($method) } @methods) ? 1:0; + return $result; + } else { + ## No HTTP Methods to check + return 1; + } } -=item namespace +sub compare { + my ($a1, $a2) = @_; -=item reverse + my ($a1_args) = @{ $a1->attributes->{Args} || [] }; + my ($a2_args) = @{ $a2->attributes->{Args} || [] }; -=item new + $_ = looks_like_number($_) ? $_ : ~0 + for $a1_args, $a2_args; -=cut + return $a1_args <=> $a2_args; +} -sub new { # Dumbass constructor - my ( $class, $attrs ) = @_; - return bless { %{ $attrs || {} } }, $class; +sub number_of_args { + my ( $self ) = @_; + return 0 unless exists $self->attributes->{Args}; + return $self->attributes->{Args}[0]; } -=back +sub number_of_captures { + my ( $self ) = @_; + + return 0 unless exists $self->attributes->{CaptureArgs}; + return $self->attributes->{CaptureArgs}[0] || 0; +} -=head1 AUTHOR +__PACKAGE__->meta->make_immutable; -Matt S. Trout +1; + +__END__ + +=head1 METHODS + +=head2 attributes + +The sub attributes that are set for this action, like Local, Path, Private +and so on. This determines how the action is dispatched to. + +=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 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;