X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=catagits%2FCatalyst-Runtime.git;a=blobdiff_plain;f=lib%2FCatalyst%2FDispatcher.pm;h=5df4526e51baf131890f1e52ac37320f250a82bd;hp=91ae6fc8ddf21671d95203857f78178efc2ad857;hb=17b3d80076b6acb25d56ed83b0ed7134ed4fb343;hpb=52f71256fa6baba38de781b3074884ff0d12769f diff --git a/lib/Catalyst/Dispatcher.pm b/lib/Catalyst/Dispatcher.pm index 91ae6fc..5df4526 100644 --- a/lib/Catalyst/Dispatcher.pm +++ b/lib/Catalyst/Dispatcher.pm @@ -2,6 +2,7 @@ package Catalyst::Dispatcher; use Moose; use Class::MOP; +with 'MooseX::Emulate::Class::Accessor::Fast'; use Catalyst::Exception; use Catalyst::Utils; @@ -9,30 +10,41 @@ use Catalyst::Action; use Catalyst::ActionContainer; use Catalyst::DispatchType::Default; use Catalyst::DispatchType::Index; +use Catalyst::Utils; use Text::SimpleTable; use Tree::Simple; use Tree::Simple::Visitor::FindByPath; -use Scalar::Util (); -#do these belong as package vars or should we build these via a builder method? +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. + # Preload these action types our @PRELOAD = qw/Index Path Regex/; # Postload these action types our @POSTLOAD = qw/Default/; -has _tree => (is => 'rw'); +# Note - see back-compat methods at end of file. +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'); -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 { {} }); +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] }); -no Moose; +# Wrap accessors so you can assign a list and it will capture a list ref. +around qw/preload_dispatch_types postload_dispatch_types/ => sub { + my $orig = shift; + my $self = shift; + return $self->$orig([@_]) if (scalar @_ && ref $_[0] ne 'ARRAY'); + return $self->$orig(@_); +}; =head1 NAME @@ -55,13 +67,13 @@ 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 @@ -84,24 +96,11 @@ it with a C<+>, like so: +My::Dispatch::Type -=head2 $self->detach( $c, $command [, \@arguments ] ) - -Documented in L - -=cut - -sub detach { - my ( $self, $c, $command, @args ) = @_; - $c->forward( $command, @args ) if $command; - die $Catalyst::DETACH; -} - =head2 $self->dispatch($c) Delegate the dispatch to the action that matched the url, or return a message about unknown resource - =cut sub dispatch { @@ -109,7 +108,6 @@ sub dispatch { if ( my $action = $c->action ) { $c->forward( join( '/', '', $action->namespace, '_DISPATCH' ) ); } - else { my $path = $c->req->path; my $error = $path @@ -121,7 +119,8 @@ sub dispatch { } # $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 { @@ -132,7 +131,11 @@ 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 } @@ -145,8 +148,13 @@ sub _command2action { my $action; # go to a string path ("/foo/bar/gorch") - # or action object which stringifies to that - $action = $self->_invoke_as_path( $c, "$command", \@args ); + # or action object + if (blessed($command) && $command->isa('Catalyst::Action')) { + $action = $command; + } + else { + $action = $self->_invoke_as_path( $c, "$command", \@args ); + } # go to a component ( "MyApp::*::Foo" or $c->component("...") # - a path or an object) @@ -155,24 +163,44 @@ sub _command2action { $action = $self->_invoke_as_component( $c, $command, $method ); } - return $action, \@args; + return $action, \@args, \@captures; } -=head2 $self->go( $c, $command [, \@arguments ] ) +=head2 $self->visit( $c, $command [, \@arguments ] ) Documented in L =cut -sub go { +sub visit { my $self = shift; + $self->_do_visit('visit', @_); +} + +sub _do_visit { + 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"): /; - unless ($action && defined $action->namespace) { - my $error = - qq/Couldn't go to command "$command": / - . qq/Invalid action or component./; + if (!$action) { + $error .= qq/Couldn't $opname to command "$command": / + .qq/Invalid action or component./; + } + elsif (!defined $action->namespace) { + $error .= qq/Action has no namespace: cannot $opname() to a plain / + .qq/method or component, must be an :Action of some sort./ + } + elsif (!$action->class->can('_DISPATCH')) { + $error .= qq/Action cannot _DISPATCH. / + .qq/Did you try to $opname() a non-controller action?/; + } + else { + $error = q(); + } + + if($error) { $c->error($error); $c->log->debug($error) if $c->debug; return 0; @@ -181,10 +209,22 @@ sub go { $action = $self->expand_action($action); local $c->request->{arguments} = $args; - $c->namespace($action->namespace); - $c->action($action); + local $c->request->{captures} = $captures; + local $c->{namespace} = $action->{'namespace'}; + local $c->{action} = $action; + $self->dispatch($c); +} + +=head2 $self->go( $c, $command [, \@arguments ] ) + +Documented in L + +=cut +sub go { + my $self = shift; + $self->_do_visit('go', @_); die $Catalyst::GO; } @@ -196,30 +236,44 @@ Documented in L sub forward { my $self = shift; + no warnings 'recursion'; + $self->_do_forward(forward => @_); +} + +sub _do_forward { + my $self = shift; + my $opname = shift; my ( $c, $command ) = @_; - my ( $action, $args ) = $self->_command2action(@_); + my ( $action, $args, $captures ) = $self->_command2action(@_); - unless ($action) { - my $error = - qq/Couldn't forward to command "$command": / - . qq/Invalid action or component./; + if (!$action) { + my $error .= qq/Couldn't $opname to command "$command": / + .qq/Invalid action or component./; $c->error($error); $c->log->debug($error) if $c->debug; return 0; } - #push @$args, @_; + local $c->request->{arguments} = $args; no warnings 'recursion'; - - my $orig_args = $c->request->arguments(); - $c->request->arguments($args); $action->dispatch( $c ); - $c->request->arguments($orig_args); - + return $c->state; } +=head2 $self->detach( $c, $command [, \@arguments ] ) + +Documented in L + +=cut + +sub detach { + my ( $self, $c, $command, @args ) = @_; + $self->_do_forward(detach => $c, $command, @args ) if $command; + die $Catalyst::DETACH; +} + sub _action_rel2abs { my ( $self, $c, $path ) = @_; @@ -254,35 +308,44 @@ sub _invoke_as_path { } } -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; @@ -327,7 +390,7 @@ sub prepare_action { s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg for grep { defined } @{$req->captures||[]}; $c->log->debug( 'Path is "' . $req->match . '"' ) - if ( $c->debug && length $req->match ); + if ( $c->debug && defined $req->match && length $req->match ); $c->log->debug( 'Arguments are "' . join( '/', @args ) . '"' ) if ( $c->debug && @args ); @@ -350,7 +413,7 @@ sub get_action { =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 @@ -423,6 +486,14 @@ sub uri_for_action { return undef; } +=head2 expand_action + +expand an action into a full representation of the dispatch. +mostly useful for chained, other actions will just return a +single action. + +=cut + sub expand_action { my ($self, $action) = @_; @@ -452,7 +523,8 @@ sub register { next if $key eq 'Private'; my $class = "Catalyst::DispatchType::$key"; unless ( $registered->{$class} ) { - #some error checking rethrowing here wouldn't hurt. + # FIXME - Some error checking and re-throwing needed here, as + # we eat exceptions loading dispatch types. eval { Class::MOP::load_class($class) }; push( @{ $self->_dispatch_types }, $class->new ) unless $@; $registered->{$class} = 1; @@ -506,13 +578,15 @@ sub _find_or_create_namespace_node { =head2 $self->setup_actions( $class, $context ) +Loads all of the preload dispatch types, registers their actions and then +loads all of the postload dispatch types, and iterates over the tree of +actions, displaying the debug information if appropriate. =cut sub setup_actions { my ( $self, $c ) = @_; - my @classes = $self->_load_dispatch_types( @{ $self->preload_dispatch_types } ); @{ $self->_registered_dispatch_types }{@classes} = (1) x @classes; @@ -524,11 +598,15 @@ sub setup_actions { $self->_load_dispatch_types( @{ $self->postload_dispatch_types } ); return unless $c->debug; + $self->_display_action_tables($c); +} + +sub _display_action_tables { + my ($self, $c) = @_; + my $column_width = Catalyst::Utils::term_width() - 20 - 36 - 12; my $privates = Text::SimpleTable->new( - [ 20, 'Private' ], - [ 36, 'Class' ], - [ 12, 'Method' ] + [ 20, 'Private' ], [ 36, 'Class' ], [ $column_width, 'Method' ] ); my $has_private = 0; @@ -565,9 +643,8 @@ sub _load_dispatch_types { # Preload action types for my $type (@types) { - my $class = - ( $type =~ /^\+(.*)$/ ) ? $1 : "Catalyst::DispatchType::${type}"; - + my $class = Catalyst::Utils::resolve_namespace('Catalyst::DispatchType', $type); + eval { Class::MOP::load_class($class) }; Catalyst::Exception->throw( message => qq/Couldn't load "$class"/ ) if $@; @@ -579,7 +656,66 @@ sub _load_dispatch_types { return @loaded; } -no Moose; +=head2 $self->dispatch_type( $type ) + +Get the DispatchType object of the relevant type, i.e. passing C<$type> of +C would return a L object (assuming +of course it's being used.) + +=cut + +sub dispatch_type { + my ($self, $name) = @_; + + $name = Catalyst::Utils::resolve_namespace('Catalyst::DispatchType', $name); + + for (@{ $self->_dispatch_types }) { + return $_ if ref($_) eq $name; + } + return undef; +} + +use Moose; + +# 5.70 backwards compatibility hacks. + +# Various plugins (e.g. Plugin::Server and Plugin::Authorization::ACL) +# need the methods here which *should* be private.. + +# However we can't really take them away until there is a sane API for +# building actions and configuring / introspecting the dispatcher. +# In 5.90, we should build that infrastructure, port the plugins which +# use it, and then take the crap below away. +# 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 + container_hash + /) { + my $private_method_name = '_' . $public_method_name; + my $meta = __PACKAGE__->meta; # Calling meta method here fine as we happen at compile time. + $meta->add_method($public_method_name, $meta->get_method($private_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 = 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. + __PACKAGE__->meta->make_immutable; =head2 meta