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=680a76bb664dde9fc58bd5d2790973a79c0e5d75;hp=08652e5135b7eeb256e157b570fae5309de5d5dd;hb=5299fff8fe52a4f4c10698b258984e41a2f6964f;hpb=8f59bbe26ac3e8b9e40f66b07b2855a80139c075 diff --git a/lib/Catalyst/Dispatcher.pm b/lib/Catalyst/Dispatcher.pm index 08652e5..680a76b 100644 --- a/lib/Catalyst/Dispatcher.pm +++ b/lib/Catalyst/Dispatcher.pm @@ -15,6 +15,8 @@ use Text::SimpleTable; 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. @@ -26,14 +28,14 @@ our @PRELOAD = qw/Index Path Regex/; 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'); 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. @@ -44,8 +46,6 @@ around qw/preload_dispatch_types postload_dispatch_types/ => sub { return $self->$orig(@_); }; -no Moose; - =head1 NAME Catalyst::Dispatcher - The Catalyst Dispatcher @@ -61,19 +61,19 @@ application based on the attributes you set. =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 @@ -119,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 { @@ -130,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 } @@ -158,7 +163,7 @@ sub _command2action { $action = $self->_invoke_as_component( $c, $command, $method ); } - return $action, \@args; + return $action, \@args, \@captures; } =head2 $self->visit( $c, $command [, \@arguments ] ) @@ -176,7 +181,7 @@ 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"): /; if (!$action) { @@ -185,7 +190,7 @@ sub _do_visit { } 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. / @@ -204,6 +209,7 @@ sub _do_visit { $action = $self->expand_action($action); local $c->request->{arguments} = $args; + local $c->request->{captures} = $captures; local $c->{namespace} = $action->{'namespace'}; local $c->{action} = $action; @@ -230,6 +236,7 @@ Documented in L sub forward { my $self = shift; + no warnings 'recursion'; $self->_do_forward(forward => @_); } @@ -237,7 +244,7 @@ sub _do_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": / @@ -247,9 +254,9 @@ sub _do_forward { return 0; } - no warnings 'recursion'; local $c->request->{arguments} = $args; + no warnings 'recursion'; $action->dispatch( $c ); return $c->state; @@ -301,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; @@ -354,9 +370,7 @@ sub prepare_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 @@ -395,9 +409,9 @@ sub get_action { 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 @@ -443,9 +457,6 @@ sub get_containers { } 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) @@ -515,9 +526,29 @@ sub register { } } + 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; @@ -582,6 +613,11 @@ 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( @@ -636,6 +672,27 @@ sub _load_dispatch_types { return @loaded; } +=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) = @_; + + unless ($name =~ s/^\+//) { + $name = "Catalyst::DispatchType::" . $name; + } + + for (@{ $self->_dispatch_types }) { + return $_ if ref($_) eq $name; + } + return undef; +} + use Moose; # 5.70 backwards compatibility hacks. @@ -650,12 +707,12 @@ use Moose; # 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; @@ -665,17 +722,18 @@ foreach my $public_method_name (qw/ 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 @@ -688,7 +746,7 @@ 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