change forward/detach to work with instances

[catagits/Catalyst-Runtime.git] / lib / Catalyst / Dispatcher.pm

diff --git a/lib/Catalyst/Dispatcher.pm b/lib/Catalyst/Dispatcher.pm
index 12040b2..7a31c77 100644 (file)
--- a/lib/Catalyst/Dispatcher.pm
+++ b/lib/Catalyst/Dispatcher.pm
@@ -13,7 +13,6 @@ use Catalyst::DispatchType::Index;
 use Catalyst::Utils;
 use Text::SimpleTable;
 use Tree::Simple;
-use Tree::Simple::Visitor::FindByPath;
 use Class::Load qw(load_class try_load_class);
 use Encode 2.21 'decode_utf8';
 
@@ -239,7 +238,7 @@ Documented in L<Catalyst>
 sub forward {
     my $self = shift;
     no warnings 'recursion';
-    $self->_do_forward(forward => @_);
+    return $self->_do_forward(forward => @_);
 }
 
 sub _do_forward {
@@ -261,6 +260,12 @@ sub _do_forward {
     no warnings 'recursion';
     $action->dispatch( $c );
 
+    #If there is an error, all bets off regarding state.  Documentation
+    #Specifies that when you forward, if there's an error you must expect
+    #state to be 0.
+    if( @{ $c->error }) {
+      $c->state(0);
+    }
     return $c->state;
 }
 
@@ -273,6 +278,7 @@ Documented in L<Catalyst>
 sub detach {
     my ( $self, $c, $command, @args ) = @_;
     $self->_do_forward(detach => $c, $command, @args ) if $command;
+    $c->state(0); # Needed in order to skip any auto functions
     Catalyst::Exception::Detach->throw;
 }
 
@@ -322,37 +328,39 @@ sub _find_component {
 }
 
 sub _invoke_as_component {
-    my ( $self, $c, $component_or_class, $method ) = @_;
-
-    my $component = $self->_find_component($c, $component_or_class);
-    my $component_class = blessed $component || return 0;
-
-    if (my $code = $component_class->can('action_for')) {
-        my $possible_action = $component->$code($method);
-        return $possible_action if $possible_action;
-    }
-
-    if ( my $code = $component_class->can($method) ) {
-        return $self->_method_action_class->new(
-            {
-                name      => $method,
-                code      => $code,
-                reverse   => "$component_class->$method",
-                class     => $component_class,
-                namespace => Catalyst::Utils::class2prefix(
-                    $component_class, ref($c)->config->{case_sensitive}
-                ),
-            }
-        );
-    }
-    else {
-        my $error =
-          qq/Couldn't forward to "$component_class". Does not implement "$method"/;
-        $c->error($error);
-        $c->log->debug($error)
-          if $c->debug;
-        return 0;
-    }
+  my ( $self, $c, $component_or_class, $method ) = @_;
+
+  my $component = $self->_find_component($c, $component_or_class);
+  my $component_class = blessed $component || return 0;
+
+  if (my $code = $component_class->can('action_for')) {
+      my $possible_action = $component->$code($method);
+      return $possible_action if $possible_action;
+  }
+
+  my $component_to_call = blessed($component_or_class) ? $component_or_class : $component_class;
+
+  if ( my $code = $component_to_call->can($method) ) {
+      return $self->_method_action_class->new(
+          {
+              name      => $method,
+              code      => $code,
+              reverse   => "$component_class->$method",
+              class     => $component_to_call,
+              namespace => Catalyst::Utils::class2prefix(
+                  $component_class, ref($c)->config->{case_sensitive}
+              ),
+          }
+      );
+  }
+  else {
+      my $error =
+        qq/Couldn't forward to "$component_class". Does not implement "$method"/;
+      $c->error($error);
+      $c->log->debug($error)
+        if $c->debug;
+      return 0;
+  }
 }
 
 =head2 $self->prepare_action($c)
@@ -400,9 +408,14 @@ sub prepare_action {
       if ( $c->debug && @args );
 }
 
-=head2 $self->get_action( $action, $namespace )
+=head2 $self->get_action( $action_name, $namespace )
 
-returns a named action from a given namespace.
+returns a named action from a given namespace.  C<$action_name>
+may be a relative path on that C<$namespace> such as
+
+    $self->get_action('../bar', 'foo/baz');
+
+In which case we look for the action at 'foo/bar'.
 
 =cut
 
@@ -412,17 +425,22 @@ sub get_action {
 
     $namespace = join( "/", grep { length } split '/', ( defined $namespace ? $namespace : "" ) );
 
-    return $self->_action_hash->{"${namespace}/${name}"};
+    return $self->get_action_by_path("${namespace}/${name}");
 }
 
 =head2 $self->get_action_by_path( $path );
 
 Returns the named action by its full private path.
 
+This method performs some normalization on C<$path> so that if
+it includes '..' it will do the right thing (for example if
+C<$path> is '/foo/../bar' that is normalized to '/bar'.
+
 =cut
 
 sub get_action_by_path {
     my ( $self, $path ) = @_;
+    $path =~s/[^\/]+\/\.\.\/// while $path=~m/[^\/]+\/\.\.\//;
     $path =~ s/^\///;
     $path = "/$path" unless $path =~ /\//;
     $self->_action_hash->{$path};
@@ -613,7 +631,8 @@ sub setup_actions {
       $self->_load_dispatch_types( @{ $self->preload_dispatch_types } );
     @{ $self->_registered_dispatch_types }{@classes} = (1) x @classes;
 
-    foreach my $comp ( values %{ $c->components } ) {
+    foreach my $comp ( map @{$_}{sort keys %$_}, $c->components ) {
+        $comp = $comp->() if ref($comp) eq 'CODE';
         $comp->register_actions($c) if $comp->can('register_actions');
     }