my ( $self, $c ) = @_;
if ( $c->action ) {
- $c->forward( join('/', '', $c->namespace, '_DISPATCH') );
+ $c->forward( join( '/', '', $c->namespace, '_DISPATCH' ) );
}
else {
my $arguments = ( ref( $_[-1] ) eq 'ARRAY' ) ? pop(@_) : $c->req->args;
- my $results = [];
+ my $result;
my $command_copy = $command;
}
unless ( $command_copy =~ /\// ) {
- $results = $c->get_action( $command_copy, '/' );
+ $result = $c->get_action( $command_copy, '/' );
}
else {
my @extra_args;
DESCEND: while ( $command_copy =~ s/^(.*)\/(\w+)$/$1/ ) {
my $tail = $2;
- $results = $c->get_action( $tail, $1 );
- if ( @{$results} ) {
+ $result = $c->get_action( $tail, $1 );
+ if ( $result ) {
$command = $tail;
push( @{$arguments}, @extra_args );
last DESCEND;
}
}
- unless ( @{$results} ) {
+ unless ( $result ) {
unless ( $c->components->{$command} ) {
my $error =
namespace => $class,
}
);
- $results = [ [$action] ];
+ $result = $action;
}
else {
local $c->request->{arguments} = [ @{$arguments} ];
- for my $result ( @{$results} ) {
- $result->[0]->execute($c);
- return if scalar @{ $c->error };
- last unless $c->state;
- }
+ $result->execute($c);
return $c->state;
}
if ( $c->debug && @args );
}
-=item $self->get_action( $c, $action, $namespace, $inherit )
+=item $self->get_action( $c, $action, $namespace )
=cut
sub get_action {
- my ( $self, $c, $action, $namespace, $inherit ) = @_;
- return [] unless $action;
+ my ( $self, $c, $name, $namespace ) = @_;
+ return unless $name;
$namespace ||= '';
$namespace = '' if $namespace eq '/';
- $inherit ||= 0;
my @match = $self->get_containers($namespace);
- if ($inherit) { # Return [ [ $act_obj ], ... ] for valid containers
- return [
- map { [ $_->{$action} ] } # Make [ $action_obj ]
- grep { defined $_->{$action} } # If it exists in the container
- map { $_->actions } # Get action hash for container
- @match
- ];
- }
- else {
- my $node = $match[-1]->actions; # Only bother looking at the last one
+ return unless @match;
- if ( defined $node->{$action}
- && ( $node->{$action}->namespace eq $namespace ) )
- {
- return [ [ $node->{$action} ] ];
- }
- else {
- return [];
- }
+ if ( my $action = $match[-1]->get_action( $c, $name ) )
+ {
+ return $action if $action->namespace eq $namespace;
}
}
+=item $self->get_actions( $c, $action, $namespace )
+
+=cut
+
+sub get_actions {
+ my ( $self, $c, $action, $namespace ) = @_;
+ return [] unless $action;
+ $namespace ||= '';
+ $namespace = '' if $namespace eq '/';
+
+ my @match = $self->get_containers($namespace);
+
+ return map { $_->get_action($c, $action) } @match;
+}
+
=item $self->get_containers( $namespace )
=cut
}
return unless keys %attributes;
- my $parent = $self->tree;
- my $visitor = Tree::Simple::Visitor::FindByPath->new;
+ my $reverse = $namespace ? "$namespace/$method" : $method;
+
+ my $action = Catalyst::Action->new(
+ {
+ name => $method,
+ code => $code,
+ reverse => $reverse,
+ namespace => $namespace,
+ class => $class,
+ attributes => \%attributes,
+ }
+ );
+
+ $self->register($c, $action);
+}
+
+sub register {
+ my ( $self, $c, $action ) = @_;
+
+ my $namespace = $action->namespace;
+ my $parent = $self->tree;
+ my $visitor = Tree::Simple::Visitor::FindByPath->new;
if ($namespace) {
for my $part ( split '/', $namespace ) {
}
}
- my $reverse = $namespace ? "$namespace/$method" : $method;
-
- my $action = Catalyst::Action->new(
- {
- name => $method,
- code => $code,
- reverse => $reverse,
- namespace => $namespace,
- class => $class,
- attributes => \%attributes,
- }
- );
-
# Set the method value
- $parent->getNodeValue->actions->{$method} = $action;
+ $parent->getNodeValue->actions->{$action->name} = $action;
# Pass the action to our dispatch types so they can register it if reqd.
foreach my $type ( @{ $self->dispatch_types } ) {
for my $action ( keys %{$node} ) {
my $action_obj = $node->{$action};
+ next
+ if ( ( $action =~ /^_.*/ )
+ && ( !$c->config->{show_internal_actions} ) );
$privates->addRow( "$prefix$action", $action_obj->class );
}