package Catalyst::DispatchType::Chained;
-use strict;
-use base qw/Catalyst::DispatchType/;
+use Moose;
+extends 'Catalyst::DispatchType';
+
+#use strict;
+#use base qw/Catalyst::DispatchType/;
use Text::SimpleTable;
use Catalyst::ActionChain;
use URI;
+has _endpoints => (
+ is => 'rw',
+ isa => 'ArrayRef',
+ required => 1,
+ default => sub{ [] },
+ );
+
+has _actions => (
+ is => 'rw',
+ isa => 'HashRef',
+ required => 1,
+ default => sub{ {} },
+ );
+
+has _children_of => (
+ is => 'rw',
+ isa => 'HashRef',
+ required => 1,
+ default => sub{ {} },
+ );
+
# please don't perltidy this. hairy code within.
=head1 NAME
sub list {
my ( $self, $c ) = @_;
- return unless $self->{endpoints};
+ return unless $self->_endpoints;
my $paths = Text::SimpleTable->new(
[ 35, 'Path Spec' ], [ 36, 'Private' ]
ENDPOINT: foreach my $endpoint (
sort { $a->reverse cmp $b->reverse }
- @{ $self->{endpoints} }
+ @{ $self->_endpoints }
) {
my $args = $endpoint->attributes->{Args}->[0];
my @parts = (defined($args) ? (("*") x $args) : '...');
if (defined $pp->[0] && length $pp->[0]);
}
$parent = $curr->attributes->{Chained}->[0];
- $curr = $self->{actions}{$parent};
+ $curr = $self->_actions->{$parent};
unshift(@parents, $curr) if $curr;
}
next ENDPOINT unless $parent eq '/'; # skip dangling action
$paths->row(@$_) for @rows;
}
- $c->log->debug( "Loaded Path Part actions:\n" . $paths->draw );
+ $c->log->debug( "Loaded Chained actions:\n" . $paths->draw . "\n" );
}
=head2 $self->match( $c, $path )
my @parts = split('/', $path);
- my ($chain, $captures) = $self->recurse_match($c, '/', \@parts);
+ my ($chain, $captures, $parts) = $self->recurse_match($c, '/', \@parts);
+ push @{$c->req->args}, @$parts if $parts && @$parts;
return 0 unless $chain;
sub recurse_match {
my ( $self, $c, $parent, $path_parts ) = @_;
- my $children = $self->{children_of}{$parent};
+ my $children = $self->_children_of->{$parent};
return () unless $children;
+ my $best_action;
my @captures;
TRY: foreach my $try_part (sort { length($b) <=> length($a) }
keys %$children) {
my @try_actions = @{$children->{$try_part}};
TRY_ACTION: foreach my $action (@try_actions) {
if (my $capture_attr = $action->attributes->{CaptureArgs}) {
+
+ # Short-circuit if not enough remaining parts
+ next TRY_ACTION unless @parts >= $capture_attr->[0];
+
my @captures;
my @parts = @parts; # localise
push(@captures, splice(@parts, 0, $capture_attr->[0]));
# try the remaining parts against children of this action
- my ($actions, $captures) = $self->recurse_match(
+ my ($actions, $captures, $action_parts) = $self->recurse_match(
$c, '/'.$action->reverse, \@parts
);
- if ($actions) {
- return [ $action, @$actions ], [ @captures, @$captures ];
+ if ($actions && (!$best_action || $#$action_parts < $#{$best_action->{parts}})){
+ $best_action = {
+ actions => [ $action, @$actions ],
+ captures=> [ @captures, @$captures ],
+ parts => $action_parts
+ };
}
- } else {
+ }
+ else {
{
local $c->req->{arguments} = [ @{$c->req->args}, @parts ];
next TRY_ACTION unless $action->match($c);
}
- push(@{$c->req->args}, @parts);
- return [ $action ], [ ];
+ my $args_attr = $action->attributes->{Args}->[0];
+
+ # No best action currently
+ # OR This one matches with fewer parts left than the current best action,
+ # And therefore is a better match
+ # OR No parts and this expects 0
+ # The current best action might also be Args(0),
+ # but we couldn't chose between then anyway so we'll take the last seen
+
+ if (!$best_action ||
+ @parts < @{$best_action->{parts}} ||
+ (!@parts && $args_attr eq 0)){
+ $best_action = {
+ actions => [ $action ],
+ captures=> [],
+ parts => \@parts
+ }
+ }
}
}
}
+ return @$best_action{qw/actions captures parts/} if $best_action;
return ();
}
if ($parent eq '.') {
$parent = '/'.$action->namespace;
} elsif ($parent !~ m/^\//) {
- $parent = '/'.join('/', $action->namespace, $parent);
+ if ($action->namespace) {
+ $parent = '/'.join('/', $action->namespace, $parent);
+ } else {
+ $parent = '/'.$parent; # special case namespace '' (root)
+ }
}
} else {
$parent = '/'
$action->attributes->{Chained} = [ $parent ];
- my $children = ($self->{children_of}{$parent} ||= {});
+ my $children = ($self->_children_of->{$parent} ||= {});
my @path_part = @{ $action->attributes->{PathPart} || [] };
unshift(@{ $children->{$part} ||= [] }, $action);
- ($self->{actions} ||= {})->{'/'.$action->reverse} = $action;
+ $self->_actions->{'/'.$action->reverse} = $action;
unless ($action->attributes->{CaptureArgs}) {
- unshift(@{ $self->{endpoints} ||= [] }, $action);
+ unshift(@{ $self->_endpoints }, $action);
}
return 1;
my ( $self, $action, $captures ) = @_;
return undef unless ($action->attributes->{Chained}
- && $action->attributes->{Args});
+ && !$action->attributes->{CaptureArgs});
my @parts = ();
my @captures = @$captures;
while ($curr) {
if (my $cap = $curr->attributes->{CaptureArgs}) {
return undef unless @captures >= $cap->[0]; # not enough captures
- unshift(@parts, splice(@captures, -$cap->[0]));
+ if ($cap->[0]) {
+ unshift(@parts, splice(@captures, -$cap->[0]));
+ }
}
if (my $pp = $curr->attributes->{PartPath}) {
unshift(@parts, $pp->[0])
- if (defined $pp->[0] && length $pp->[0]);
+ if (defined($pp->[0]) && length($pp->[0]));
}
$parent = $curr->attributes->{Chained}->[0];
- $curr = $self->{actions}{$parent};
+ $curr = $self->_actions->{$parent};
}
return undef unless $parent eq '/'; # fail for dangling action
return undef if @captures; # fail for too many captures
return join('/', '', @parts);
-
+
}
=head1 USAGE
'-----------------------+------------------------------'
...
-Here's a more detailed specification of the attributes belonging to
+Here's a more detailed specification of the attributes belonging to
C<:Chained>:
=head2 Attributes
Has to be specified for every child in the chain. Possible values are
absolute and relative private action paths, with the relatives pointing
to the current controller, or a single slash C</> to tell Catalyst that
-this is the root of a chain. The attribute C<:Chained> without aguments
+this is the root of a chain. The attribute C<:Chained> without arguments
also defaults to the C</> behavior.
Because you can specify an absolute path to the parent action, it