X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FDispatcher.pm;h=0f341defb663c2a43cca94a2d57db16839a61a22;hb=bfdaffa8cfd20d905dc451b05505d0ad8d476bea;hp=c4e4dd09a71c42df415fcccd1b50865cc871b7a8;hpb=7f23827ba42e87b4bf1f52d37534f3229a7f594d;p=catagits%2FCatalyst-Runtime.git

diff --git a/lib/Catalyst/Dispatcher.pm b/lib/Catalyst/Dispatcher.pm
index c4e4dd0..0f341de 100644
--- a/lib/Catalyst/Dispatcher.pm
+++ b/lib/Catalyst/Dispatcher.pm
@@ -11,6 +11,7 @@ use Catalyst::DispatchType::Index;
 use Text::SimpleTable;
 use Tree::Simple;
 use Tree::Simple::Visitor::FindByPath;
+use Scalar::Util ();
 
 # Stringify to class
 use overload '""' => sub { return ref shift }, fallback => 1;
@@ -126,26 +127,54 @@ 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<Catalyst>
-
-=cut
-
-sub forward {
-    my ( $self, $c, $command ) = splice( @_, 0, 3 );
+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;
     }
 
-    my $args = [ @{ $c->request->arguments } ];
+    my @args;
+    
+    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
+        @args = @{ $c->request->arguments };
+    }
 
-    @$args = @{ pop @_ } if ( ref( $_[-1] ) eq 'ARRAY' );
+    my $action;
 
-    my $action = $self->_invoke_as_path( $c, $command, $args )
-      || $self->_invoke_as_component( $c, $command, shift );
+    # go to a string path ("/foo/bar/gorch")
+    # or action object which stringifies to that
+    $action = $self->_invoke_as_path( $c, "$command", \@args );
+
+    # 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->forward( $c, $command [, \@arguments ] )
+
+Documented in L<Catalyst>
+
+=cut
+
+sub forward {
+    my $self = shift;
+    my ( $c, $command ) = @_;
+    my ( $action, $args ) = $self->_command2action(@_);
 
     unless ($action) {
         my $error =
@@ -156,10 +185,8 @@ sub forward {
         return 0;
     }
 
-    #push @$args, @_;
-
     local $c->request->{arguments} = $args;
-    $action->execute($c);
+    $action->dispatch( $c );
 
     return $c->state;
 }
@@ -179,8 +206,6 @@ sub _action_rel2abs {
 sub _invoke_as_path {
     my ( $self, $c, $rel_path, $args ) = @_;
 
-    return if ref $rel_path;    # it must be a string
-
     my $path = $self->_action_rel2abs( $c, $rel_path );
 
     my ( $tail, @extra_args );
@@ -212,7 +237,6 @@ sub _invoke_as_component {
     my ( $self, $c, $component, $method ) = @_;
 
     my $class = $self->_find_component_class( $c, $component ) || return 0;
-    $method ||= "process";
 
     if ( my $code = $class->can($method) ) {
         return $self->method_action_class->new(
@@ -270,8 +294,10 @@ sub prepare_action {
         unshift @args, $arg;
     }
 
+    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 );
@@ -287,19 +313,20 @@ 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"};
 }
 
-=head2 $self->get_action_by_path( $path );
-
-returns the named action by it's full path.
+=head2 $self->get_action_by_path( $path ); 
+   
+Returns the named action by its full path. 
 
-=cut
+=cut 
 
 sub get_action_by_path {
     my ( $self, $path ) = @_;
+    $path =~ s/^\///;
     $path = "/$path" unless $path =~ /\//;
     $self->action_hash->{$path};
 }
@@ -343,6 +370,28 @@ sub get_containers {
     my @parts = split '/', $namespace;
 }
 
+=head2 $self->uri_for_action($action, \@captures)
+
+Takes a Catalyst::Action object and action parameters and returns a URI
+part such that if $c->req->path were this URI part, this action would be
+dispatched to with $c->req->captures set to the supplied arrayref.
+
+If the action object is not available for external dispatch or the dispatcher
+cannot determine an appropriate URI, this method will return undef.
+
+=cut
+
+sub uri_for_action {
+    my ( $self, $action, $captures) = @_;
+    $captures ||= [];
+    foreach my $dispatch_type ( @{ $self->dispatch_types } ) {
+        my $uri = $dispatch_type->uri_for_action( $action, $captures );
+        return( $uri eq '' ? '/' : $uri )
+            if defined($uri);
+    }
+    return undef;
+}
+
 =head2 $self->register( $c, $action )
 
 Make sure all required dispatch types for this action are loaded, then
@@ -358,7 +407,7 @@ sub register {
 
     my $priv = 0;
     foreach my $key ( keys %{ $action->attributes } ) {
-        $priv++ if $key eq 'Private';
+        next if $key eq 'Private';
         my $class = "Catalyst::DispatchType::$key";
         unless ( $registered->{$class} ) {
             eval "require $class";
@@ -368,17 +417,14 @@ sub register {
     }
 
     # Pass the action to our dispatch types so they can register it if reqd.
-    my $reg = 0;
     foreach my $type ( @{ $self->dispatch_types } ) {
-        $reg++ if $type->register( $c, $action );
+        $type->register( $c, $action );
     }
 
-    return unless $reg + $priv;
-
     my $namespace = $action->namespace;
     my $name      = $action->name;
 
-    my $container = $self->find_or_create_action_container($namespace);
+    my $container = $self->_find_or_create_action_container($namespace);
 
     # Set the method value
     $container->add_action($action);
@@ -387,7 +433,7 @@ sub register {
     $self->container_hash->{$namespace} = $container;
 }
 
-sub find_or_create_action_container {
+sub _find_or_create_action_container {
     my ( $self, $namespace ) = @_;
 
     my $tree ||= $self->tree;
@@ -429,20 +475,20 @@ sub setup_actions {
     $self->action_container_class('Catalyst::ActionContainer');
 
     my @classes =
-      $self->do_load_dispatch_types( @{ $self->preload_dispatch_types } );
+      $self->_load_dispatch_types( @{ $self->preload_dispatch_types } );
     @{ $self->registered_dispatch_types }{@classes} = (1) x @classes;
 
     foreach my $comp ( values %{ $c->components } ) {
         $comp->register_actions($c) if $comp->can('register_actions');
     }
 
-    $self->do_load_dispatch_types( @{ $self->postload_dispatch_types } );
+    $self->_load_dispatch_types( @{ $self->postload_dispatch_types } );
 
     return unless $c->debug;
 
     my $privates = Text::SimpleTable->new(
         [ 20, 'Private' ],
-        [ 38, 'Class' ],
+        [ 36, 'Class' ],
         [ 12, 'Method' ]
     );
 
@@ -466,14 +512,14 @@ 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 };
 }
 
-sub do_load_dispatch_types {
+sub _load_dispatch_types {
     my ( $self, @types ) = @_;
 
     my @loaded;
@@ -493,10 +539,9 @@ sub do_load_dispatch_types {
     return @loaded;
 }
 
-=head1 AUTHOR
+=head1 AUTHORS
 
-Sebastian Riedel, C<sri@cpan.org>
-Matt S Trout, C<mst@shadowcatsystems.co.uk>
+Catalyst Contributors, see Catalyst.pm
 
 =head1 COPYRIGHT