X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FDispatcher.pm;h=d5bb4554fc6c4d3f7793d444cc02a34326d2807d;hb=c41cfce33f5510dee4937dfaaff2fd331130a84b;hp=067f721da255fdc373e56310318fca63021f73eb;hpb=e63bdf38982956964059c65227f31a7b13dbf841;p=catagits%2FCatalyst-Runtime.git diff --git a/lib/Catalyst/Dispatcher.pm b/lib/Catalyst/Dispatcher.pm index 067f721..d5bb455 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; @@ -14,9 +15,9 @@ use Tree::Simple; use Tree::Simple::Visitor::FindByPath; use Scalar::Util (); -# Stringify to class -use overload '""' => sub { return ref(shift) }, fallback => 1; - +# 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/; @@ -24,15 +25,24 @@ 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 { {} }); +# Note - see back-compat methods at end of file. +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_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] }); + +# 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(@_); +}; no Moose; @@ -51,7 +61,7 @@ application based on the attributes you set. =head1 METHODS -=head2 new +=head2 new Construct a new dispatcher. @@ -86,18 +96,6 @@ 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 @@ -122,17 +120,15 @@ sub dispatch { } } -=head2 $self->forward( $c, $command [, \@arguments ] ) - -Documented in L +# $self->_command2action( $c, $command [, \@arguments ] ) +# Search for an action, from the command and returns C<($action, $args)> on +# success. Returns C<(0)> on error. -=cut - -sub forward { +sub _command2action { my ( $self, $c, $command, @extra_params ) = @_; unless ($command) { - $c->log->debug('Nothing to forward to') if $c->debug; + $c->log->debug('Nothing to go to') if $c->debug; return 0; } @@ -141,41 +137,140 @@ sub forward { 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 + # 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; - # forward to a string path ("/foo/bar/gorch") or action object which stringifies to that - $action = $self->_invoke_as_path( $c, "$command", \@args ); + # go to a string path ("/foo/bar/gorch") + # or action object + if (Scalar::Util::blessed($command) && $command->isa('Catalyst::Action')) { + $action = $command; + } + else { + $action = $self->_invoke_as_path( $c, "$command", \@args ); + } - # forward to a component ( "MyApp::*::Foo" or $c->component("...") - a path or an object) + # 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; +} - unless ($action) { - my $error = - qq/Couldn't forward to command "$command": / - . qq/Invalid action or component./; +=head2 $self->visit( $c, $command [, \@arguments ] ) + +Documented in L + +=cut + +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 $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 a :Action or 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; } - #push @$args, @_; + $action = $self->expand_action($action); + + local $c->request->{arguments} = $args; + 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; +} + +=head2 $self->forward( $c, $command [, \@arguments ] ) + +Documented in L + +=cut + +sub forward { + my $self = shift; + $self->_do_forward(forward => @_); +} + +sub _do_forward { + my $self = shift; + my $opname = shift; + my ( $c, $command ) = @_; + my ( $action, $args ) = $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; + } 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; } +=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 ) = @_; @@ -280,11 +375,10 @@ sub prepare_action { unshift @args, $arg; } - #Moose todo: This seems illegible, even if efficient. 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 && $req->match ); + if ( $c->debug && defined $req->match && length $req->match ); $c->log->debug( 'Arguments are "' . join( '/', @args ) . '"' ) if ( $c->debug && @args ); @@ -300,14 +394,14 @@ 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}"}; } -=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 path. =cut @@ -380,6 +474,25 @@ 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) = @_; + + 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 ) Make sure all required dispatch types for this action are loaded, then @@ -398,7 +511,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; @@ -458,10 +572,6 @@ sub _find_or_create_namespace_node { 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 } ); @@ -517,7 +627,7 @@ sub _load_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 $@; @@ -529,14 +639,55 @@ sub _load_dispatch_types { return @loaded; } +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 = Scalar::Util::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"); + }; + }); + } +} +# End 5.70 backwards compatibility hacks. + +no Moose; +__PACKAGE__->meta->make_immutable; + =head2 meta Provided by Moose -=head1 AUTHOR +=head1 AUTHORS -Sebastian Riedel, C -Matt S Trout, C +Catalyst Contributors, see Catalyst.pm =head1 COPYRIGHT