package Catalyst::Dispatcher;
use Moose;
+use Class::MOP;
use Catalyst::Exception;
use Catalyst::Utils;
use Tree::Simple::Visitor::FindByPath;
use Scalar::Util ();
-# Stringify to class
-use overload '""' => sub { return ref shift }, fallback => 1;
-
-
+#do these belong as package vars or should we build these via a builder method?
# Preload these action types
our @PRELOAD = qw/Index Path Regex/;
# Postload these action types
our @POSTLOAD = qw/Default/;
-has _tree => (is => 'rw');
-has _dispatch_types => (is => 'rw');
-has _registered_dispatch_types => (is => 'rw');
-has _method_action_class => (is => 'rw');
-has _action_container_class => (is => 'rw');
-has preload_dispatch_types => (is => 'rw', required => 1, lazy => 1, default => sub { [@PRELOAD] });
-has postload_dispatch_types => (is => 'rw', required => 1, lazy => 1, default => sub { [@POSTLOAD] });
-has _action_hash => (is => 'rw', required => 1, lazy => 1, default => sub { {} });
-has _container_hash => (is => 'rw', required => 1, lazy => 1, default => sub { {} });
+has _tree => (is => 'rw');
+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');
+has _action_container_class => (is => 'rw', default => 'Catalyst::ActionContainer');
+
+has preload_dispatch_types => (is => 'rw', required => 1, lazy => 1, default => sub { [@PRELOAD] });
+has postload_dispatch_types => (is => 'rw', required => 1, lazy => 1, default => sub { [@POSTLOAD] });
+has _action_hash => (is => 'rw', required => 1, lazy => 1, default => sub { {} });
+has _container_hash => (is => 'rw', required => 1, lazy => 1, default => sub { {} });
no Moose;
sub BUILD {
my ($self, $params) = @_;
- my $container =
+ my $container =
Catalyst::ActionContainer->new( { part => '/', actions => {} } );
$self->_tree( Tree::Simple->new( $container, Tree::Simple->ROOT ) );
sub dispatch {
my ( $self, $c ) = @_;
- if ( $c->action ) {
- $c->forward( join( '/', '', $c->action->namespace, '_DISPATCH' ) );
+ if ( my $action = $c->action ) {
+ $c->forward( join( '/', '', $action->namespace, '_DISPATCH' ) );
}
else {
}
my @args;
-
+
if ( ref( $extra_params[-1] ) eq 'ARRAY' ) {
@args = @{ pop @extra_params }
} else {
no warnings 'recursion';
- local $c->request->{arguments} = \@args;
+ my $orig_args = $c->request->arguments();
+ $c->request->arguments(\@args);
$action->dispatch( $c );
-
+ $c->request->arguments($orig_args);
+
return $c->state;
}
sub prepare_action {
my ( $self, $c ) = @_;
- my $path = $c->req->path;
- my @path = split /\//, $c->req->path;
- $c->req->args( \my @args );
+ my $req = $c->req;
+ my $path = $req->path;
+ my @path = split /\//, $req->path;
+ $req->args( \my @args );
unshift( @path, '' ); # Root action
unshift @args, $arg;
}
- s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg for grep { defined } @{$c->req->captures||[]};
+ s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg for grep { defined } @{$req->captures||[]};
- $c->log->debug( 'Path is "' . $c->req->match . '"' )
- if ( $c->debug && $c->req->match );
+ $c->log->debug( 'Path is "' . $req->match . '"' )
+ if ( $c->debug && $req->match );
$c->log->debug( 'Arguments are "' . join( '/', @args ) . '"' )
if ( $c->debug && @args );
$namespace = join( "/", grep { length } split '/', $namespace || "" );
- return $self->_action_hash->{"$namespace/$name"};
+ return $self->_action_hash->{"${namespace}/${name}"};
}
=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 ) = @_;
return reverse grep { defined } @containers, $self->_container_hash->{''};
+ #return (split '/', $namespace); # isnt this more clear?
my @parts = split '/', $namespace;
}
my $registered = $self->_registered_dispatch_types;
- my $priv = 0;
+ #my $priv = 0; #seems to be unused
foreach my $key ( keys %{ $action->attributes } ) {
next if $key eq 'Private';
my $class = "Catalyst::DispatchType::$key";
unless ( $registered->{$class} ) {
- eval "require $class";
+ #some error checking rethrowing here wouldn't hurt.
+ eval { Class::MOP::load_class($class) };
push( @{ $self->_dispatch_types }, $class->new ) unless $@;
$registered->{$class} = 1;
}
sub setup_actions {
my ( $self, $c ) = @_;
- $self->_dispatch_types( [] );
- $self->_registered_dispatch_types( {} );
- $self->_method_action_class('Catalyst::Action');
- $self->_action_container_class('Catalyst::ActionContainer');
my @classes =
$self->_load_dispatch_types( @{ $self->preload_dispatch_types } );
for my $type (@types) {
my $class =
( $type =~ /^\+(.*)$/ ) ? $1 : "Catalyst::DispatchType::${type}";
- eval "require $class";
+
+ eval { Class::MOP::load_class($class) };
Catalyst::Exception->throw( message => qq/Couldn't load "$class"/ )
if $@;
push @{ $self->_dispatch_types }, $class->new;
return @loaded;
}
+no Moose;
+__PACKAGE__->meta->make_immutable;
+
=head2 meta
Provided by Moose