lib/Catalyst/Dispatcher.pm

   1 package Catalyst::Dispatcher;
   2
   3 use Moose;
   4 use Class::MOP;
   5 with 'MooseX::Emulate::Class::Accessor::Fast';
   6
   7 use Catalyst::Exception;
   8 use Catalyst::Utils;
   9 use Catalyst::Action;
  10 use Catalyst::ActionContainer;
  11 use Catalyst::DispatchType::Default;
  12 use Catalyst::DispatchType::Index;
  13 use Catalyst::Utils;
  14 use Text::SimpleTable;
  15 use Tree::Simple;
  16 use Tree::Simple::Visitor::FindByPath;
  17 use Class::Load qw(load_class try_load_class);
  18 use Encode 2.21 'decode_utf8';
  19 use Ref::Util qw(is_plain_arrayref is_plain_coderef);
  20
  21 use namespace::clean -except => 'meta';
  22
  23 # Refactoring note:
  24 # do these belong as package vars or should we build these via a builder method?
  25 # See Catalyst-Plugin-Server for them being added to, which should be much less ugly.
  26
  27 # Preload these action types
  28 our @PRELOAD = qw/Index Path/;
  29
  30 # Postload these action types
  31 our @POSTLOAD = qw/Default/;
  32
  33 # Note - see back-compat methods at end of file.
  34 has _tree => (is => 'rw', builder => '_build__tree');
  35 has dispatch_types => (is => 'rw', default => sub { [] }, required => 1, lazy => 1);
  36 has _registered_dispatch_types => (is => 'rw', default => sub { {} }, required => 1, lazy => 1);
  37 has _method_action_class => (is => 'rw', default => 'Catalyst::Action');
  38 has _action_hash => (is => 'rw', required => 1, lazy => 1, default => sub { {} });
  39 has _container_hash => (is => 'rw', required => 1, lazy => 1, default => sub { {} });
  40
  41 my %dispatch_types = ( pre => \@PRELOAD, post => \@POSTLOAD );
  42 foreach my $type (keys %dispatch_types) {
  43     has $type . "load_dispatch_types" => (
  44         is => 'rw', required => 1, lazy => 1, default => sub { $dispatch_types{$type} },
  45         traits => ['MooseX::Emulate::Class::Accessor::Fast::Meta::Role::Attribute'], # List assignment is CAF style
  46     );
  47 }
  48
  49 =head1 NAME
  50
  51 Catalyst::Dispatcher - The Catalyst Dispatcher
  52
  53 =head1 SYNOPSIS
  54
  55 See L<Catalyst>.
  56
  57 =head1 DESCRIPTION
  58
  59 This is the class that maps public urls to actions in your Catalyst
  60 application based on the attributes you set.
  61
  62 =head1 METHODS
  63
  64 =head2 new
  65
  66 Construct a new dispatcher.
  67
  68 =cut
  69
  70 sub _build__tree {
  71   my ($self) = @_;
  72
  73   my $container =
  74     Catalyst::ActionContainer->new( { part => '/', actions => {} } );
  75
  76   return Tree::Simple->new($container, Tree::Simple->ROOT);
  77 }
  78
  79 =head2 $self->preload_dispatch_types
  80
  81 An arrayref of pre-loaded dispatchtype classes
  82
  83 Entries are considered to be available as C<Catalyst::DispatchType::CLASS>
  84 To use a custom class outside the regular C<Catalyst> namespace, prefix
  85 it with a C<+>, like so:
  86
  87     +My::Dispatch::Type
  88
  89 =head2 $self->postload_dispatch_types
  90
  91 An arrayref of post-loaded dispatchtype classes
  92
  93 Entries are considered to be available as C<Catalyst::DispatchType::CLASS>
  94 To use a custom class outside the regular C<Catalyst> namespace, prefix
  95 it with a C<+>, like so:
  96
  97     +My::Dispatch::Type
  98
  99 =head2 $self->dispatch($c)
 100
 101 Delegate the dispatch to the action that matched the url, or return a
 102 message about unknown resource
 103
 104 =cut
 105
 106 sub dispatch {
 107     my ( $self, $c ) = @_;
 108     if ( my $action = $c->action ) {
 109         $c->forward( join( '/', '', $action->namespace, '_DISPATCH' ) );
 110     }
 111     else {
 112         my $path  = $c->req->path;
 113         $path =~ s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg;
 114         $path = decode_utf8($path);
 115
 116         my $error = $path
 117           ? qq/Unknown resource "$path"/
 118           : "No default action defined";
 119         $c->log->error($error) if $c->debug;
 120         $c->error($error);
 121     }
 122 }
 123
 124 # $self->_command2action( $c, $command [, \@arguments ] )
 125 # $self->_command2action( $c, $command [, \@captures, \@arguments ] )
 126 # Search for an action, from the command and returns C<($action, $args, $captures)> on
 127 # success. Returns C<(0)> on error.
 128
 129 sub _command2action {
 130     my ( $self, $c, $command, @extra_params ) = @_;
 131
 132     unless ($command) {
 133         $c->log->debug('Nothing to go to') if $c->debug;
 134         return 0;
 135     }
 136
 137     my (@args, @captures);
 138
 139     if ( is_plain_arrayref($extra_params[-2]) ) {
 140         @captures = @{ splice @extra_params, -2, 1 };
 141     }
 142
 143     if ( is_plain_arrayref($extra_params[-1]) ) {
 144         @args = @{ pop @extra_params }
 145     } else {
 146         # this is a copy, it may take some abuse from
 147         # ->_invoke_as_path if the path had trailing parts
 148         @args = @{ $c->request->arguments };
 149     }
 150
 151     my $action;
 152
 153     # go to a string path ("/foo/bar/gorch")
 154     # or action object
 155     if (blessed($command) && $command->isa('Catalyst::Action')) {
 156         $action = $command;
 157     }
 158     else {
 159         $action = $self->_invoke_as_path( $c, "$command", \@args );
 160     }
 161
 162     # go to a component ( "View::Foo" or $c->component("...")
 163     # - a path or an object)
 164     unless ($action) {
 165         my $method = @extra_params ? $extra_params[0] : "process";
 166         $action = $self->_invoke_as_component( $c, $command, $method );
 167     }
 168
 169     return $action, \@args, \@captures;
 170 }
 171
 172 =head2 $self->visit( $c, $command [, \@arguments ] )
 173
 174 Documented in L<Catalyst>
 175
 176 =cut
 177
 178 sub visit {
 179     my $self = shift;
 180     $self->_do_visit('visit', @_);
 181 }
 182
 183 sub _do_visit {
 184     my $self = shift;
 185     my $opname = shift;
 186     my ( $c, $command ) = @_;
 187     my ( $action, $args, $captures ) = $self->_command2action(@_);
 188     my $error = qq/Couldn't $opname("$command"): /;
 189
 190     if (!$action) {
 191         $error .= qq/Couldn't $opname to command "$command": /
 192                  .qq/Invalid action or component./;
 193     }
 194     elsif (!defined $action->namespace) {
 195         $error .= qq/Action has no namespace: cannot $opname() to a plain /
 196                  .qq/method or component, must be an :Action of some sort./
 197     }
 198     elsif (!$action->class->can('_DISPATCH')) {
 199         $error .= qq/Action cannot _DISPATCH. /
 200                  .qq/Did you try to $opname() a non-controller action?/;
 201     }
 202     else {
 203         $error = q();
 204     }
 205
 206     if($error) {
 207         $c->error($error);
 208         $c->log->debug($error) if $c->debug;
 209         return 0;
 210     }
 211
 212     $action = $self->expand_action($action);
 213
 214     local $c->request->{arguments} = $args;
 215     local $c->request->{captures}  = $captures;
 216     local $c->{namespace} = $action->{'namespace'};
 217     local $c->{action} = $action;
 218
 219     $self->dispatch($c);
 220 }
 221
 222 =head2 $self->go( $c, $command [, \@arguments ] )
 223
 224 Documented in L<Catalyst>
 225
 226 =cut
 227
 228 sub go {
 229     my $self = shift;
 230     $self->_do_visit('go', @_);
 231     Catalyst::Exception::Go->throw;
 232 }
 233
 234 =head2 $self->forward( $c, $command [, \@arguments ] )
 235
 236 Documented in L<Catalyst>
 237
 238 =cut
 239
 240 sub forward {
 241     my $self = shift;
 242     no warnings 'recursion';
 243     return $self->_do_forward(forward => @_);
 244 }
 245
 246 sub _do_forward {
 247     my $self = shift;
 248     my $opname = shift;
 249     my ( $c, $command ) = @_;
 250     my ( $action, $args, $captures ) = $self->_command2action(@_);
 251
 252     if (!$action) {
 253         my $error .= qq/Couldn't $opname to command "$command": /
 254                     .qq/Invalid action or component./;
 255         $c->error($error);
 256         $c->log->debug($error) if $c->debug;
 257         return 0;
 258     }
 259
 260
 261     local $c->request->{arguments} = $args;
 262     no warnings 'recursion';
 263     $action->dispatch( $c );
 264
 265     #If there is an error, all bets off regarding state.  Documentation
 266     #Specifies that when you forward, if there's an error you must expect
 267     #state to be 0.
 268     if( @{ $c->error }) {
 269       $c->state(0);
 270     }
 271     return $c->state;
 272 }
 273
 274 =head2 $self->detach( $c, $command [, \@arguments ] )
 275
 276 Documented in L<Catalyst>
 277
 278 =cut
 279
 280 sub detach {
 281     my ( $self, $c, $command, @args ) = @_;
 282     $self->_do_forward(detach => $c, $command, @args ) if $command;
 283     $c->state(0); # Needed in order to skip any auto functions
 284     Catalyst::Exception::Detach->throw;
 285 }
 286
 287 sub _action_rel2abs {
 288     my ( $self, $c, $path ) = @_;
 289
 290     unless ( $path =~ m#^/# ) {
 291         my $namespace = $c->stack->[-1]->namespace;
 292         $path = "$namespace/$path";
 293     }
 294
 295     $path =~ s#^/##;
 296     return $path;
 297 }
 298
 299 sub _invoke_as_path {
 300     my ( $self, $c, $rel_path, $args ) = @_;
 301
 302     my $path = $self->_action_rel2abs( $c, $rel_path );
 303
 304     my ( $tail, @extra_args );
 305     while ( ( $path, $tail ) = ( $path =~ m#^(?:(.*)/)?(\w+)?$# ) )
 306     {                           # allow $path to be empty
 307         if ( my $action = $c->get_action( $tail, $path ) ) {
 308             push @$args, @extra_args;
 309             return $action;
 310         }
 311         else {
 312             return
 313               unless $path
 314               ; # if a match on the global namespace failed then the whole lookup failed
 315         }
 316
 317         unshift @extra_args, $tail;
 318     }
 319 }
 320
 321 sub _find_component {
 322     my ( $self, $c, $component ) = @_;
 323
 324     # fugly, why doesn't ->component('MyApp') work?
 325     return $c if ($component eq blessed($c));
 326
 327     return blessed($component)
 328         ? $component
 329         : $c->component($component);
 330 }
 331
 332 sub _invoke_as_component {
 333     my ( $self, $c, $component_or_class, $method ) = @_;
 334
 335     my $component = $self->_find_component($c, $component_or_class);
 336     my $component_class = blessed $component || return 0;
 337
 338     if (my $code = $component_class->can('action_for')) {
 339         my $possible_action = $component->$code($method);
 340         return $possible_action if $possible_action;
 341     }
 342
 343     if ( my $code = $component_class->can($method) ) {
 344         return $self->_method_action_class->new(
 345             {
 346                 name      => $method,
 347                 code      => $code,
 348                 reverse   => "$component_class->$method",
 349                 class     => $component_class,
 350                 namespace => Catalyst::Utils::class2prefix(
 351                     $component_class, ref($c)->config->{case_sensitive}
 352                 ),
 353             }
 354         );
 355     }
 356     else {
 357         my $error =
 358           qq/Couldn't forward to "$component_class". Does not implement "$method"/;
 359         $c->error($error);
 360         $c->log->debug($error)
 361           if $c->debug;
 362         return 0;
 363     }
 364 }
 365
 366 =head2 $self->prepare_action($c)
 367
 368 Find an dispatch type that matches $c->req->path, and set args from it.
 369
 370 =cut
 371
 372 sub prepare_action {
 373     my ( $self, $c ) = @_;
 374     my $req = $c->req;
 375     my $path = $req->path;
 376     my @path = split /\//, $req->path;
 377     $req->args( \my @args );
 378
 379     unshift( @path, '' );    # Root action
 380
 381   DESCEND: while (@path) {
 382         $path = join '/', @path;
 383         $path =~ s#^/+##;
 384
 385         # Check out dispatch types to see if any will handle the path at
 386         # this level
 387
 388         foreach my $type ( @{ $self->dispatch_types } ) {
 389             last DESCEND if $type->match( $c, $path );
 390         }
 391
 392         # If not, move the last part path to args
 393         my $arg = pop(@path);
 394         $arg =~ s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg;
 395         unshift @args, $arg;
 396     }
 397
 398     s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg for grep { defined } @{$req->captures||[]};
 399
 400     if($c->debug && defined $req->match && length $req->match) {
 401       my $match = $req->match;
 402       $match =~ s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg;
 403       $match = decode_utf8($match);
 404       $c->log->debug( 'Path is "' . $match . '"' )
 405     }
 406
 407     $c->log->debug( 'Arguments are "' . join( '/', map { decode_utf8 $_ } @args ) . '"' )
 408       if ( $c->debug && @args );
 409 }
 410
 411 =head2 $self->get_action( $action_name, $namespace )
 412
 413 returns a named action from a given namespace.  C<$action_name>
 414 may be a relative path on that C<$namespace> such as
 415
 416     $self->get_action('../bar', 'foo/baz');
 417
 418 In which case we look for the action at 'foo/bar'.
 419
 420 =cut
 421
 422 sub get_action {
 423     my ( $self, $name, $namespace ) = @_;
 424     return unless $name;
 425
 426     $namespace = join( "/", grep { length } split '/', ( defined $namespace ? $namespace : "" ) );
 427
 428     return $self->get_action_by_path("${namespace}/${name}");
 429 }
 430
 431 =head2 $self->get_action_by_path( $path );
 432
 433 Returns the named action by its full private path.
 434
 435 This method performs some normalization on C<$path> so that if
 436 it includes '..' it will do the right thing (for example if
 437 C<$path> is '/foo/../bar' that is normalized to '/bar'.
 438
 439 =cut
 440
 441 sub get_action_by_path {
 442     my ( $self, $path ) = @_;
 443     $path =~s/[^\/]+\/\.\.\/// while $path=~m/[^\/]+\/\.\.\//;
 444     $path =~ s/^\///;
 445     $path = "/$path" unless $path =~ /\//;
 446     $self->_action_hash->{$path};
 447 }
 448
 449 =head2 $self->get_actions( $c, $action, $namespace )
 450
 451 =cut
 452
 453 sub get_actions {
 454     my ( $self, $c, $action, $namespace ) = @_;
 455     return [] unless $action;
 456
 457     $namespace = join( "/", grep { length } split '/', $namespace || "" );
 458
 459     my @match = $self->get_containers($namespace);
 460
 461     return map { $_->get_action($action) } @match;
 462 }
 463
 464 =head2 $self->get_containers( $namespace )
 465
 466 Return all the action containers for a given namespace, inclusive
 467
 468 =cut
 469
 470 sub get_containers {
 471     my ( $self, $namespace ) = @_;
 472     $namespace ||= '';
 473     $namespace = '' if $namespace eq '/';
 474
 475     my @containers;
 476
 477     if ( length $namespace ) {
 478         do {
 479             push @containers, $self->_container_hash->{$namespace};
 480         } while ( $namespace =~ s#/[^/]+$## );
 481     }
 482
 483     return reverse grep { defined } @containers, $self->_container_hash->{''};
 484 }
 485
 486 =head2 $self->uri_for_action($action, \@captures)
 487
 488 Takes a Catalyst::Action object and action parameters and returns a URI
 489 part such that if $c->req->path were this URI part, this action would be
 490 dispatched to with $c->req->captures set to the supplied arrayref.
 491
 492 If the action object is not available for external dispatch or the dispatcher
 493 cannot determine an appropriate URI, this method will return undef.
 494
 495 =cut
 496
 497 sub uri_for_action {
 498     my ( $self, $action, $captures) = @_;
 499     $captures ||= [];
 500     foreach my $dispatch_type ( @{ $self->dispatch_types } ) {
 501         my $uri = $dispatch_type->uri_for_action( $action, $captures );
 502         return( $uri eq '' ? '/' : $uri )
 503             if defined($uri);
 504     }
 505     return undef;
 506 }
 507
 508 =head2 expand_action
 509
 510 expand an action into a full representation of the dispatch.
 511 mostly useful for chained, other actions will just return a
 512 single action.
 513
 514 =cut
 515
 516 sub expand_action {
 517     my ($self, $action) = @_;
 518
 519     foreach my $dispatch_type (@{ $self->dispatch_types }) {
 520         my $expanded = $dispatch_type->expand_action($action);
 521         return $expanded if $expanded;
 522     }
 523
 524     return $action;
 525 }
 526
 527 =head2 $self->register( $c, $action )
 528
 529 Make sure all required dispatch types for this action are loaded, then
 530 pass the action to our dispatch types so they can register it if required.
 531 Also, set up the tree with the action containers.
 532
 533 =cut
 534
 535 sub register {
 536     my ( $self, $c, $action ) = @_;
 537
 538     my $registered = $self->_registered_dispatch_types;
 539
 540     foreach my $key ( keys %{ $action->attributes } ) {
 541         next if $key eq 'Private';
 542         my $class = "Catalyst::DispatchType::$key";
 543         unless ( $registered->{$class} ) {
 544             # FIXME - Some error checking and re-throwing needed here, as
 545             #         we eat exceptions loading dispatch types.
 546             # see also try_load_class
 547             eval { load_class($class) };
 548             my $load_failed = $@;
 549             $self->_check_deprecated_dispatch_type( $key, $load_failed );
 550             push( @{ $self->dispatch_types }, $class->new ) unless $load_failed;
 551             $registered->{$class} = 1;
 552         }
 553     }
 554
 555     my @dtypes = @{ $self->dispatch_types };
 556     my @normal_dtypes;
 557     my @low_precedence_dtypes;
 558
 559     for my $type ( @dtypes ) {
 560         if ($type->_is_low_precedence) {
 561             push @low_precedence_dtypes, $type;
 562         } else {
 563             push @normal_dtypes, $type;
 564         }
 565     }
 566
 567     # Pass the action to our dispatch types so they can register it if reqd.
 568     my $was_registered = 0;
 569     foreach my $type ( @normal_dtypes ) {
 570         $was_registered = 1 if $type->register( $c, $action );
 571     }
 572
 573     if (not $was_registered) {
 574         foreach my $type ( @low_precedence_dtypes ) {
 575             $type->register( $c, $action );
 576         }
 577     }
 578
 579     my $namespace = $action->namespace;
 580     my $name      = $action->name;
 581
 582     my $container = $self->_find_or_create_action_container($namespace);
 583
 584     # Set the method value
 585     $container->add_action($action);
 586
 587     $self->_action_hash->{"$namespace/$name"} = $action;
 588     $self->_container_hash->{$namespace} = $container;
 589 }
 590
 591 sub _find_or_create_action_container {
 592     my ( $self, $namespace ) = @_;
 593
 594     my $tree ||= $self->_tree;
 595
 596     return $tree->getNodeValue unless $namespace;
 597
 598     my @namespace = split '/', $namespace;
 599     return $self->_find_or_create_namespace_node( $tree, @namespace )
 600       ->getNodeValue;
 601 }
 602
 603 sub _find_or_create_namespace_node {
 604     my ( $self, $parent, $part, @namespace ) = @_;
 605
 606     return $parent unless $part;
 607
 608     my $child =
 609       ( grep { $_->getNodeValue->part eq $part } $parent->getAllChildren )[0];
 610
 611     unless ($child) {
 612         my $container = Catalyst::ActionContainer->new($part);
 613         $parent->addChild( $child = Tree::Simple->new($container) );
 614     }
 615
 616     $self->_find_or_create_namespace_node( $child, @namespace );
 617 }
 618
 619 =head2 $self->setup_actions( $class, $context )
 620
 621 Loads all of the pre-load dispatch types, registers their actions and then
 622 loads all of the post-load dispatch types, and iterates over the tree of
 623 actions, displaying the debug information if appropriate.
 624
 625 =cut
 626
 627 sub setup_actions {
 628     my ( $self, $c ) = @_;
 629
 630     my @classes =
 631       $self->_load_dispatch_types( @{ $self->preload_dispatch_types } );
 632     @{ $self->_registered_dispatch_types }{@classes} = (1) x @classes;
 633
 634     foreach my $comp ( map @{$_}{sort keys %$_}, $c->components ) {
 635         $comp = $comp->() if is_plain_coderef($comp);
 636         $comp->register_actions($c) if $comp->can('register_actions');
 637     }
 638
 639     $self->_load_dispatch_types( @{ $self->postload_dispatch_types } );
 640
 641     return unless $c->debug;
 642     $self->_display_action_tables($c);
 643 }
 644
 645 sub _display_action_tables {
 646     my ($self, $c) = @_;
 647
 648     my $avail_width = Catalyst::Utils::term_width() - 12;
 649     my $col1_width = ($avail_width * .25) < 20 ? 20 : int($avail_width * .25);
 650     my $col2_width = ($avail_width * .50) < 36 ? 36 : int($avail_width * .50);
 651     my $col3_width =  $avail_width - $col1_width - $col2_width;
 652     my $privates = Text::SimpleTable->new(
 653         [ $col1_width, 'Private' ], [ $col2_width, 'Class' ], [ $col3_width, 'Method' ]
 654     );
 655
 656     my $has_private = 0;
 657     my $walker = sub {
 658         my ( $walker, $parent, $prefix ) = @_;
 659         $prefix .= $parent->getNodeValue || '';
 660         $prefix .= '/' unless $prefix =~ /\/$/;
 661         my $node = $parent->getNodeValue->actions;
 662
 663         for my $action ( keys %{$node} ) {
 664             my $action_obj = $node->{$action};
 665             next
 666               if ( ( $action =~ /^_.*/ )
 667                 && ( !$c->config->{show_internal_actions} ) );
 668             $privates->row( "$prefix$action", $action_obj->class, $action );
 669             $has_private = 1;
 670         }
 671
 672         $walker->( $walker, $_, $prefix ) for $parent->getAllChildren;
 673     };
 674
 675     $walker->( $walker, $self->_tree, '' );
 676     $c->log->debug( "Loaded Private actions:\n" . $privates->draw . "\n" )
 677       if $has_private;
 678
 679     # List all public actions
 680     $_->list($c) for @{ $self->dispatch_types };
 681 }
 682
 683 sub _load_dispatch_types {
 684     my ( $self, @types ) = @_;
 685
 686     my @loaded;
 687     # Preload action types
 688     for my $type (@types) {
 689         # first param is undef because we cannot get the appclass
 690         my $class = Catalyst::Utils::resolve_namespace(undef, 'Catalyst::DispatchType', $type);
 691
 692         my ($success, $error) = try_load_class($class);
 693         Catalyst::Exception->throw( message => $error ) if not $success;
 694         push @{ $self->dispatch_types }, $class->new;
 695
 696         push @loaded, $class;
 697     }
 698
 699     return @loaded;
 700 }
 701
 702 =head2 $self->dispatch_type( $type )
 703
 704 Get the DispatchType object of the relevant type, i.e. passing C<$type> of
 705 C<Chained> would return a L<Catalyst::DispatchType::Chained> object (assuming
 706 of course it's being used.)
 707
 708 =cut
 709
 710 sub dispatch_type {
 711     my ($self, $name) = @_;
 712
 713     # first param is undef because we cannot get the appclass
 714     $name = Catalyst::Utils::resolve_namespace(undef, 'Catalyst::DispatchType', $name);
 715
 716     for (@{ $self->dispatch_types }) {
 717         return $_ if ref($_) eq $name;
 718     }
 719     return undef;
 720 }
 721
 722 sub _check_deprecated_dispatch_type {
 723     my ($self, $key, $load_failed) = @_;
 724
 725     return unless $key =~ /^(Local)?Regexp?/;
 726
 727     # TODO: Should these throw an exception rather than just warning?
 728     if ($load_failed) {
 729         warn(   "Attempt to use deprecated $key dispatch type.\n"
 730               . "  Use Chained methods or install the standalone\n"
 731               . "  Catalyst::DispatchType::Regex if necessary.\n" );
 732     } elsif ( !defined $Catalyst::DispatchType::Regex::VERSION
 733         || $Catalyst::DispatchType::Regex::VERSION le '5.90020' ) {
 734         # We loaded the old core version of the Regex module this will break
 735         warn(   "The $key DispatchType has been removed from Catalyst core.\n"
 736               . "  An old version of the core Catalyst::DispatchType::Regex\n"
 737               . "  has been loaded and will likely fail. Please remove\n"
 738               . "   $INC{'Catalyst/DispatchType/Regex.pm'}\n"
 739               . "  and use Chained methods or install the standalone\n"
 740               . "  Catalyst::DispatchType::Regex if necessary.\n" );
 741     }
 742 }
 743
 744 use Moose;
 745
 746 # 5.70 backwards compatibility hacks.
 747
 748 # Various plugins (e.g. Plugin::Server and Plugin::Authorization::ACL)
 749 # need the methods here which *should* be private..
 750
 751 # You should be able to use get_actions or get_containers appropriately
 752 # instead of relying on these methods which expose implementation details
 753 # of the dispatcher..
 754 #
 755 # IRC backlog included below, please come ask if this doesn't work for you.
 756 #
 757 # <@t0m> 5.80, the state of. There are things in the dispatcher which have
 758 #        been deprecated, that we yell at anyone for using, which there isn't
 759 #        a good alternative for yet..
 760 # <@mst> er, get_actions/get_containers provides that doesn't it?
 761 # <@mst> DispatchTypes are loaded on demand anyway
 762 # <@t0m> I'm thinking of things like _tree which is aliased to 'tree' with
 763 #        warnings otherwise shit breaks.. We're issuing warnings about the
 764 #        correct set of things which you shouldn't be calling..
 765 # <@mst> right
 766 # <@mst> basically, I don't see there's a need for a replacement for anything
 767 # <@mst> it was never a good idea to call ->tree
 768 # <@mst> nothingmuch was the only one who did AFAIK
 769 # <@mst> and he admitted it was a hack ;)
 770
 771 # See also t/lib/TestApp/Plugin/AddDispatchTypes.pm
 772
 773 # Alias _method_name to method_name, add a before modifier to warn..
 774 foreach my $public_method_name (qw/
 775         tree
 776         registered_dispatch_types
 777         method_action_class
 778         action_hash
 779         container_hash
 780     /) {
 781     my $private_method_name = '_' . $public_method_name;
 782     my $meta = __PACKAGE__->meta; # Calling meta method here fine as we happen at compile time.
 783     $meta->add_method($public_method_name, $meta->get_method($private_method_name));
 784     {
 785         my %package_hash; # Only warn once per method, per package. These are infrequent enough that
 786                           # I haven't provided a way to disable them, patches welcome.
 787         $meta->add_before_method_modifier($public_method_name, sub {
 788             my $class = caller(2);
 789             chomp($class);
 790             $package_hash{$class}++ || do {
 791                 warn("Class $class is calling the deprecated method\n"
 792                     . "  Catalyst::Dispatcher::$public_method_name,\n"
 793                     . "  this will be removed in Catalyst 5.9\n");
 794             };
 795         });
 796     }
 797 }
 798 # End 5.70 backwards compatibility hacks.
 799
 800 __PACKAGE__->meta->make_immutable;
 801
 802 =head2 meta
 803
 804 Provided by Moose
 805
 806 =head1 AUTHORS
 807
 808 Catalyst Contributors, see Catalyst.pm
 809
 810 =head1 COPYRIGHT
 811
 812 This library is free software. You can redistribute it and/or modify it under
 813 the same terms as Perl itself.
 814
 815 =cut
 816
 817 1;