use Tree::Simple;
use Tree::Simple::Visitor::FindByPath;
+use namespace::clean -except => 'meta';
+
# Refactoring note:
# do these belong as package vars or should we build these via a builder method?
# See Catalyst-Plugin-Server for them being added to, which should be much less ugly.
our @POSTLOAD = qw/Default/;
# Note - see back-compat methods at end of file.
-has _tree => (is => 'rw');
+has _tree => (is => 'rw', builder => '_build__tree');
has _dispatch_types => (is => 'rw', default => sub { [] }, required => 1, lazy => 1);
has _registered_dispatch_types => (is => 'rw', default => sub { {} }, required => 1, lazy => 1);
has _method_action_class => (is => 'rw', default => 'Catalyst::Action');
return $self->$orig(@_);
};
-no Moose;
-
=head1 NAME
Catalyst::Dispatcher - The Catalyst Dispatcher
=head1 METHODS
-=head2 new
+=head2 new
Construct a new dispatcher.
=cut
-sub BUILD {
- my ($self, $params) = @_;
+sub _build__tree {
+ my ($self) = @_;
my $container =
Catalyst::ActionContainer->new( { part => '/', actions => {} } );
- $self->_tree( Tree::Simple->new( $container, Tree::Simple->ROOT ) );
+ return Tree::Simple->new($container, Tree::Simple->ROOT);
}
=head2 $self->preload_dispatch_types
}
# $self->_command2action( $c, $command [, \@arguments ] )
-# Search for an action, from the command and returns C<($action, $args)> on
+# $self->_command2action( $c, $command [, \@captures, \@arguments ] )
+# Search for an action, from the command and returns C<($action, $args, $captures)> on
# success. Returns C<(0)> on error.
sub _command2action {
return 0;
}
- my @args;
+ my (@args, @captures);
+
+ if ( ref( $extra_params[-2] ) eq 'ARRAY' ) {
+ @captures = @{ pop @extra_params };
+ }
if ( ref( $extra_params[-1] ) eq 'ARRAY' ) {
@args = @{ pop @extra_params }
$action = $self->_invoke_as_component( $c, $command, $method );
}
- return $action, \@args;
+ return $action, \@args, \@captures;
}
=head2 $self->visit( $c, $command [, \@arguments ] )
my $self = shift;
my $opname = shift;
my ( $c, $command ) = @_;
- my ( $action, $args ) = $self->_command2action(@_);
+ my ( $action, $args, $captures ) = $self->_command2action(@_);
my $error = qq/Couldn't $opname("$command"): /;
if (!$action) {
}
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./
+ .qq/method or component, must be an :Action of some sort./
}
elsif (!$action->class->can('_DISPATCH')) {
$error .= qq/Action cannot _DISPATCH. /
$action = $self->expand_action($action);
local $c->request->{arguments} = $args;
+ local $c->request->{captures} = $captures;
local $c->{namespace} = $action->{'namespace'};
local $c->{action} = $action;
sub forward {
my $self = shift;
+ no warnings 'recursion';
$self->_do_forward(forward => @_);
}
my $self = shift;
my $opname = shift;
my ( $c, $command ) = @_;
- my ( $action, $args ) = $self->_command2action(@_);
+ my ( $action, $args, $captures ) = $self->_command2action(@_);
if (!$action) {
my $error .= qq/Couldn't $opname to command "$command": /
return 0;
}
- no warnings 'recursion';
local $c->request->{arguments} = $args;
+ no warnings 'recursion';
$action->dispatch( $c );
return $c->state;
}
}
-sub _find_component_class {
+sub _find_component {
my ( $self, $c, $component ) = @_;
- return ref($component)
- || ref( $c->component($component) )
- || $c->component($component);
+ # fugly, why doesn't ->component('MyApp') work?
+ return $c if ($component eq blessed($c));
+
+ return blessed($component)
+ ? $component
+ : $c->component($component);
}
sub _invoke_as_component {
- my ( $self, $c, $component, $method ) = @_;
+ my ( $self, $c, $component_or_class, $method ) = @_;
+
+ my $component = $self->_find_component($c, $component_or_class);
+ my $component_class = blessed $component || return 0;
- my $class = $self->_find_component_class( $c, $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 = $class->can($method) ) {
+ if ( my $code = $component_class->can($method) ) {
return $self->_method_action_class->new(
{
name => $method,
code => $code,
- reverse => "$class->$method",
- class => $class,
+ reverse => "$component_class->$method",
+ class => $component_class,
namespace => Catalyst::Utils::class2prefix(
- $class, $c->config->{case_sensitive}
+ $component_class, $c->config->{case_sensitive}
),
}
);
}
else {
my $error =
- qq/Couldn't forward to "$class". Does not implement "$method"/;
+ qq/Couldn't forward to "$component_class". Does not implement "$method"/;
$c->error($error);
$c->log->debug($error)
if $c->debug;
DESCEND: while (@path) {
$path = join '/', @path;
- $path =~ s#^/##;
-
- $path = '' if $path eq '/'; # Root action
+ $path =~ s#^/+##;
# Check out dispatch types to see if any will handle the path at
# this level
return $self->_action_hash->{"${namespace}/${name}"};
}
-=head2 $self->get_action_by_path( $path );
+=head2 $self->get_action_by_path( $path );
-Returns the named action by its full path.
+Returns the named action by its full private path.
=cut
}
return reverse grep { defined } @containers, $self->_container_hash->{''};
-
- #return (split '/', $namespace); # isnt this more clear?
- my @parts = split '/', $namespace;
}
=head2 $self->uri_for_action($action, \@captures)
}
}
+ my @dtypes = @{ $self->_dispatch_types };
+ my @normal_dtypes;
+ my @low_precedence_dtypes;
+
+ for my $type ( @dtypes ) {
+ if ($type->isa('Catalyst::DispatchType::Index') ||
+ $type->isa('Catalyst::DispatchType::Default')) {
+ push @low_precedence_dtypes, $type;
+ } else {
+ push @normal_dtypes, $type;
+ }
+ }
+
# Pass the action to our dispatch types so they can register it if reqd.
- foreach my $type ( @{ $self->_dispatch_types } ) {
- $type->register( $c, $action );
+ my $was_registered = 0;
+ foreach my $type ( @normal_dtypes ) {
+ $was_registered = 1 if $type->register( $c, $action );
+ }
+
+ if (not $was_registered) {
+ foreach my $type ( @low_precedence_dtypes ) {
+ $type->register( $c, $action );
+ }
}
my $namespace = $action->namespace;
return @loaded;
}
-# Dont document this until someone else is happy with beaviour. Ash 2009/03/16
+=head2 $self->dispatch_type( $type )
+
+Get the DispatchType object of the relevant type, i.e. passing C<$type> of
+C<Chained> would return a L<Catalyst::DispatchType::Chained> object (assuming
+of course it's being used.)
+
+=cut
+
sub dispatch_type {
my ($self, $name) = @_;
# See also t/lib/TestApp/Plugin/AddDispatchTypes.pm
# Alias _method_name to method_name, add a before modifier to warn..
-foreach my $public_method_name (qw/
- tree
- dispatch_types
- registered_dispatch_types
- method_action_class
- action_hash
+foreach my $public_method_name (qw/
+ tree
+ dispatch_types
+ registered_dispatch_types
+ method_action_class
+ action_hash
container_hash
/) {
my $private_method_name = '_' . $public_method_name;
my %package_hash; # Only warn once per method, per package. These are infrequent enough that
# I haven't provided a way to disable them, patches welcome.
$meta->add_before_method_modifier($public_method_name, sub {
- my $class = blessed(shift);
- $package_hash{$class}++ || do {
- warn("Class $class is calling the deprecated method Catalyst::Dispatcher::$public_method_name,\n"
- . "this will be removed in Catalyst 5.9X");
+ my $class = caller(2);
+ chomp($class);
+ $package_hash{$class}++ || do {
+ warn("Class $class is calling the deprecated method\n"
+ . " Catalyst::Dispatcher::$public_method_name,\n"
+ . " this will be removed in Catalyst 5.9X\n");
};
});
}
}
# End 5.70 backwards compatibility hacks.
-no Moose;
__PACKAGE__->meta->make_immutable;
=head2 meta
=head1 COPYRIGHT
-This program is free software, you can redistribute it and/or modify it under
+This library is free software. You can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
projects / catagits/Catalyst-Runtime.git / blobdiff