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=9d2ae4ad977906bc48c39dfdf1484b2cd93e0925;hp=96dc2ade8612fa57ef2075c7131018e911a564d9;hb=48d435ba6a0925260fd58c8c18ff425e99708eae;hpb=34d28dfd33574ce30aca69fb8700b61111d97b92 diff --git a/lib/Catalyst/Dispatcher.pm b/lib/Catalyst/Dispatcher.pm index 96dc2ad..9d2ae4a 100644 --- a/lib/Catalyst/Dispatcher.pm +++ b/lib/Catalyst/Dispatcher.pm @@ -1,27 +1,25 @@ package Catalyst::Dispatcher; -use strict; -use base 'Class::Accessor::Fast'; +use Moose; +use Class::MOP; +with 'MooseX::Emulate::Class::Accessor::Fast'; + use Catalyst::Exception; use Catalyst::Utils; 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; -# Stringify to class -use overload '""' => sub { return ref shift }, fallback => 1; +use namespace::clean -except => 'meta'; -__PACKAGE__->mk_accessors( - qw/tree dispatch_types registered_dispatch_types - method_action_class action_container_class - preload_dispatch_types postload_dispatch_types - action_hash container_hash - / -); +# 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/; @@ -29,6 +27,22 @@ our @PRELOAD = qw/Index Path Regex/; # Postload these action types our @POSTLOAD = qw/Default/; +# 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_hash => (is => 'rw', required => 1, lazy => 1, default => sub { {} }); +has _container_hash => (is => 'rw', required => 1, lazy => 1, default => sub { {} }); + +my %dispatch_types = ( pre => \@PRELOAD, post => \@POSTLOAD ); +foreach my $type (keys %dispatch_types) { + has $type . "load_dispatch_types" => ( + is => 'rw', required => 1, lazy => 1, default => sub { $dispatch_types{$type} }, + traits => ['MooseX::Emulate::Class::Accessor::Fast::Meta::Role::Attribute'], # List assignment is CAF style + ); +} + =head1 NAME Catalyst::Dispatcher - The Catalyst Dispatcher @@ -44,30 +58,19 @@ application based on the attributes you set. =head1 METHODS -=head2 new +=head2 new Construct a new dispatcher. =cut -sub new { - my $self = shift; - my $class = ref($self) || $self; +sub _build__tree { + my ($self) = @_; - my $obj = $class->SUPER::new(@_); + my $container = + Catalyst::ActionContainer->new( { part => '/', actions => {} } ); - # set the default pre- and and postloads - $obj->preload_dispatch_types( \@PRELOAD ); - $obj->postload_dispatch_types( \@POSTLOAD ); - $obj->action_hash( {} ); - $obj->container_hash( {} ); - - # Create the root node of the tree - my $container = - Catalyst::ActionContainer->new( { part => '/', actions => {} } ); - $obj->tree( Tree::Simple->new( $container, Tree::Simple->ROOT ) ); - - return $obj; + return Tree::Simple->new($container, Tree::Simple->ROOT); } =head2 $self->preload_dispatch_types @@ -90,32 +93,18 @@ 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 { 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 $path = $c->req->path; my $error = $path @@ -126,44 +115,162 @@ sub dispatch { } } -=head2 $self->forward( $c, $command [, \@arguments ] ) +# $self->_command2action( $c, $command [, \@arguments ] ) +# $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 { + my ( $self, $c, $command, @extra_params ) = @_; + + unless ($command) { + $c->log->debug('Nothing to go to') if $c->debug; + return 0; + } + + 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 } + } else { + # this is a copy, it may take some abuse from + # ->_invoke_as_path if the path had trailing parts + @args = @{ $c->request->arguments }; + } + + my $action; + + # go to a string path ("/foo/bar/gorch") + # 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) + unless ($action) { + my $method = @extra_params ? $extra_params[0] : "process"; + $action = $self->_invoke_as_component( $c, $command, $method ); + } + + return $action, \@args, \@captures; +} + +=head2 $self->visit( $c, $command [, \@arguments ] ) Documented in L =cut -sub forward { - my ( $self, $c, $command ) = splice( @_, 0, 3 ); +sub visit { + my $self = shift; + $self->_do_visit('visit', @_); +} - unless ($command) { - $c->log->debug('Nothing to forward to') if $c->debug; +sub _do_visit { + my $self = shift; + my $opname = shift; + my ( $c, $command ) = @_; + my ( $action, $args, $captures ) = $self->_command2action(@_); + my $error = qq/Couldn't $opname("$command"): /; + + 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; } - my $args = [ @{ $c->request->arguments } ]; + $action = $self->expand_action($action); - @$args = @{ pop @_ } if ( ref( $_[-1] ) eq 'ARRAY' ); + local $c->request->{arguments} = $args; + local $c->request->{captures} = $captures; + local $c->{namespace} = $action->{'namespace'}; + local $c->{action} = $action; - my $action = $self->_invoke_as_path( $c, $command, $args ) - || $self->_invoke_as_component( $c, $command, shift ); + $self->dispatch($c); +} - unless ($action) { - my $error = - qq/Couldn't forward to command "$command": / - . qq/Invalid action or component./; +=head2 $self->go( $c, $command [, \@arguments ] ) + +Documented in L + +=cut + +sub go { + my $self = shift; + $self->_do_visit('go', @_); + Catalyst::Exception::Go->throw; +} + +=head2 $self->forward( $c, $command [, \@arguments ] ) + +Documented in L + +=cut + +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, $captures ) = $self->_command2action(@_); + + 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; - $action->execute($c); + no warnings 'recursion'; + $action->dispatch( $c ); 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; + Catalyst::Exception::Detach->throw; +} + sub _action_rel2abs { my ( $self, $c, $path ) = @_; @@ -179,8 +286,6 @@ sub _action_rel2abs { sub _invoke_as_path { my ( $self, $c, $rel_path, $args ) = @_; - return if ref $rel_path; # it must be a string - my $path = $self->_action_rel2abs( $c, $rel_path ); my ( $tail, @extra_args ); @@ -200,36 +305,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; - $method ||= "process"; + 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) ) { - return $self->method_action_class->new( + 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; @@ -245,22 +358,21 @@ Find an dispatch type that matches $c->req->path, and set args from it. 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 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 - foreach my $type ( @{ $self->dispatch_types } ) { + foreach my $type ( @{ $self->_dispatch_types } ) { last DESCEND if $type->match( $c, $path ); } @@ -270,8 +382,10 @@ sub prepare_action { unshift @args, $arg; } - $c->log->debug( 'Path is "' . $c->req->match . '"' ) - if ( $c->debug && $c->req->match ); + 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 && defined $req->match && length $req->match ); $c->log->debug( 'Arguments are "' . join( '/', @args ) . '"' ) if ( $c->debug && @args ); @@ -287,21 +401,22 @@ sub get_action { my ( $self, $name, $namespace ) = @_; return unless $name; - $namespace = join( "/", grep { length } split '/', $namespace || "" ); + $namespace = join( "/", grep { length } split '/', ( defined $namespace ? $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. +=head2 $self->get_action_by_path( $path ); + +Returns the named action by its full private path. -=cut +=cut sub get_action_by_path { my ( $self, $path ) = @_; + $path =~ s/^\///; $path = "/$path" unless $path =~ /\//; - $self->action_hash->{$path}; + $self->_action_hash->{$path}; } =head2 $self->get_actions( $c, $action, $namespace ) @@ -334,13 +449,52 @@ sub get_containers { if ( length $namespace ) { do { - push @containers, $self->container_hash->{$namespace}; + push @containers, $self->_container_hash->{$namespace}; } while ( $namespace =~ s#/[^/]+$## ); } - return reverse grep { defined } @containers, $self->container_hash->{''}; + return reverse grep { defined } @containers, $self->_container_hash->{''}; +} - my @parts = split '/', $namespace; +=head2 $self->uri_for_action($action, \@captures) + +Takes a Catalyst::Action object and action parameters and returns a URI +part such that if $c->req->path were this URI part, this action would be +dispatched to with $c->req->captures set to the supplied arrayref. + +If the action object is not available for external dispatch or the dispatcher +cannot determine an appropriate URI, this method will return undef. + +=cut + +sub uri_for_action { + my ( $self, $action, $captures) = @_; + $captures ||= []; + foreach my $dispatch_type ( @{ $self->_dispatch_types } ) { + my $uri = $dispatch_type->uri_for_action( $action, $captures ); + return( $uri eq '' ? '/' : $uri ) + if defined($uri); + } + 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) = @_; + + foreach my $dispatch_type (@{ $self->_dispatch_types }) { + my $expanded = $dispatch_type->expand_action($action); + return $expanded if $expanded; + } + + return $action; } =head2 $self->register( $c, $action ) @@ -354,43 +508,61 @@ Also, set up the tree with the action containers. sub register { my ( $self, $c, $action ) = @_; - my $registered = $self->registered_dispatch_types; + my $registered = $self->_registered_dispatch_types; - my $priv = 0; + #my $priv = 0; #seems to be unused foreach my $key ( keys %{ $action->attributes } ) { - $priv++ if $key eq 'Private'; + next if $key eq 'Private'; my $class = "Catalyst::DispatchType::$key"; unless ( $registered->{$class} ) { - eval "require $class"; - push( @{ $self->dispatch_types }, $class->new ) unless $@; + # 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; } } + my @dtypes = @{ $self->_dispatch_types }; + my @normal_dtypes; + my @low_precedence_dtypes; + + for my $type ( @dtypes ) { + if ($type->_is_low_precedence) { + push @low_precedence_dtypes, $type; + } else { + push @normal_dtypes, $type; + } + } + # Pass the action to our dispatch types so they can register it if reqd. - my $reg = 0; - foreach my $type ( @{ $self->dispatch_types } ) { - $reg++ if $type->register( $c, $action ); + my $was_registered = 0; + foreach my $type ( @normal_dtypes ) { + $was_registered = 1 if $type->register( $c, $action ); } - return unless $reg + $priv; + if (not $was_registered) { + foreach my $type ( @low_precedence_dtypes ) { + $type->register( $c, $action ); + } + } my $namespace = $action->namespace; my $name = $action->name; - my $container = $self->find_or_create_action_container($namespace); + my $container = $self->_find_or_create_action_container($namespace); # Set the method value $container->add_action($action); - $self->action_hash->{"$namespace/$name"} = $action; - $self->container_hash->{$namespace} = $container; + $self->_action_hash->{"$namespace/$name"} = $action; + $self->_container_hash->{$namespace} = $container; } -sub find_or_create_action_container { +sub _find_or_create_action_container { my ( $self, $namespace ) = @_; - my $tree ||= $self->tree; + my $tree ||= $self->_tree; return $tree->getNodeValue unless $namespace; @@ -417,33 +589,41 @@ 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 ) = @_; - $self->dispatch_types( [] ); - $self->registered_dispatch_types( {} ); - $self->method_action_class('Catalyst::Action'); - $self->action_container_class('Catalyst::ActionContainer'); - my @classes = - $self->do_load_dispatch_types( @{ $self->preload_dispatch_types } ); - @{ $self->registered_dispatch_types }{@classes} = (1) x @classes; + $self->_load_dispatch_types( @{ $self->preload_dispatch_types } ); + @{ $self->_registered_dispatch_types }{@classes} = (1) x @classes; foreach my $comp ( values %{ $c->components } ) { $comp->register_actions($c) if $comp->can('register_actions'); } - $self->do_load_dispatch_types( @{ $self->postload_dispatch_types } ); + $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 $avail_width = Catalyst::Utils::term_width() - 12; + my $col1_width = ($avail_width * .25) < 20 ? 20 : int($avail_width * .25); + my $col2_width = ($avail_width * .50) < 36 ? 36 : int($avail_width * .50); + my $col3_width = $avail_width - $col1_width - $col2_width; + $c->log->debug("col1: $col1_width"); + $c->log->debug("col2: $col2_width"); + $c->log->debug("col3: $col3_width"); my $privates = Text::SimpleTable->new( - [ 20, 'Private' ], - [ 36, 'Class' ], - [ 12, 'Method' ] + [ $col1_width, 'Private' ], [ $col2_width, 'Class' ], [ $col3_width, 'Method' ] ); my $has_private = 0; @@ -465,27 +645,27 @@ sub setup_actions { $walker->( $walker, $_, $prefix ) for $parent->getAllChildren; }; - $walker->( $walker, $self->tree, '' ); - $c->log->debug( "Loaded Private actions:\n" . $privates->draw ) - if ($has_private); + $walker->( $walker, $self->_tree, '' ); + $c->log->debug( "Loaded Private actions:\n" . $privates->draw . "\n" ) + if $has_private; # List all public actions - $_->list($c) for @{ $self->dispatch_types }; + $_->list($c) for @{ $self->_dispatch_types }; } -sub do_load_dispatch_types { +sub _load_dispatch_types { my ( $self, @types ) = @_; my @loaded; - # Preload action types for my $type (@types) { - my $class = - ( $type =~ /^\+(.*)$/ ) ? $1 : "Catalyst::DispatchType::${type}"; - eval "require $class"; + # first param is undef because we cannot get the appclass + my $class = Catalyst::Utils::resolve_namespace(undef, 'Catalyst::DispatchType', $type); + + eval { Class::MOP::load_class($class) }; Catalyst::Exception->throw( message => qq/Couldn't load "$class"/ ) if $@; - push @{ $self->dispatch_types }, $class->new; + push @{ $self->_dispatch_types }, $class->new; push @loaded, $class; } @@ -493,14 +673,96 @@ sub do_load_dispatch_types { return @loaded; } -=head1 AUTHOR +=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) = @_; + + # first param is undef because we cannot get the appclass + $name = Catalyst::Utils::resolve_namespace(undef, '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.. + +# You should be able to use get_actions or get_containers appropriately +# instead of relying on these methods which expose implementation details +# of the dispatcher.. +# +# IRC backlog included below, please come ask if this doesn't work for you. +# +# <@t0m> 5.80, the state of. There are things in the dispatcher which have +# been deprecated, that we yell at anyone for using, which there isn't +# a good alternative for yet.. +# <@mst> er, get_actions/get_containers provides that doesn't it? +# <@mst> DispatchTypes are loaded on demand anyway +# <@t0m> I'm thinking of things like _tree which is aliased to 'tree' with +# warnings otherwise shit breaks.. We're issuing warnings about the +# correct set of things which you shouldn't be calling.. +# <@mst> right +# <@mst> basically, I don't see there's a need for a replacement for anything +# <@mst> it was never a good idea to call ->tree +# <@mst> nothingmuch was the only one who did AFAIK +# <@mst> and he admitted it was a hack ;) + +# 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 + +Provided by Moose + +=head1 AUTHORS -Sebastian Riedel, C -Matt S Trout, C +Catalyst Contributors, see Catalyst.pm =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