X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FDispatcher.pm;h=e8e201ea7f3c3b9d952ab6ccf2eb7e8d968b5bba;hb=2eb2c42f2faef472cecd3788573d4872943334b6;hp=29cf4ec68df16f3c87be580fc8387cbf9b0534c4;hpb=66d7ad40942b2eed2c5d12d62a8868431e10cd06;p=catagits%2FCatalyst-Runtime.git diff --git a/lib/Catalyst/Dispatcher.pm b/lib/Catalyst/Dispatcher.pm index 29cf4ec..e8e201e 100644 --- a/lib/Catalyst/Dispatcher.pm +++ b/lib/Catalyst/Dispatcher.pm @@ -8,6 +8,7 @@ use Catalyst::Action; use Catalyst::ActionContainer; use Catalyst::DispatchType::Default; use Catalyst::DispatchType::Index; +use Catalyst::Utils; use Text::SimpleTable; use Tree::Simple; use Tree::Simple::Visitor::FindByPath; @@ -127,17 +128,15 @@ sub dispatch { } } -=head2 $self->forward( $c, $command [, \@arguments ] ) +# $self->_command2action( $c, $command [, \@arguments ] ) +# Search for an action, from the command and returns C<($action, $args)> on +# success. Returns C<(0)> on error. -Documented in L - -=cut - -sub forward { +sub _command2action { my ( $self, $c, $command, @extra_params ) = @_; unless ($command) { - $c->log->debug('Nothing to forward to') if $c->debug; + $c->log->debug('Nothing to go to') if $c->debug; return 0; } @@ -146,21 +145,103 @@ sub forward { if ( ref( $extra_params[-1] ) eq 'ARRAY' ) { @args = @{ pop @extra_params } } else { - # this is a copy, it may take some abuse from ->_invoke_as_path if the path had trailing parts + # this is a copy, it may take some abuse from + # ->_invoke_as_path if the path had trailing parts @args = @{ $c->request->arguments }; } my $action; - # forward to a string path ("/foo/bar/gorch") or action object which stringifies to that - $action = $self->_invoke_as_path( $c, "$command", \@args ); + if (Scalar::Util::blessed($command) && $command->isa('Catalyst::Action')) { + $action = $command; + } + else { + # go to a string path ("/foo/bar/gorch") + # or action object which stringifies to that + $action = $self->_invoke_as_path( $c, "$command", \@args ); + } - # forward to a component ( "MyApp::*::Foo" or $c->component("...") - a path or an object) + # go to a component ( "MyApp::*::Foo" or $c->component("...") + # - a path or an object) unless ($action) { my $method = @extra_params ? $extra_params[0] : "process"; $action = $self->_invoke_as_component( $c, $command, $method ); } + return $action, \@args; +} + +=head2 $self->visit( $c, $command [, \@arguments ] ) + +Documented in L + +=cut + +sub visit { + my $self = shift; + $self->_do_visit('visit', @_); +} + +sub _do_visit { + my $self = shift; + my $opname = shift; + my ( $c, $command ) = @_; + my ( $action, $args ) = $self->_command2action(@_); + my $error = qq/Couldn't $opname("$command"): /; + + if (!$action) { + $error .= qq/Couldn't $opname to command "$command": / + .qq/Invalid action or component./; + } + elsif (!defined $action->namespace) { + $error .= qq/Action has no namespace: cannot $opname() to a plain / + .qq/method or component, must be a :Action or some sort./ + } + elsif (!$action->class->can('_DISPATCH')) { + $error .= qq/Action cannot _DISPATCH. / + .qq/Did you try to $opname() a non-controller action?/; + } + else { + $error = q(); + } + + if($error) { + $c->error($error); + $c->log->debug($error) if $c->debug; + return 0; + } + + $action = $self->expand_action($action); + + local $c->request->{arguments} = $args; + local $c->{namespace} = $action->{'namespace'}; + local $c->{action} = $action; + + $self->dispatch($c); +} + +=head2 $self->go( $c, $command [, \@arguments ] ) + +Documented in L + +=cut + +sub go { + my $self = shift; + $self->_do_visit('go', @_); + die $Catalyst::GO; +} + +=head2 $self->forward( $c, $command [, \@arguments ] ) + +Documented in L + +=cut + +sub forward { + my $self = shift; + my ( $c, $command ) = @_; + my ( $action, $args ) = $self->_command2action(@_); unless ($action) { my $error = @@ -171,9 +252,7 @@ sub forward { return 0; } - #push @$args, @_; - - local $c->request->{arguments} = \@args; + local $c->request->{arguments} = $args; $action->dispatch( $c ); return $c->state; @@ -282,10 +361,10 @@ sub prepare_action { unshift @args, $arg; } - s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg for @{$c->req->captures||[]}; + s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg for grep { defined } @{$c->req->captures||[]}; $c->log->debug( 'Path is "' . $c->req->match . '"' ) - if ( $c->debug && $c->req->match ); + if ( $c->debug && length $c->req->match ); $c->log->debug( 'Arguments are "' . join( '/', @args ) . '"' ) if ( $c->debug && @args ); @@ -301,7 +380,7 @@ sub get_action { my ( $self, $name, $namespace ) = @_; return unless $name; - $namespace = join( "/", grep { length } split '/', $namespace || "" ); + $namespace = join( "/", grep { length } split '/', ( defined $namespace ? $namespace : "" ) ); return $self->action_hash->{"$namespace/$name"}; } @@ -380,6 +459,25 @@ sub uri_for_action { return undef; } +=head2 expand_action + +expand an action into a full representation of the dispatch. +mostly useful for chained, other actions will just return a +single action. + +=cut + +sub expand_action { + my ($self, $action) = @_; + + foreach my $dispatch_type (@{ $self->dispatch_types }) { + my $expanded = $dispatch_type->expand_action($action); + return $expanded if $expanded; + } + + return $action; +} + =head2 $self->register( $c, $action ) Make sure all required dispatch types for this action are loaded, then @@ -473,11 +571,15 @@ sub setup_actions { $self->_load_dispatch_types( @{ $self->postload_dispatch_types } ); return unless $c->debug; + $self->_display_action_tables($c); +} +sub _display_action_tables { + my ($self, $c) = @_; + + my $column_width = Catalyst::Utils::term_width() - 20 - 36 - 12; my $privates = Text::SimpleTable->new( - [ 20, 'Private' ], - [ 36, 'Class' ], - [ 12, 'Method' ] + [ 20, 'Private' ], [ 36, 'Class' ], [ $column_width, 'Method' ] ); my $has_private = 0; @@ -500,8 +602,8 @@ sub setup_actions { }; $walker->( $walker, $self->tree, '' ); - $c->log->debug( "Loaded Private actions:\n" . $privates->draw ) - if ($has_private); + $c->log->debug( "Loaded Private actions:\n" . $privates->draw . "\n" ) + if $has_private; # List all public actions $_->list($c) for @{ $self->dispatch_types }; @@ -527,10 +629,23 @@ sub _load_dispatch_types { return @loaded; } -=head1 AUTHOR +# Dont document this until someone else is happy with beaviour. Ash 2009/03/16 +sub dispatch_type { + my ($self, $name) = @_; + + unless ($name =~ s/^\+//) { + $name = "Catalyst::DispatchType::" . $name; + } + + for (@{ $self->dispatch_types }) { + return $_ if ref($_) eq $name; + } + return undef; +} + +=head1 AUTHORS -Sebastian Riedel, C -Matt S Trout, C +Catalyst Contributors, see Catalyst.pm =head1 COPYRIGHT