lib/Catalyst.pm

   1 package Catalyst;
   2
   3 use Moose;
   4 use Moose::Meta::Class ();
   5 extends 'Catalyst::Component';
   6 use Moose::Util qw/find_meta/;
   7 use B::Hooks::EndOfScope ();
   8 use Catalyst::Exception;
   9 use Catalyst::Exception::Detach;
  10 use Catalyst::Exception::Go;
  11 use Catalyst::Log;
  12 use Catalyst::Request;
  13 use Catalyst::Request::Upload;
  14 use Catalyst::Response;
  15 use Catalyst::Utils;
  16 use Catalyst::Controller;
  17 use Devel::InnerPackage ();
  18 use File::stat;
  19 use Module::Pluggable::Object ();
  20 use Text::SimpleTable ();
  21 use Path::Class::Dir ();
  22 use Path::Class::File ();
  23 use URI ();
  24 use URI::http;
  25 use URI::https;
  26 use Tree::Simple qw/use_weak_refs/;
  27 use Tree::Simple::Visitor::FindByUID;
  28 use Class::C3::Adopt::NEXT;
  29 use List::MoreUtils qw/uniq/;
  30 use attributes;
  31 use utf8;
  32 use Carp qw/croak carp shortmess/;
  33
  34 BEGIN { require 5.008004; }
  35
  36 has stack => (is => 'ro', default => sub { [] });
  37 has stash => (is => 'rw', default => sub { {} });
  38 has state => (is => 'rw', default => 0);
  39 has stats => (is => 'rw');
  40 has action => (is => 'rw');
  41 has counter => (is => 'rw', default => sub { {} });
  42 has request => (is => 'rw', default => sub { $_[0]->request_class->new({}) }, required => 1, lazy => 1);
  43 has response => (is => 'rw', default => sub { $_[0]->response_class->new({}) }, required => 1, lazy => 1);
  44 has namespace => (is => 'rw');
  45
  46 sub depth { scalar @{ shift->stack || [] }; }
  47 sub comp { shift->component(@_) }
  48
  49 sub req {
  50     my $self = shift; return $self->request(@_);
  51 }
  52 sub res {
  53     my $self = shift; return $self->response(@_);
  54 }
  55
  56 # For backwards compatibility
  57 sub finalize_output { shift->finalize_body(@_) };
  58
  59 # For statistics
  60 our $COUNT     = 1;
  61 our $START     = time;
  62 our $RECURSION = 1000;
  63 our $DETACH    = Catalyst::Exception::Detach->new;
  64 our $GO        = Catalyst::Exception::Go->new;
  65
  66 #I imagine that very few of these really need to be class variables. if any.
  67 #maybe we should just make them attributes with a default?
  68 __PACKAGE__->mk_classdata($_)
  69   for qw/components arguments dispatcher engine log dispatcher_class
  70   engine_class context_class request_class response_class stats_class
  71   setup_finished/;
  72
  73 __PACKAGE__->dispatcher_class('Catalyst::Dispatcher');
  74 __PACKAGE__->engine_class('Catalyst::Engine::CGI');
  75 __PACKAGE__->request_class('Catalyst::Request');
  76 __PACKAGE__->response_class('Catalyst::Response');
  77 __PACKAGE__->stats_class('Catalyst::Stats');
  78
  79 # Remember to update this in Catalyst::Runtime as well!
  80
  81 our $VERSION = '5.80018';
  82 $VERSION = eval $VERSION;
  83
  84 sub import {
  85     my ( $class, @arguments ) = @_;
  86
  87     # We have to limit $class to Catalyst to avoid pushing Catalyst upon every
  88     # callers @ISA.
  89     return unless $class eq 'Catalyst';
  90
  91     my $caller = caller();
  92     return if $caller eq 'main';
  93
  94     my $meta = Moose::Meta::Class->initialize($caller);
  95     unless ( $caller->isa('Catalyst') ) {
  96         my @superclasses = ($meta->superclasses, $class, 'Catalyst::Controller');
  97         $meta->superclasses(@superclasses);
  98     }
  99     # Avoid possible C3 issues if 'Moose::Object' is already on RHS of MyApp
 100     $meta->superclasses(grep { $_ ne 'Moose::Object' } $meta->superclasses);
 101
 102     unless( $meta->has_method('meta') ){
 103         $meta->add_method(meta => sub { Moose::Meta::Class->initialize("${caller}") } );
 104     }
 105
 106     $caller->arguments( [@arguments] );
 107     $caller->setup_home;
 108 }
 109
 110 sub _application { $_[0] }
 111
 112 =head1 NAME
 113
 114 Catalyst - The Elegant MVC Web Application Framework
 115
 116 =head1 SYNOPSIS
 117
 118 See the L<Catalyst::Manual> distribution for comprehensive
 119 documentation and tutorials.
 120
 121     # Install Catalyst::Devel for helpers and other development tools
 122     # use the helper to create a new application
 123     catalyst.pl MyApp
 124
 125     # add models, views, controllers
 126     script/myapp_create.pl model MyDatabase DBIC::Schema create=static dbi:SQLite:/path/to/db
 127     script/myapp_create.pl view MyTemplate TT
 128     script/myapp_create.pl controller Search
 129
 130     # built in testserver -- use -r to restart automatically on changes
 131     # --help to see all available options
 132     script/myapp_server.pl
 133
 134     # command line testing interface
 135     script/myapp_test.pl /yada
 136
 137     ### in lib/MyApp.pm
 138     use Catalyst qw/-Debug/; # include plugins here as well
 139
 140     ### In lib/MyApp/Controller/Root.pm (autocreated)
 141     sub foo : Global { # called for /foo, /foo/1, /foo/1/2, etc.
 142         my ( $self, $c, @args ) = @_; # args are qw/1 2/ for /foo/1/2
 143         $c->stash->{template} = 'foo.tt'; # set the template
 144         # lookup something from db -- stash vars are passed to TT
 145         $c->stash->{data} =
 146           $c->model('Database::Foo')->search( { country => $args[0] } );
 147         if ( $c->req->params->{bar} ) { # access GET or POST parameters
 148             $c->forward( 'bar' ); # process another action
 149             # do something else after forward returns
 150         }
 151     }
 152
 153     # The foo.tt TT template can use the stash data from the database
 154     [% WHILE (item = data.next) %]
 155         [% item.foo %]
 156     [% END %]
 157
 158     # called for /bar/of/soap, /bar/of/soap/10, etc.
 159     sub bar : Path('/bar/of/soap') { ... }
 160
 161     # called for all actions, from the top-most controller downwards
 162     sub auto : Private {
 163         my ( $self, $c ) = @_;
 164         if ( !$c->user_exists ) { # Catalyst::Plugin::Authentication
 165             $c->res->redirect( '/login' ); # require login
 166             return 0; # abort request and go immediately to end()
 167         }
 168         return 1; # success; carry on to next action
 169     }
 170
 171     # called after all actions are finished
 172     sub end : Private {
 173         my ( $self, $c ) = @_;
 174         if ( scalar @{ $c->error } ) { ... } # handle errors
 175         return if $c->res->body; # already have a response
 176         $c->forward( 'MyApp::View::TT' ); # render template
 177     }
 178
 179     ### in MyApp/Controller/Foo.pm
 180     # called for /foo/bar
 181     sub bar : Local { ... }
 182
 183     # called for /blargle
 184     sub blargle : Global { ... }
 185
 186     # an index action matches /foo, but not /foo/1, etc.
 187     sub index : Private { ... }
 188
 189     ### in MyApp/Controller/Foo/Bar.pm
 190     # called for /foo/bar/baz
 191     sub baz : Local { ... }
 192
 193     # first Root auto is called, then Foo auto, then this
 194     sub auto : Private { ... }
 195
 196     # powerful regular expression paths are also possible
 197     sub details : Regex('^product/(\w+)/details$') {
 198         my ( $self, $c ) = @_;
 199         # extract the (\w+) from the URI
 200         my $product = $c->req->captures->[0];
 201     }
 202
 203 See L<Catalyst::Manual::Intro> for additional information.
 204
 205 =head1 DESCRIPTION
 206
 207 Catalyst is a modern framework for making web applications without the
 208 pain usually associated with this process. This document is a reference
 209 to the main Catalyst application. If you are a new user, we suggest you
 210 start with L<Catalyst::Manual::Tutorial> or L<Catalyst::Manual::Intro>.
 211
 212 See L<Catalyst::Manual> for more documentation.
 213
 214 Catalyst plugins can be loaded by naming them as arguments to the "use
 215 Catalyst" statement. Omit the C<Catalyst::Plugin::> prefix from the
 216 plugin name, i.e., C<Catalyst::Plugin::My::Module> becomes
 217 C<My::Module>.
 218
 219     use Catalyst qw/My::Module/;
 220
 221 If your plugin starts with a name other than C<Catalyst::Plugin::>, you can
 222 fully qualify the name by using a unary plus:
 223
 224     use Catalyst qw/
 225         My::Module
 226         +Fully::Qualified::Plugin::Name
 227     /;
 228
 229 Special flags like C<-Debug> and C<-Engine> can also be specified as
 230 arguments when Catalyst is loaded:
 231
 232     use Catalyst qw/-Debug My::Module/;
 233
 234 The position of plugins and flags in the chain is important, because
 235 they are loaded in the order in which they appear.
 236
 237 The following flags are supported:
 238
 239 =head2 -Debug
 240
 241 Enables debug output. You can also force this setting from the system
 242 environment with CATALYST_DEBUG or <MYAPP>_DEBUG. The environment
 243 settings override the application, with <MYAPP>_DEBUG having the highest
 244 priority.
 245
 246 =head2 -Engine
 247
 248 Forces Catalyst to use a specific engine. Omit the
 249 C<Catalyst::Engine::> prefix of the engine name, i.e.:
 250
 251     use Catalyst qw/-Engine=CGI/;
 252
 253 =head2 -Home
 254
 255 Forces Catalyst to use a specific home directory, e.g.:
 256
 257     use Catalyst qw[-Home=/usr/mst];
 258
 259 This can also be done in the shell environment by setting either the
 260 C<CATALYST_HOME> environment variable or C<MYAPP_HOME>; where C<MYAPP>
 261 is replaced with the uppercased name of your application, any "::" in
 262 the name will be replaced with underscores, e.g. MyApp::Web should use
 263 MYAPP_WEB_HOME. If both variables are set, the MYAPP_HOME one will be used.
 264
 265 If none of these are set, Catalyst will attempt to automatically detect the
 266 home directory. If you are working in a development envirnoment, Catalyst
 267 will try and find the directory containing either Makefile.PL, Build.PL or
 268 dist.ini. If the application has been installed into the system (i.e.
 269 you have done C<make install>), then Catalyst will use the path to your
 270 application module, without the .pm extension (ie, /foo/MyApp if your
 271 application was installed at /foo/MyApp.pm)
 272
 273 =head2 -Log
 274
 275     use Catalyst '-Log=warn,fatal,error';
 276
 277 Specifies a comma-delimited list of log levels.
 278
 279 =head2 -Stats
 280
 281 Enables statistics collection and reporting. You can also force this setting
 282 from the system environment with CATALYST_STATS or <MYAPP>_STATS. The
 283 environment settings override the application, with <MYAPP>_STATS having the
 284 highest priority.
 285
 286 e.g.
 287
 288    use Catalyst qw/-Stats=1/
 289
 290 =head1 METHODS
 291
 292 =head2 INFORMATION ABOUT THE CURRENT REQUEST
 293
 294 =head2 $c->action
 295
 296 Returns a L<Catalyst::Action> object for the current action, which
 297 stringifies to the action name. See L<Catalyst::Action>.
 298
 299 =head2 $c->namespace
 300
 301 Returns the namespace of the current action, i.e., the URI prefix
 302 corresponding to the controller of the current action. For example:
 303
 304     # in Controller::Foo::Bar
 305     $c->namespace; # returns 'foo/bar';
 306
 307 =head2 $c->request
 308
 309 =head2 $c->req
 310
 311 Returns the current L<Catalyst::Request> object, giving access to
 312 information about the current client request (including parameters,
 313 cookies, HTTP headers, etc.). See L<Catalyst::Request>.
 314
 315 =head2 REQUEST FLOW HANDLING
 316
 317 =head2 $c->forward( $action [, \@arguments ] )
 318
 319 =head2 $c->forward( $class, $method, [, \@arguments ] )
 320
 321 Forwards processing to another action, by its private name. If you give a
 322 class name but no method, C<process()> is called. You may also optionally
 323 pass arguments in an arrayref. The action will receive the arguments in
 324 C<@_> and C<< $c->req->args >>. Upon returning from the function,
 325 C<< $c->req->args >> will be restored to the previous values.
 326
 327 Any data C<return>ed from the action forwarded to, will be returned by the
 328 call to forward.
 329
 330     my $foodata = $c->forward('/foo');
 331     $c->forward('index');
 332     $c->forward(qw/Model::DBIC::Foo do_stuff/);
 333     $c->forward('View::TT');
 334
 335 Note that L<< forward|/"$c->forward( $action [, \@arguments ] )" >> implies
 336 an C<< eval { } >> around the call (actually
 337 L<< execute|/"$c->execute( $class, $coderef )" >> does), thus de-fatalizing
 338 all 'dies' within the called action. If you want C<die> to propagate you
 339 need to do something like:
 340
 341     $c->forward('foo');
 342     die join "\n", @{ $c->error } if @{ $c->error };
 343
 344 Or make sure to always return true values from your actions and write
 345 your code like this:
 346
 347     $c->forward('foo') || return;
 348
 349 Another note is that C<< $c->forward >> always returns a scalar because it
 350 actually returns $c->state which operates in a scalar context.
 351 Thus, something like:
 352
 353     return @array;
 354
 355 in an action that is forwarded to is going to return a scalar,
 356 i.e. how many items are in that array, which is probably not what you want.
 357 If you need to return an array then return a reference to it,
 358 or stash it like so:
 359
 360     $c->stash->{array} = \@array;
 361
 362 and access it from the stash.
 363
 364 =cut
 365
 366 sub forward { my $c = shift; no warnings 'recursion'; $c->dispatcher->forward( $c, @_ ) }
 367
 368 =head2 $c->detach( $action [, \@arguments ] )
 369
 370 =head2 $c->detach( $class, $method, [, \@arguments ] )
 371
 372 =head2 $c->detach()
 373
 374 The same as L<< forward|/"$c->forward( $action [, \@arguments ] )" >>, but
 375 doesn't return to the previous action when processing is finished.
 376
 377 When called with no arguments it escapes the processing chain entirely.
 378
 379 =cut
 380
 381 sub detach { my $c = shift; $c->dispatcher->detach( $c, @_ ) }
 382
 383 =head2 $c->visit( $action [, \@captures, \@arguments ] )
 384
 385 =head2 $c->visit( $class, $method, [, \@captures, \@arguments ] )
 386
 387 Almost the same as L<< forward|/"$c->forward( $action [, \@arguments ] )" >>,
 388 but does a full dispatch, instead of just calling the new C<$action> /
 389 C<< $class->$method >>. This means that C<begin>, C<auto> and the method
 390 you go to are called, just like a new request.
 391
 392 In addition both C<< $c->action >> and C<< $c->namespace >> are localized.
 393 This means, for example, that C<< $c->action >> methods such as
 394 L<name|Catalyst::Action/name>, L<class|Catalyst::Action/class> and
 395 L<reverse|Catalyst::Action/reverse> return information for the visited action
 396 when they are invoked within the visited action.  This is different from the
 397 behavior of L<< forward|/"$c->forward( $action [, \@arguments ] )" >>, which
 398 continues to use the $c->action object from the caller action even when
 399 invoked from the callee.
 400
 401 C<< $c->stash >> is kept unchanged.
 402
 403 In effect, L<< visit|/"$c->visit( $action [, \@captures, \@arguments ] )" >>
 404 allows you to "wrap" another action, just as it would have been called by
 405 dispatching from a URL, while the analogous
 406 L<< go|/"$c->go( $action [, \@captures, \@arguments ] )" >> allows you to
 407 transfer control to another action as if it had been reached directly from a URL.
 408
 409 =cut
 410
 411 sub visit { my $c = shift; $c->dispatcher->visit( $c, @_ ) }
 412
 413 =head2 $c->go( $action [, \@captures, \@arguments ] )
 414
 415 =head2 $c->go( $class, $method, [, \@captures, \@arguments ] )
 416
 417 The relationship between C<go> and
 418 L<< visit|/"$c->visit( $action [, \@captures, \@arguments ] )" >> is the same as
 419 the relationship between
 420 L<< forward|/"$c->forward( $class, $method, [, \@arguments ] )" >> and
 421 L<< detach|/"$c->detach( $action [, \@arguments ] )" >>. Like C<< $c->visit >>,
 422 C<< $c->go >> will perform a full dispatch on the specified action or method,
 423 with localized C<< $c->action >> and C<< $c->namespace >>. Like C<detach>,
 424 C<go> escapes the processing of the current request chain on completion, and
 425 does not return to its caller.
 426
 427 =cut
 428
 429 sub go { my $c = shift; $c->dispatcher->go( $c, @_ ) }
 430
 431 =head2 $c->response
 432
 433 =head2 $c->res
 434
 435 Returns the current L<Catalyst::Response> object, see there for details.
 436
 437 =head2 $c->stash
 438
 439 Returns a hashref to the stash, which may be used to store data and pass
 440 it between components during a request. You can also set hash keys by
 441 passing arguments. The stash is automatically sent to the view. The
 442 stash is cleared at the end of a request; it cannot be used for
 443 persistent storage (for this you must use a session; see
 444 L<Catalyst::Plugin::Session> for a complete system integrated with
 445 Catalyst).
 446
 447     $c->stash->{foo} = $bar;
 448     $c->stash( { moose => 'majestic', qux => 0 } );
 449     $c->stash( bar => 1, gorch => 2 ); # equivalent to passing a hashref
 450
 451     # stash is automatically passed to the view for use in a template
 452     $c->forward( 'MyApp::View::TT' );
 453
 454 =cut
 455
 456 around stash => sub {
 457     my $orig = shift;
 458     my $c = shift;
 459     my $stash = $orig->($c);
 460     if (@_) {
 461         my $new_stash = @_ > 1 ? {@_} : $_[0];
 462         croak('stash takes a hash or hashref') unless ref $new_stash;
 463         foreach my $key ( keys %$new_stash ) {
 464           $stash->{$key} = $new_stash->{$key};
 465         }
 466     }
 467
 468     return $stash;
 469 };
 470
 471
 472 =head2 $c->error
 473
 474 =head2 $c->error($error, ...)
 475
 476 =head2 $c->error($arrayref)
 477
 478 Returns an arrayref containing error messages.  If Catalyst encounters an
 479 error while processing a request, it stores the error in $c->error.  This
 480 method should only be used to store fatal error messages.
 481
 482     my @error = @{ $c->error };
 483
 484 Add a new error.
 485
 486     $c->error('Something bad happened');
 487
 488 =cut
 489
 490 sub error {
 491     my $c = shift;
 492     if ( $_[0] ) {
 493         my $error = ref $_[0] eq 'ARRAY' ? $_[0] : [@_];
 494         croak @$error unless ref $c;
 495         push @{ $c->{error} }, @$error;
 496     }
 497     elsif ( defined $_[0] ) { $c->{error} = undef }
 498     return $c->{error} || [];
 499 }
 500
 501
 502 =head2 $c->state
 503
 504 Contains the return value of the last executed action.
 505 Note that << $c->state >> operates in a scalar context which means that all
 506 values it returns are scalar.
 507
 508 =head2 $c->clear_errors
 509
 510 Clear errors.  You probably don't want to clear the errors unless you are
 511 implementing a custom error screen.
 512
 513 This is equivalent to running
 514
 515     $c->error(0);
 516
 517 =cut
 518
 519 sub clear_errors {
 520     my $c = shift;
 521     $c->error(0);
 522 }
 523
 524 sub _comp_search_prefixes {
 525     my $c = shift;
 526     return map $c->components->{ $_ }, $c->_comp_names_search_prefixes(@_);
 527 }
 528
 529 # search components given a name and some prefixes
 530 sub _comp_names_search_prefixes {
 531     my ( $c, $name, @prefixes ) = @_;
 532     my $appclass = ref $c || $c;
 533     my $filter   = "^${appclass}::(" . join( '|', @prefixes ) . ')::';
 534     $filter = qr/$filter/; # Compile regex now rather than once per loop
 535
 536     # map the original component name to the sub part that we will search against
 537     my %eligible = map { my $n = $_; $n =~ s{^$appclass\::[^:]+::}{}; $_ => $n; }
 538         grep { /$filter/ } keys %{ $c->components };
 539
 540     # undef for a name will return all
 541     return keys %eligible if !defined $name;
 542
 543     my $query  = ref $name ? $name : qr/^$name$/i;
 544     my @result = grep { $eligible{$_} =~ m{$query} } keys %eligible;
 545
 546     return @result if @result;
 547
 548     # if we were given a regexp to search against, we're done.
 549     return if ref $name;
 550
 551     # skip regexp fallback if configured
 552     return
 553         if $appclass->config->{disable_component_resolution_regex_fallback};
 554
 555     # regexp fallback
 556     $query  = qr/$name/i;
 557     @result = grep { $eligible{ $_ } =~ m{$query} } keys %eligible;
 558
 559     # no results? try against full names
 560     if( !@result ) {
 561         @result = grep { m{$query} } keys %eligible;
 562     }
 563
 564     # don't warn if we didn't find any results, it just might not exist
 565     if( @result ) {
 566         # Disgusting hack to work out correct method name
 567         my $warn_for = lc $prefixes[0];
 568         my $msg = "Used regexp fallback for \$c->${warn_for}('${name}'), which found '" .
 569            (join '", "', @result) . "'. Relying on regexp fallback behavior for " .
 570            "component resolution is unreliable and unsafe.";
 571         my $short = $result[0];
 572         # remove the component namespace prefix
 573         $short =~ s/.*?(Model|Controller|View):://;
 574         my $shortmess = Carp::shortmess('');
 575         if ($shortmess =~ m#Catalyst/Plugin#) {
 576            $msg .= " You probably need to set '$short' instead of '${name}' in this " .
 577               "plugin's config";
 578         } elsif ($shortmess =~ m#Catalyst/lib/(View|Controller)#) {
 579            $msg .= " You probably need to set '$short' instead of '${name}' in this " .
 580               "component's config";
 581         } else {
 582            $msg .= " You probably meant \$c->${warn_for}('$short') instead of \$c->${warn_for}('${name}'), " .
 583               "but if you really wanted to search, pass in a regexp as the argument " .
 584               "like so: \$c->${warn_for}(qr/${name}/)";
 585         }
 586         $c->log->warn( "${msg}$shortmess" );
 587     }
 588
 589     return @result;
 590 }
 591
 592 # Find possible names for a prefix
 593 sub _comp_names {
 594     my ( $c, @prefixes ) = @_;
 595     my $appclass = ref $c || $c;
 596
 597     my $filter = "^${appclass}::(" . join( '|', @prefixes ) . ')::';
 598
 599     my @names = map { s{$filter}{}; $_; }
 600         $c->_comp_names_search_prefixes( undef, @prefixes );
 601
 602     return @names;
 603 }
 604
 605 # Filter a component before returning by calling ACCEPT_CONTEXT if available
 606 sub _filter_component {
 607     my ( $c, $comp, @args ) = @_;
 608
 609     if ( eval { $comp->can('ACCEPT_CONTEXT'); } ) {
 610         return $comp->ACCEPT_CONTEXT( $c, @args );
 611     }
 612
 613     return $comp;
 614 }
 615
 616 =head2 COMPONENT ACCESSORS
 617
 618 =head2 $c->controller($name)
 619
 620 Gets a L<Catalyst::Controller> instance by name.
 621
 622     $c->controller('Foo')->do_stuff;
 623
 624 If the name is omitted, will return the controller for the dispatched
 625 action.
 626
 627 If you want to search for controllers, pass in a regexp as the argument.
 628
 629     # find all controllers that start with Foo
 630     my @foo_controllers = $c->controller(qr{^Foo});
 631
 632
 633 =cut
 634
 635 sub controller {
 636     my ( $c, $name, @args ) = @_;
 637
 638     if( $name ) {
 639         my @result = $c->_comp_search_prefixes( $name, qw/Controller C/ );
 640         return map { $c->_filter_component( $_, @args ) } @result if ref $name;
 641         return $c->_filter_component( $result[ 0 ], @args );
 642     }
 643
 644     return $c->component( $c->action->class );
 645 }
 646
 647 =head2 $c->model($name)
 648
 649 Gets a L<Catalyst::Model> instance by name.
 650
 651     $c->model('Foo')->do_stuff;
 652
 653 Any extra arguments are directly passed to ACCEPT_CONTEXT.
 654
 655 If the name is omitted, it will look for
 656  - a model object in $c->stash->{current_model_instance}, then
 657  - a model name in $c->stash->{current_model}, then
 658  - a config setting 'default_model', or
 659  - check if there is only one model, and return it if that's the case.
 660
 661 If you want to search for models, pass in a regexp as the argument.
 662
 663     # find all models that start with Foo
 664     my @foo_models = $c->model(qr{^Foo});
 665
 666 =cut
 667
 668 sub model {
 669     my ( $c, $name, @args ) = @_;
 670     my $appclass = ref($c) || $c;
 671     if( $name ) {
 672         my @result = $c->_comp_search_prefixes( $name, qw/Model M/ );
 673         return map { $c->_filter_component( $_, @args ) } @result if ref $name;
 674         return $c->_filter_component( $result[ 0 ], @args );
 675     }
 676
 677     if (ref $c) {
 678         return $c->stash->{current_model_instance}
 679           if $c->stash->{current_model_instance};
 680         return $c->model( $c->stash->{current_model} )
 681           if $c->stash->{current_model};
 682     }
 683     return $c->model( $appclass->config->{default_model} )
 684       if $appclass->config->{default_model};
 685
 686     my( $comp, $rest ) = $c->_comp_search_prefixes( undef, qw/Model M/);
 687
 688     if( $rest ) {
 689         $c->log->warn( Carp::shortmess('Calling $c->model() will return a random model unless you specify one of:') );
 690         $c->log->warn( '* $c->config(default_model => "the name of the default model to use")' );
 691         $c->log->warn( '* $c->stash->{current_model} # the name of the model to use for this request' );
 692         $c->log->warn( '* $c->stash->{current_model_instance} # the instance of the model to use for this request' );
 693         $c->log->warn( 'NB: in version 5.81, the "random" behavior will not work at all.' );
 694     }
 695
 696     return $c->_filter_component( $comp );
 697 }
 698
 699
 700 =head2 $c->view($name)
 701
 702 Gets a L<Catalyst::View> instance by name.
 703
 704     $c->view('Foo')->do_stuff;
 705
 706 Any extra arguments are directly passed to ACCEPT_CONTEXT.
 707
 708 If the name is omitted, it will look for
 709  - a view object in $c->stash->{current_view_instance}, then
 710  - a view name in $c->stash->{current_view}, then
 711  - a config setting 'default_view', or
 712  - check if there is only one view, and return it if that's the case.
 713
 714 If you want to search for views, pass in a regexp as the argument.
 715
 716     # find all views that start with Foo
 717     my @foo_views = $c->view(qr{^Foo});
 718
 719 =cut
 720
 721 sub view {
 722     my ( $c, $name, @args ) = @_;
 723
 724     my $appclass = ref($c) || $c;
 725     if( $name ) {
 726         my @result = $c->_comp_search_prefixes( $name, qw/View V/ );
 727         return map { $c->_filter_component( $_, @args ) } @result if ref $name;
 728         return $c->_filter_component( $result[ 0 ], @args );
 729     }
 730
 731     if (ref $c) {
 732         return $c->stash->{current_view_instance}
 733           if $c->stash->{current_view_instance};
 734         return $c->view( $c->stash->{current_view} )
 735           if $c->stash->{current_view};
 736     }
 737     return $c->view( $appclass->config->{default_view} )
 738       if $appclass->config->{default_view};
 739
 740     my( $comp, $rest ) = $c->_comp_search_prefixes( undef, qw/View V/);
 741
 742     if( $rest ) {
 743         $c->log->warn( 'Calling $c->view() will return a random view unless you specify one of:' );
 744         $c->log->warn( '* $c->config(default_view => "the name of the default view to use")' );
 745         $c->log->warn( '* $c->stash->{current_view} # the name of the view to use for this request' );
 746         $c->log->warn( '* $c->stash->{current_view_instance} # the instance of the view to use for this request' );
 747         $c->log->warn( 'NB: in version 5.81, the "random" behavior will not work at all.' );
 748     }
 749
 750     return $c->_filter_component( $comp );
 751 }
 752
 753 =head2 $c->controllers
 754
 755 Returns the available names which can be passed to $c->controller
 756
 757 =cut
 758
 759 sub controllers {
 760     my ( $c ) = @_;
 761     return $c->_comp_names(qw/Controller C/);
 762 }
 763
 764 =head2 $c->models
 765
 766 Returns the available names which can be passed to $c->model
 767
 768 =cut
 769
 770 sub models {
 771     my ( $c ) = @_;
 772     return $c->_comp_names(qw/Model M/);
 773 }
 774
 775
 776 =head2 $c->views
 777
 778 Returns the available names which can be passed to $c->view
 779
 780 =cut
 781
 782 sub views {
 783     my ( $c ) = @_;
 784     return $c->_comp_names(qw/View V/);
 785 }
 786
 787 =head2 $c->comp($name)
 788
 789 =head2 $c->component($name)
 790
 791 Gets a component object by name. This method is not recommended,
 792 unless you want to get a specific component by full
 793 class. C<< $c->controller >>, C<< $c->model >>, and C<< $c->view >>
 794 should be used instead.
 795
 796 If C<$name> is a regexp, a list of components matched against the full
 797 component name will be returned.
 798
 799 If Catalyst can't find a component by name, it will fallback to regex
 800 matching by default. To disable this behaviour set
 801 disable_component_resolution_regex_fallback to a true value.
 802
 803     __PACKAGE__->config( disable_component_resolution_regex_fallback => 1 );
 804
 805 =cut
 806
 807 sub component {
 808     my ( $c, $name, @args ) = @_;
 809
 810     if( $name ) {
 811         my $comps = $c->components;
 812
 813         if( !ref $name ) {
 814             # is it the exact name?
 815             return $c->_filter_component( $comps->{ $name }, @args )
 816                        if exists $comps->{ $name };
 817
 818             # perhaps we just omitted "MyApp"?
 819             my $composed = ( ref $c || $c ) . "::${name}";
 820             return $c->_filter_component( $comps->{ $composed }, @args )
 821                        if exists $comps->{ $composed };
 822
 823             # search all of the models, views and controllers
 824             my( $comp ) = $c->_comp_search_prefixes( $name, qw/Model M Controller C View V/ );
 825             return $c->_filter_component( $comp, @args ) if $comp;
 826         }
 827
 828         # This is here so $c->comp( '::M::' ) works
 829         my $query = ref $name ? $name : qr{$name}i;
 830
 831         my @result = grep { m{$query} } keys %{ $c->components };
 832         return map { $c->_filter_component( $_, @args ) } @result if ref $name;
 833
 834         if( $result[ 0 ] ) {
 835             $c->log->warn( Carp::shortmess(qq(Found results for "${name}" using regexp fallback)) );
 836             $c->log->warn( 'Relying on the regexp fallback behavior for component resolution' );
 837             $c->log->warn( 'is unreliable and unsafe. You have been warned' );
 838             return $c->_filter_component( $result[ 0 ], @args );
 839         }
 840
 841         # I would expect to return an empty list here, but that breaks back-compat
 842     }
 843
 844     # fallback
 845     return sort keys %{ $c->components };
 846 }
 847
 848 =head2 CLASS DATA AND HELPER CLASSES
 849
 850 =head2 $c->config
 851
 852 Returns or takes a hashref containing the application's configuration.
 853
 854     __PACKAGE__->config( { db => 'dsn:SQLite:foo.db' } );
 855
 856 You can also use a C<YAML>, C<XML> or L<Config::General> config file
 857 like C<myapp.conf> in your applications home directory. See
 858 L<Catalyst::Plugin::ConfigLoader>.
 859
 860 =head3 Cascading configuration
 861
 862 The config method is present on all Catalyst components, and configuration
 863 will be merged when an application is started. Configuration loaded with
 864 L<Catalyst::Plugin::ConfigLoader> takes precedence over other configuration,
 865 followed by configuration in your top level C<MyApp> class. These two
 866 configurations are merged, and then configuration data whose hash key matches a
 867 component name is merged with configuration for that component.
 868
 869 The configuration for a component is then passed to the C<new> method when a
 870 component is constructed.
 871
 872 For example:
 873
 874     MyApp->config({ 'Model::Foo' => { bar => 'baz', overrides => 'me' } });
 875     MyApp::Model::Foo->config({ quux => 'frob', 'overrides => 'this' });
 876
 877 will mean that C<MyApp::Model::Foo> receives the following data when
 878 constructed:
 879
 880     MyApp::Model::Foo->new({
 881         bar => 'baz',
 882         quux => 'frob',
 883         overrides => 'me',
 884     });
 885
 886 =cut
 887
 888 around config => sub {
 889     my $orig = shift;
 890     my $c = shift;
 891
 892     croak('Setting config after setup has been run is not allowed.')
 893         if ( @_ and $c->setup_finished );
 894
 895     $c->$orig(@_);
 896 };
 897
 898 =head2 $c->log
 899
 900 Returns the logging object instance. Unless it is already set, Catalyst
 901 sets this up with a L<Catalyst::Log> object. To use your own log class,
 902 set the logger with the C<< __PACKAGE__->log >> method prior to calling
 903 C<< __PACKAGE__->setup >>.
 904
 905  __PACKAGE__->log( MyLogger->new );
 906  __PACKAGE__->setup;
 907
 908 And later:
 909
 910     $c->log->info( 'Now logging with my own logger!' );
 911
 912 Your log class should implement the methods described in
 913 L<Catalyst::Log>.
 914
 915
 916 =head2 $c->debug
 917
 918 Returns 1 if debug mode is enabled, 0 otherwise.
 919
 920 You can enable debug mode in several ways:
 921
 922 =over
 923
 924 =item By calling myapp_server.pl with the -d flag
 925
 926 =item With the environment variables MYAPP_DEBUG, or CATALYST_DEBUG
 927
 928 =item The -Debug option in your MyApp.pm
 929
 930 =item By declaring C<sub debug { 1 }> in your MyApp.pm.
 931
 932 =back
 933
 934 Calling C<< $c->debug(1) >> has no effect.
 935
 936 =cut
 937
 938 sub debug { 0 }
 939
 940 =head2 $c->dispatcher
 941
 942 Returns the dispatcher instance. See L<Catalyst::Dispatcher>.
 943
 944 =head2 $c->engine
 945
 946 Returns the engine instance. See L<Catalyst::Engine>.
 947
 948
 949 =head2 UTILITY METHODS
 950
 951 =head2 $c->path_to(@path)
 952
 953 Merges C<@path> with C<< $c->config->{home} >> and returns a
 954 L<Path::Class::Dir> object. Note you can usually use this object as
 955 a filename, but sometimes you will have to explicitly stringify it
 956 yourself by calling the C<< ->stringify >> method.
 957
 958 For example:
 959
 960     $c->path_to( 'db', 'sqlite.db' );
 961
 962 =cut
 963
 964 sub path_to {
 965     my ( $c, @path ) = @_;
 966     my $path = Path::Class::Dir->new( $c->config->{home}, @path );
 967     if ( -d $path ) { return $path }
 968     else { return Path::Class::File->new( $c->config->{home}, @path ) }
 969 }
 970
 971 =head2 $c->plugin( $name, $class, @args )
 972
 973 Helper method for plugins. It creates a class data accessor/mutator and
 974 loads and instantiates the given class.
 975
 976     MyApp->plugin( 'prototype', 'HTML::Prototype' );
 977
 978     $c->prototype->define_javascript_functions;
 979
 980 B<Note:> This method of adding plugins is deprecated. The ability
 981 to add plugins like this B<will be removed> in a Catalyst 5.81.
 982 Please do not use this functionality in new code.
 983
 984 =cut
 985
 986 sub plugin {
 987     my ( $class, $name, $plugin, @args ) = @_;
 988
 989     # See block comment in t/unit_core_plugin.t
 990     $class->log->warn(qq/Adding plugin using the ->plugin method is deprecated, and will be removed in Catalyst 5.81/);
 991
 992     $class->_register_plugin( $plugin, 1 );
 993
 994     eval { $plugin->import };
 995     $class->mk_classdata($name);
 996     my $obj;
 997     eval { $obj = $plugin->new(@args) };
 998
 999     if ($@) {
1000         Catalyst::Exception->throw( message =>
1001               qq/Couldn't instantiate instant plugin "$plugin", "$@"/ );
1002     }
1003
1004     $class->$name($obj);
1005     $class->log->debug(qq/Initialized instant plugin "$plugin" as "$name"/)
1006       if $class->debug;
1007 }
1008
1009 =head2 MyApp->setup
1010
1011 Initializes the dispatcher and engine, loads any plugins, and loads the
1012 model, view, and controller components. You may also specify an array
1013 of plugins to load here, if you choose to not load them in the C<use
1014 Catalyst> line.
1015
1016     MyApp->setup;
1017     MyApp->setup( qw/-Debug/ );
1018
1019 =cut
1020
1021 sub setup {
1022     my ( $class, @arguments ) = @_;
1023     croak('Running setup more than once')
1024         if ( $class->setup_finished );
1025
1026     unless ( $class->isa('Catalyst') ) {
1027
1028         Catalyst::Exception->throw(
1029             message => qq/'$class' does not inherit from Catalyst/ );
1030     }
1031
1032     if ( $class->arguments ) {
1033         @arguments = ( @arguments, @{ $class->arguments } );
1034     }
1035
1036     # Process options
1037     my $flags = {};
1038
1039     foreach (@arguments) {
1040
1041         if (/^-Debug$/) {
1042             $flags->{log} =
1043               ( $flags->{log} ) ? 'debug,' . $flags->{log} : 'debug';
1044         }
1045         elsif (/^-(\w+)=?(.*)$/) {
1046             $flags->{ lc $1 } = $2;
1047         }
1048         else {
1049             push @{ $flags->{plugins} }, $_;
1050         }
1051     }
1052
1053     $class->setup_home( delete $flags->{home} );
1054
1055     $class->setup_log( delete $flags->{log} );
1056     $class->setup_plugins( delete $flags->{plugins} );
1057     $class->setup_dispatcher( delete $flags->{dispatcher} );
1058     $class->setup_engine( delete $flags->{engine} );
1059     $class->setup_stats( delete $flags->{stats} );
1060
1061     for my $flag ( sort keys %{$flags} ) {
1062
1063         if ( my $code = $class->can( 'setup_' . $flag ) ) {
1064             &$code( $class, delete $flags->{$flag} );
1065         }
1066         else {
1067             $class->log->warn(qq/Unknown flag "$flag"/);
1068         }
1069     }
1070
1071     eval { require Catalyst::Devel; };
1072     if( !$@ && $ENV{CATALYST_SCRIPT_GEN} && ( $ENV{CATALYST_SCRIPT_GEN} < $Catalyst::Devel::CATALYST_SCRIPT_GEN ) ) {
1073         $class->log->warn(<<"EOF");
1074 You are running an old script!
1075
1076   Please update by running (this will overwrite existing files):
1077     catalyst.pl -force -scripts $class
1078
1079   or (this will not overwrite existing files):
1080     catalyst.pl -scripts $class
1081
1082 EOF
1083     }
1084
1085     if ( $class->debug ) {
1086         my @plugins = map { "$_  " . ( $_->VERSION || '' ) } $class->registered_plugins;
1087
1088         if (@plugins) {
1089             my $column_width = Catalyst::Utils::term_width() - 6;
1090             my $t = Text::SimpleTable->new($column_width);
1091             $t->row($_) for @plugins;
1092             $class->log->debug( "Loaded plugins:\n" . $t->draw . "\n" );
1093         }
1094
1095         my $dispatcher = $class->dispatcher;
1096         my $engine     = $class->engine;
1097         my $home       = $class->config->{home};
1098
1099         $class->log->debug(sprintf(q/Loaded dispatcher "%s"/, blessed($dispatcher)));
1100         $class->log->debug(sprintf(q/Loaded engine "%s"/, blessed($engine)));
1101
1102         $home
1103           ? ( -d $home )
1104           ? $class->log->debug(qq/Found home "$home"/)
1105           : $class->log->debug(qq/Home "$home" doesn't exist/)
1106           : $class->log->debug(q/Couldn't find home/);
1107     }
1108
1109     # Call plugins setup, this is stupid and evil.
1110     # Also screws C3 badly on 5.10, hack to avoid.
1111     {
1112         no warnings qw/redefine/;
1113         local *setup = sub { };
1114         $class->setup unless $Catalyst::__AM_RESTARTING;
1115     }
1116
1117     # Initialize our data structure
1118     $class->components( {} );
1119
1120     $class->setup_components;
1121
1122     if ( $class->debug ) {
1123         my $column_width = Catalyst::Utils::term_width() - 8 - 9;
1124         my $t = Text::SimpleTable->new( [ $column_width, 'Class' ], [ 8, 'Type' ] );
1125         for my $comp ( sort keys %{ $class->components } ) {
1126             my $type = ref $class->components->{$comp} ? 'instance' : 'class';
1127             $t->row( $comp, $type );
1128         }
1129         $class->log->debug( "Loaded components:\n" . $t->draw . "\n" )
1130           if ( keys %{ $class->components } );
1131     }
1132
1133     # Add our self to components, since we are also a component
1134     if( $class->isa('Catalyst::Controller') ){
1135       $class->components->{$class} = $class;
1136     }
1137
1138     $class->setup_actions;
1139
1140     if ( $class->debug ) {
1141         my $name = $class->config->{name} || 'Application';
1142         $class->log->info("$name powered by Catalyst $Catalyst::VERSION");
1143     }
1144
1145     # Make sure that the application class becomes immutable at this point,
1146     B::Hooks::EndOfScope::on_scope_end {
1147         return if $@;
1148         my $meta = Class::MOP::get_metaclass_by_name($class);
1149         if (
1150             $meta->is_immutable
1151             && ! { $meta->immutable_options }->{replace_constructor}
1152             && (
1153                    $class->isa('Class::Accessor::Fast')
1154                 || $class->isa('Class::Accessor')
1155             )
1156         ) {
1157             warn "You made your application class ($class) immutable, "
1158                 . "but did not inline the\nconstructor. "
1159                 . "This will break catalyst, as your app \@ISA "
1160                 . "Class::Accessor(::Fast)?\nPlease pass "
1161                 . "(replace_constructor => 1)\nwhen making your class immutable.\n";
1162         }
1163         $meta->make_immutable(
1164             replace_constructor => 1,
1165         ) unless $meta->is_immutable;
1166     };
1167
1168     if ($class->config->{case_sensitive}) {
1169         $class->log->warn($class . "->config->{case_sensitive} is set.");
1170         $class->log->warn("This setting is deprecated and planned to be removed in Catalyst 5.81.");
1171     }
1172
1173     $class->setup_finalize;
1174     # Should be the last thing we do so that user things hooking
1175     # setup_finalize can log..
1176     $class->log->_flush() if $class->log->can('_flush');
1177     return 1; # Explicit return true as people have __PACKAGE__->setup as the last thing in their class. HATE.
1178 }
1179
1180
1181 =head2 $app->setup_finalize
1182
1183 A hook to attach modifiers to.
1184 Using C<< after setup => sub{}; >> doesn't work, because of quirky things done for plugin setup.
1185 Also better than C< setup_finished(); >, as that is a getter method.
1186
1187     sub setup_finalize {
1188
1189         my $app = shift;
1190
1191         ## do stuff, i.e., determine a primary key column for sessions stored in a DB
1192
1193         $app->next::method(@_);
1194
1195
1196     }
1197
1198 =cut
1199
1200 sub setup_finalize {
1201     my ($class) = @_;
1202     $class->setup_finished(1);
1203 }
1204
1205 =head2 $c->uri_for( $path?, @args?, \%query_values? )
1206
1207 =head2 $c->uri_for( $action, \@captures?, @args?, \%query_values? )
1208
1209 Constructs an absolute L<URI> object based on the application root, the
1210 provided path, and the additional arguments and query parameters provided.
1211 When used as a string, provides a textual URI.
1212
1213 If no arguments are provided, the URI for the current action is returned.
1214 To return the current action and also provide @args, use
1215 C<< $c->uri_for( $c->action, @args ) >>.
1216
1217 If the first argument is a string, it is taken as a public URI path relative
1218 to C<< $c->namespace >> (if it doesn't begin with a forward slash) or
1219 relative to the application root (if it does). It is then merged with
1220 C<< $c->request->base >>; any C<@args> are appended as additional path
1221 components; and any C<%query_values> are appended as C<?foo=bar> parameters.
1222
1223 If the first argument is a L<Catalyst::Action> it represents an action which
1224 will have its path resolved using C<< $c->dispatcher->uri_for_action >>. The
1225 optional C<\@captures> argument (an arrayref) allows passing the captured
1226 variables that are needed to fill in the paths of Chained and Regex actions;
1227 once the path is resolved, C<uri_for> continues as though a path was
1228 provided, appending any arguments or parameters and creating an absolute
1229 URI.
1230
1231 The captures for the current request can be found in
1232 C<< $c->request->captures >>, and actions can be resolved using
1233 C<< Catalyst::Controller->action_for($name) >>. If you have a private action
1234 path, use C<< $c->uri_for_action >> instead.
1235
1236   # Equivalent to $c->req->uri
1237   $c->uri_for($c->action, $c->req->captures,
1238       @{ $c->req->args }, $c->req->params);
1239
1240   # For the Foo action in the Bar controller
1241   $c->uri_for($c->controller('Bar')->action_for('Foo'));
1242
1243   # Path to a static resource
1244   $c->uri_for('/static/images/logo.png');
1245
1246 =cut
1247
1248 sub uri_for {
1249     my ( $c, $path, @args ) = @_;
1250
1251     if (blessed($path) && $path->isa('Catalyst::Controller')) {
1252         $path = $path->path_prefix;
1253         $path =~ s{/+\z}{};
1254         $path .= '/';
1255     }
1256
1257     if ( blessed($path) ) { # action object
1258         my $captures = [ map { s|/|%2F|; $_; }
1259                         ( scalar @args && ref $args[0] eq 'ARRAY'
1260                          ? @{ shift(@args) }
1261                          : ()) ];
1262         my $action = $path;
1263         $path = $c->dispatcher->uri_for_action($action, $captures);
1264         if (not defined $path) {
1265             $c->log->debug(qq/Can't find uri_for action '$action' @$captures/)
1266                 if $c->debug;
1267             return undef;
1268         }
1269         $path = '/' if $path eq '';
1270     }
1271
1272     undef($path) if (defined $path && $path eq '');
1273
1274     my $params =
1275       ( scalar @args && ref $args[$#args] eq 'HASH' ? pop @args : {} );
1276
1277     carp "uri_for called with undef argument" if grep { ! defined $_ } @args;
1278     s/([^$URI::uric])/$URI::Escape::escapes{$1}/go for @args;
1279     s|/|%2F| for @args;
1280
1281     unshift(@args, $path);
1282
1283     unless (defined $path && $path =~ s!^/!!) { # in-place strip
1284         my $namespace = $c->namespace;
1285         if (defined $path) { # cheesy hack to handle path '../foo'
1286            $namespace =~ s{(?:^|/)[^/]+$}{} while $args[0] =~ s{^\.\./}{};
1287         }
1288         unshift(@args, $namespace || '');
1289     }
1290
1291     # join args with '/', or a blank string
1292     my $args = join('/', grep { defined($_) } @args);
1293     $args =~ s/\?/%3F/g; # STUPID STUPID SPECIAL CASE
1294     $args =~ s!^/+!!;
1295     my $base = $c->req->base;
1296     my $class = ref($base);
1297     $base =~ s{(?<!/)$}{/};
1298
1299     my $query = '';
1300
1301     if (my @keys = keys %$params) {
1302       # somewhat lifted from URI::_query's query_form
1303       $query = '?'.join('&', map {
1304           my $val = $params->{$_};
1305           s/([;\/?:@&=+,\$\[\]%])/$URI::Escape::escapes{$1}/go;
1306           s/ /+/g;
1307           my $key = $_;
1308           $val = '' unless defined $val;
1309           (map {
1310               my $param = "$_";
1311               utf8::encode( $param ) if utf8::is_utf8($param);
1312               # using the URI::Escape pattern here so utf8 chars survive
1313               $param =~ s/([^A-Za-z0-9\-_.!~*'() ])/$URI::Escape::escapes{$1}/go;
1314               $param =~ s/ /+/g;
1315               "${key}=$param"; } ( ref $val eq 'ARRAY' ? @$val : $val ));
1316       } @keys);
1317     }
1318
1319     my $res = bless(\"${base}${args}${query}", $class);
1320     $res;
1321 }
1322
1323 =head2 $c->uri_for_action( $path, \@captures?, @args?, \%query_values? )
1324
1325 =head2 $c->uri_for_action( $action, \@captures?, @args?, \%query_values? )
1326
1327 =over
1328
1329 =item $path
1330
1331 A private path to the Catalyst action you want to create a URI for.
1332
1333 This is a shortcut for calling C<< $c->dispatcher->get_action_by_path($path)
1334 >> and passing the resulting C<$action> and the remaining arguments to C<<
1335 $c->uri_for >>.
1336
1337 You can also pass in a Catalyst::Action object, in which case it is passed to
1338 C<< $c->uri_for >>.
1339
1340 Note that although the path looks like a URI that dispatches to the wanted action, it is not a URI, but an internal path to that action.
1341
1342 For example, if the action looks like:
1343
1344  package MyApp::Controller::Users;
1345
1346  sub lst : Path('the-list') {}
1347
1348 You can use:
1349
1350  $c->uri_for_action('/users/lst')
1351
1352 and it will create the URI /users/the-list.
1353
1354 =back
1355
1356 =cut
1357
1358 sub uri_for_action {
1359     my ( $c, $path, @args ) = @_;
1360     my $action = blessed($path)
1361       ? $path
1362       : $c->dispatcher->get_action_by_path($path);
1363     unless (defined $action) {
1364       croak "Can't find action for path '$path'";
1365     }
1366     return $c->uri_for( $action, @args );
1367 }
1368
1369 =head2 $c->welcome_message
1370
1371 Returns the Catalyst welcome HTML page.
1372
1373 =cut
1374
1375 sub welcome_message {
1376     my $c      = shift;
1377     my $name   = $c->config->{name};
1378     my $logo   = $c->uri_for('/static/images/catalyst_logo.png');
1379     my $prefix = Catalyst::Utils::appprefix( ref $c );
1380     $c->response->content_type('text/html; charset=utf-8');
1381     return <<"EOF";
1382 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
1383     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
1384 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
1385     <head>
1386     <meta http-equiv="Content-Language" content="en" />
1387     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
1388         <title>$name on Catalyst $VERSION</title>
1389         <style type="text/css">
1390             body {
1391                 color: #000;
1392                 background-color: #eee;
1393             }
1394             div#content {
1395                 width: 640px;
1396                 margin-left: auto;
1397                 margin-right: auto;
1398                 margin-top: 10px;
1399                 margin-bottom: 10px;
1400                 text-align: left;
1401                 background-color: #ccc;
1402                 border: 1px solid #aaa;
1403             }
1404             p, h1, h2 {
1405                 margin-left: 20px;
1406                 margin-right: 20px;
1407                 font-family: verdana, tahoma, sans-serif;
1408             }
1409             a {
1410                 font-family: verdana, tahoma, sans-serif;
1411             }
1412             :link, :visited {
1413                     text-decoration: none;
1414                     color: #b00;
1415                     border-bottom: 1px dotted #bbb;
1416             }
1417             :link:hover, :visited:hover {
1418                     color: #555;
1419             }
1420             div#topbar {
1421                 margin: 0px;
1422             }
1423             pre {
1424                 margin: 10px;
1425                 padding: 8px;
1426             }
1427             div#answers {
1428                 padding: 8px;
1429                 margin: 10px;
1430                 background-color: #fff;
1431                 border: 1px solid #aaa;
1432             }
1433             h1 {
1434                 font-size: 0.9em;
1435                 font-weight: normal;
1436                 text-align: center;
1437             }
1438             h2 {
1439                 font-size: 1.0em;
1440             }
1441             p {
1442                 font-size: 0.9em;
1443             }
1444             p img {
1445                 float: right;
1446                 margin-left: 10px;
1447             }
1448             span#appname {
1449                 font-weight: bold;
1450                 font-size: 1.6em;
1451             }
1452         </style>
1453     </head>
1454     <body>
1455         <div id="content">
1456             <div id="topbar">
1457                 <h1><span id="appname">$name</span> on <a href="http://catalyst.perl.org">Catalyst</a>
1458                     $VERSION</h1>
1459              </div>
1460              <div id="answers">
1461                  <p>
1462                  <img src="$logo" alt="Catalyst Logo" />
1463                  </p>
1464                  <p>Welcome to the  world of Catalyst.
1465                     This <a href="http://en.wikipedia.org/wiki/MVC">MVC</a>
1466                     framework will make web development something you had
1467                     never expected it to be: Fun, rewarding, and quick.</p>
1468                  <h2>What to do now?</h2>
1469                  <p>That really depends  on what <b>you</b> want to do.
1470                     We do, however, provide you with a few starting points.</p>
1471                  <p>If you want to jump right into web development with Catalyst
1472                     you might want to start with a tutorial.</p>
1473 <pre>perldoc <a href="http://cpansearch.perl.org/dist/Catalyst-Manual/lib/Catalyst/Manual/Tutorial.pod">Catalyst::Manual::Tutorial</a></code>
1474 </pre>
1475 <p>Afterwards you can go on to check out a more complete look at our features.</p>
1476 <pre>
1477 <code>perldoc <a href="http://cpansearch.perl.org/dist/Catalyst-Manual/lib/Catalyst/Manual/Intro.pod">Catalyst::Manual::Intro</a>
1478 <!-- Something else should go here, but the Catalyst::Manual link seems unhelpful -->
1479 </code></pre>
1480                  <h2>What to do next?</h2>
1481                  <p>Next it's time to write an actual application. Use the
1482                     helper scripts to generate <a href="http://cpansearch.perl.org/search?query=Catalyst%3A%3AController%3A%3A&amp;mode=all">controllers</a>,
1483                     <a href="http://cpansearch.perl.org/search?query=Catalyst%3A%3AModel%3A%3A&amp;mode=all">models</a>, and
1484                     <a href="http://cpansearch.perl.org/search?query=Catalyst%3A%3AView%3A%3A&amp;mode=all">views</a>;
1485                     they can save you a lot of work.</p>
1486                     <pre><code>script/${prefix}_create.pl -help</code></pre>
1487                     <p>Also, be sure to check out the vast and growing
1488                     collection of <a href="http://search.cpan.org/search?query=Catalyst">plugins for Catalyst on CPAN</a>;
1489                     you are likely to find what you need there.
1490                     </p>
1491
1492                  <h2>Need help?</h2>
1493                  <p>Catalyst has a very active community. Here are the main places to
1494                     get in touch with us.</p>
1495                  <ul>
1496                      <li>
1497                          <a href="http://dev.catalyst.perl.org">Wiki</a>
1498                      </li>
1499                      <li>
1500                          <a href="http://lists.scsys.co.uk/cgi-bin/mailman/listinfo/catalyst">Mailing-List</a>
1501                      </li>
1502                      <li>
1503                          <a href="irc://irc.perl.org/catalyst">IRC channel #catalyst on irc.perl.org</a>
1504                      </li>
1505                  </ul>
1506                  <h2>In conclusion</h2>
1507                  <p>The Catalyst team hopes you will enjoy using Catalyst as much
1508                     as we enjoyed making it. Please contact us if you have ideas
1509                     for improvement or other feedback.</p>
1510              </div>
1511          </div>
1512     </body>
1513 </html>
1514 EOF
1515 }
1516
1517 =head1 INTERNAL METHODS
1518
1519 These methods are not meant to be used by end users.
1520
1521 =head2 $c->components
1522
1523 Returns a hash of components.
1524
1525 =head2 $c->context_class
1526
1527 Returns or sets the context class.
1528
1529 =head2 $c->counter
1530
1531 Returns a hashref containing coderefs and execution counts (needed for
1532 deep recursion detection).
1533
1534 =head2 $c->depth
1535
1536 Returns the number of actions on the current internal execution stack.
1537
1538 =head2 $c->dispatch
1539
1540 Dispatches a request to actions.
1541
1542 =cut
1543
1544 sub dispatch { my $c = shift; $c->dispatcher->dispatch( $c, @_ ) }
1545
1546 =head2 $c->dispatcher_class
1547
1548 Returns or sets the dispatcher class.
1549
1550 =head2 $c->dump_these
1551
1552 Returns a list of 2-element array references (name, structure) pairs
1553 that will be dumped on the error page in debug mode.
1554
1555 =cut
1556
1557 sub dump_these {
1558     my $c = shift;
1559     [ Request => $c->req ],
1560     [ Response => $c->res ],
1561     [ Stash => $c->stash ],
1562     [ Config => $c->config ];
1563 }
1564
1565 =head2 $c->engine_class
1566
1567 Returns or sets the engine class.
1568
1569 =head2 $c->execute( $class, $coderef )
1570
1571 Execute a coderef in given class and catch exceptions. Errors are available
1572 via $c->error.
1573
1574 =cut
1575
1576 sub execute {
1577     my ( $c, $class, $code ) = @_;
1578     $class = $c->component($class) || $class;
1579     $c->state(0);
1580
1581     if ( $c->depth >= $RECURSION ) {
1582         my $action = $code->reverse();
1583         $action = "/$action" unless $action =~ /->/;
1584         my $error = qq/Deep recursion detected calling "${action}"/;
1585         $c->log->error($error);
1586         $c->error($error);
1587         $c->state(0);
1588         return $c->state;
1589     }
1590
1591     my $stats_info = $c->_stats_start_execute( $code ) if $c->use_stats;
1592
1593     push( @{ $c->stack }, $code );
1594
1595     no warnings 'recursion';
1596     eval { $c->state( $code->execute( $class, $c, @{ $c->req->args } ) || 0 ) };
1597
1598     $c->_stats_finish_execute( $stats_info ) if $c->use_stats and $stats_info;
1599
1600     my $last = pop( @{ $c->stack } );
1601
1602     if ( my $error = $@ ) {
1603         if ( blessed($error) and $error->isa('Catalyst::Exception::Detach') ) {
1604             $error->rethrow if $c->depth > 1;
1605         }
1606         elsif ( blessed($error) and $error->isa('Catalyst::Exception::Go') ) {
1607             $error->rethrow if $c->depth > 0;
1608         }
1609         else {
1610             unless ( ref $error ) {
1611                 no warnings 'uninitialized';
1612                 chomp $error;
1613                 my $class = $last->class;
1614                 my $name  = $last->name;
1615                 $error = qq/Caught exception in $class->$name "$error"/;
1616             }
1617             $c->error($error);
1618             $c->state(0);
1619         }
1620     }
1621     return $c->state;
1622 }
1623
1624 sub _stats_start_execute {
1625     my ( $c, $code ) = @_;
1626     my $appclass = ref($c) || $c;
1627     return if ( ( $code->name =~ /^_.*/ )
1628         && ( !$appclass->config->{show_internal_actions} ) );
1629
1630     my $action_name = $code->reverse();
1631     $c->counter->{$action_name}++;
1632
1633     my $action = $action_name;
1634     $action = "/$action" unless $action =~ /->/;
1635
1636     # determine if the call was the result of a forward
1637     # this is done by walking up the call stack and looking for a calling
1638     # sub of Catalyst::forward before the eval
1639     my $callsub = q{};
1640     for my $index ( 2 .. 11 ) {
1641         last
1642         if ( ( caller($index) )[0] eq 'Catalyst'
1643             && ( caller($index) )[3] eq '(eval)' );
1644
1645         if ( ( caller($index) )[3] =~ /forward$/ ) {
1646             $callsub = ( caller($index) )[3];
1647             $action  = "-> $action";
1648             last;
1649         }
1650     }
1651
1652     my $uid = $action_name . $c->counter->{$action_name};
1653
1654     # is this a root-level call or a forwarded call?
1655     if ( $callsub =~ /forward$/ ) {
1656         my $parent = $c->stack->[-1];
1657
1658         # forward, locate the caller
1659         if ( exists $c->counter->{"$parent"} ) {
1660             $c->stats->profile(
1661                 begin  => $action,
1662                 parent => "$parent" . $c->counter->{"$parent"},
1663                 uid    => $uid,
1664             );
1665         }
1666         else {
1667
1668             # forward with no caller may come from a plugin
1669             $c->stats->profile(
1670                 begin => $action,
1671                 uid   => $uid,
1672             );
1673         }
1674     }
1675     else {
1676
1677         # root-level call
1678         $c->stats->profile(
1679             begin => $action,
1680             uid   => $uid,
1681         );
1682     }
1683     return $action;
1684
1685 }
1686
1687 sub _stats_finish_execute {
1688     my ( $c, $info ) = @_;
1689     $c->stats->profile( end => $info );
1690 }
1691
1692 =head2 $c->finalize
1693
1694 Finalizes the request.
1695
1696 =cut
1697
1698 sub finalize {
1699     my $c = shift;
1700
1701     for my $error ( @{ $c->error } ) {
1702         $c->log->error($error);
1703     }
1704
1705     # Allow engine to handle finalize flow (for POE)
1706     my $engine = $c->engine;
1707     if ( my $code = $engine->can('finalize') ) {
1708         $engine->$code($c);
1709     }
1710     else {
1711
1712         $c->finalize_uploads;
1713
1714         # Error
1715         if ( $#{ $c->error } >= 0 ) {
1716             $c->finalize_error;
1717         }
1718
1719         $c->finalize_headers;
1720
1721         # HEAD request
1722         if ( $c->request->method eq 'HEAD' ) {
1723             $c->response->body('');
1724         }
1725
1726         $c->finalize_body;
1727     }
1728
1729     if ($c->use_stats) {
1730         my $elapsed = sprintf '%f', $c->stats->elapsed;
1731         my $av = $elapsed == 0 ? '??' : sprintf '%.3f', 1 / $elapsed;
1732         $c->log->info(
1733             "Request took ${elapsed}s ($av/s)\n" . $c->stats->report . "\n" );
1734     }
1735
1736     return $c->response->status;
1737 }
1738
1739 =head2 $c->finalize_body
1740
1741 Finalizes body.
1742
1743 =cut
1744
1745 sub finalize_body { my $c = shift; $c->engine->finalize_body( $c, @_ ) }
1746
1747 =head2 $c->finalize_cookies
1748
1749 Finalizes cookies.
1750
1751 =cut
1752
1753 sub finalize_cookies { my $c = shift; $c->engine->finalize_cookies( $c, @_ ) }
1754
1755 =head2 $c->finalize_error
1756
1757 Finalizes error.
1758
1759 =cut
1760
1761 sub finalize_error { my $c = shift; $c->engine->finalize_error( $c, @_ ) }
1762
1763 =head2 $c->finalize_headers
1764
1765 Finalizes headers.
1766
1767 =cut
1768
1769 sub finalize_headers {
1770     my $c = shift;
1771
1772     my $response = $c->response; #accessor calls can add up?
1773
1774     # Check if we already finalized headers
1775     return if $response->finalized_headers;
1776
1777     # Handle redirects
1778     if ( my $location = $response->redirect ) {
1779         $c->log->debug(qq/Redirecting to "$location"/) if $c->debug;
1780         $response->header( Location => $location );
1781
1782         if ( !$response->has_body ) {
1783             # Add a default body if none is already present
1784             $response->body(
1785                 qq{<html><body><p>This item has moved <a href="$location">here</a>.</p></body></html>}
1786             );
1787         }
1788     }
1789
1790     # Content-Length
1791     if ( $response->body && !$response->content_length ) {
1792
1793         # get the length from a filehandle
1794         if ( blessed( $response->body ) && $response->body->can('read') )
1795         {
1796             my $stat = stat $response->body;
1797             if ( $stat && $stat->size > 0 ) {
1798                 $response->content_length( $stat->size );
1799             }
1800             else {
1801                 $c->log->warn('Serving filehandle without a content-length');
1802             }
1803         }
1804         else {
1805             # everything should be bytes at this point, but just in case
1806             $response->content_length( length( $response->body ) );
1807         }
1808     }
1809
1810     # Errors
1811     if ( $response->status =~ /^(1\d\d|[23]04)$/ ) {
1812         $response->headers->remove_header("Content-Length");
1813         $response->body('');
1814     }
1815
1816     $c->finalize_cookies;
1817
1818     $c->engine->finalize_headers( $c, @_ );
1819
1820     # Done
1821     $response->finalized_headers(1);
1822 }
1823
1824 =head2 $c->finalize_output
1825
1826 An alias for finalize_body.
1827
1828 =head2 $c->finalize_read
1829
1830 Finalizes the input after reading is complete.
1831
1832 =cut
1833
1834 sub finalize_read { my $c = shift; $c->engine->finalize_read( $c, @_ ) }
1835
1836 =head2 $c->finalize_uploads
1837
1838 Finalizes uploads. Cleans up any temporary files.
1839
1840 =cut
1841
1842 sub finalize_uploads { my $c = shift; $c->engine->finalize_uploads( $c, @_ ) }
1843
1844 =head2 $c->get_action( $action, $namespace )
1845
1846 Gets an action in a given namespace.
1847
1848 =cut
1849
1850 sub get_action { my $c = shift; $c->dispatcher->get_action(@_) }
1851
1852 =head2 $c->get_actions( $action, $namespace )
1853
1854 Gets all actions of a given name in a namespace and all parent
1855 namespaces.
1856
1857 =cut
1858
1859 sub get_actions { my $c = shift; $c->dispatcher->get_actions( $c, @_ ) }
1860
1861 =head2 $c->handle_request( $class, @arguments )
1862
1863 Called to handle each HTTP request.
1864
1865 =cut
1866
1867 sub handle_request {
1868     my ( $class, @arguments ) = @_;
1869
1870     # Always expect worst case!
1871     my $status = -1;
1872     eval {
1873         if ($class->debug) {
1874             my $secs = time - $START || 1;
1875             my $av = sprintf '%.3f', $COUNT / $secs;
1876             my $time = localtime time;
1877             $class->log->info("*** Request $COUNT ($av/s) [$$] [$time] ***");
1878         }
1879
1880         my $c = $class->prepare(@arguments);
1881         $c->dispatch;
1882         $status = $c->finalize;
1883     };
1884
1885     if ( my $error = $@ ) {
1886         chomp $error;
1887         $class->log->error(qq/Caught exception in engine "$error"/);
1888     }
1889
1890     $COUNT++;
1891
1892     if(my $coderef = $class->log->can('_flush')){
1893         $class->log->$coderef();
1894     }
1895     return $status;
1896 }
1897
1898 =head2 $c->prepare( @arguments )
1899
1900 Creates a Catalyst context from an engine-specific request (Apache, CGI,
1901 etc.).
1902
1903 =cut
1904
1905 sub prepare {
1906     my ( $class, @arguments ) = @_;
1907
1908     # XXX
1909     # After the app/ctxt split, this should become an attribute based on something passed
1910     # into the application.
1911     $class->context_class( ref $class || $class ) unless $class->context_class;
1912
1913     my $c = $class->context_class->new({});
1914
1915     # For on-demand data
1916     $c->request->_context($c);
1917     $c->response->_context($c);
1918
1919     #surely this is not the most efficient way to do things...
1920     $c->stats($class->stats_class->new)->enable($c->use_stats);
1921     if ( $c->debug ) {
1922         $c->res->headers->header( 'X-Catalyst' => $Catalyst::VERSION );
1923     }
1924
1925     #XXX reuse coderef from can
1926     # Allow engine to direct the prepare flow (for POE)
1927     if ( $c->engine->can('prepare') ) {
1928         $c->engine->prepare( $c, @arguments );
1929     }
1930     else {
1931         $c->prepare_request(@arguments);
1932         $c->prepare_connection;
1933         $c->prepare_query_parameters;
1934         $c->prepare_headers;
1935         $c->prepare_cookies;
1936         $c->prepare_path;
1937
1938         # Prepare the body for reading, either by prepare_body
1939         # or the user, if they are using $c->read
1940         $c->prepare_read;
1941
1942         # Parse the body unless the user wants it on-demand
1943         unless ( ref($c)->config->{parse_on_demand} ) {
1944             $c->prepare_body;
1945         }
1946     }
1947
1948     my $method  = $c->req->method  || '';
1949     my $path    = $c->req->path;
1950     $path       = '/' unless length $path;
1951     my $address = $c->req->address || '';
1952
1953     $c->log->debug(qq/"$method" request for "$path" from "$address"/)
1954       if $c->debug;
1955
1956     $c->prepare_action;
1957
1958     return $c;
1959 }
1960
1961 =head2 $c->prepare_action
1962
1963 Prepares action. See L<Catalyst::Dispatcher>.
1964
1965 =cut
1966
1967 sub prepare_action { my $c = shift; $c->dispatcher->prepare_action( $c, @_ ) }
1968
1969 =head2 $c->prepare_body
1970
1971 Prepares message body.
1972
1973 =cut
1974
1975 sub prepare_body {
1976     my $c = shift;
1977
1978     return if $c->request->_has_body;
1979
1980     # Initialize on-demand data
1981     $c->engine->prepare_body( $c, @_ );
1982     $c->prepare_parameters;
1983     $c->prepare_uploads;
1984
1985     if ( $c->debug && keys %{ $c->req->body_parameters } ) {
1986         my $t = Text::SimpleTable->new( [ 35, 'Parameter' ], [ 36, 'Value' ] );
1987         for my $key ( sort keys %{ $c->req->body_parameters } ) {
1988             my $param = $c->req->body_parameters->{$key};
1989             my $value = defined($param) ? $param : '';
1990             $t->row( $key,
1991                 ref $value eq 'ARRAY' ? ( join ', ', @$value ) : $value );
1992         }
1993         $c->log->debug( "Body Parameters are:\n" . $t->draw );
1994     }
1995 }
1996
1997 =head2 $c->prepare_body_chunk( $chunk )
1998
1999 Prepares a chunk of data before sending it to L<HTTP::Body>.
2000
2001 See L<Catalyst::Engine>.
2002
2003 =cut
2004
2005 sub prepare_body_chunk {
2006     my $c = shift;
2007     $c->engine->prepare_body_chunk( $c, @_ );
2008 }
2009
2010 =head2 $c->prepare_body_parameters
2011
2012 Prepares body parameters.
2013
2014 =cut
2015
2016 sub prepare_body_parameters {
2017     my $c = shift;
2018     $c->engine->prepare_body_parameters( $c, @_ );
2019 }
2020
2021 =head2 $c->prepare_connection
2022
2023 Prepares connection.
2024
2025 =cut
2026
2027 sub prepare_connection {
2028     my $c = shift;
2029     $c->engine->prepare_connection( $c, @_ );
2030 }
2031
2032 =head2 $c->prepare_cookies
2033
2034 Prepares cookies.
2035
2036 =cut
2037
2038 sub prepare_cookies { my $c = shift; $c->engine->prepare_cookies( $c, @_ ) }
2039
2040 =head2 $c->prepare_headers
2041
2042 Prepares headers.
2043
2044 =cut
2045
2046 sub prepare_headers { my $c = shift; $c->engine->prepare_headers( $c, @_ ) }
2047
2048 =head2 $c->prepare_parameters
2049
2050 Prepares parameters.
2051
2052 =cut
2053
2054 sub prepare_parameters {
2055     my $c = shift;
2056     $c->prepare_body_parameters;
2057     $c->engine->prepare_parameters( $c, @_ );
2058 }
2059
2060 =head2 $c->prepare_path
2061
2062 Prepares path and base.
2063
2064 =cut
2065
2066 sub prepare_path { my $c = shift; $c->engine->prepare_path( $c, @_ ) }
2067
2068 =head2 $c->prepare_query_parameters
2069
2070 Prepares query parameters.
2071
2072 =cut
2073
2074 sub prepare_query_parameters {
2075     my $c = shift;
2076
2077     $c->engine->prepare_query_parameters( $c, @_ );
2078
2079     if ( $c->debug && keys %{ $c->request->query_parameters } ) {
2080         my $t = Text::SimpleTable->new( [ 35, 'Parameter' ], [ 36, 'Value' ] );
2081         for my $key ( sort keys %{ $c->req->query_parameters } ) {
2082             my $param = $c->req->query_parameters->{$key};
2083             my $value = defined($param) ? $param : '';
2084             $t->row( $key,
2085                 ref $value eq 'ARRAY' ? ( join ', ', @$value ) : $value );
2086         }
2087         $c->log->debug( "Query Parameters are:\n" . $t->draw );
2088     }
2089 }
2090
2091 =head2 $c->prepare_read
2092
2093 Prepares the input for reading.
2094
2095 =cut
2096
2097 sub prepare_read { my $c = shift; $c->engine->prepare_read( $c, @_ ) }
2098
2099 =head2 $c->prepare_request
2100
2101 Prepares the engine request.
2102
2103 =cut
2104
2105 sub prepare_request { my $c = shift; $c->engine->prepare_request( $c, @_ ) }
2106
2107 =head2 $c->prepare_uploads
2108
2109 Prepares uploads.
2110
2111 =cut
2112
2113 sub prepare_uploads {
2114     my $c = shift;
2115
2116     $c->engine->prepare_uploads( $c, @_ );
2117
2118     if ( $c->debug && keys %{ $c->request->uploads } ) {
2119         my $t = Text::SimpleTable->new(
2120             [ 12, 'Parameter' ],
2121             [ 26, 'Filename' ],
2122             [ 18, 'Type' ],
2123             [ 9,  'Size' ]
2124         );
2125         for my $key ( sort keys %{ $c->request->uploads } ) {
2126             my $upload = $c->request->uploads->{$key};
2127             for my $u ( ref $upload eq 'ARRAY' ? @{$upload} : ($upload) ) {
2128                 $t->row( $key, $u->filename, $u->type, $u->size );
2129             }
2130         }
2131         $c->log->debug( "File Uploads are:\n" . $t->draw );
2132     }
2133 }
2134
2135 =head2 $c->prepare_write
2136
2137 Prepares the output for writing.
2138
2139 =cut
2140
2141 sub prepare_write { my $c = shift; $c->engine->prepare_write( $c, @_ ) }
2142
2143 =head2 $c->request_class
2144
2145 Returns or sets the request class.
2146
2147 =head2 $c->response_class
2148
2149 Returns or sets the response class.
2150
2151 =head2 $c->read( [$maxlength] )
2152
2153 Reads a chunk of data from the request body. This method is designed to
2154 be used in a while loop, reading C<$maxlength> bytes on every call.
2155 C<$maxlength> defaults to the size of the request if not specified.
2156
2157 You have to set C<< MyApp->config(parse_on_demand => 1) >> to use this
2158 directly.
2159
2160 Warning: If you use read(), Catalyst will not process the body,
2161 so you will not be able to access POST parameters or file uploads via
2162 $c->request.  You must handle all body parsing yourself.
2163
2164 =cut
2165
2166 sub read { my $c = shift; return $c->engine->read( $c, @_ ) }
2167
2168 =head2 $c->run
2169
2170 Starts the engine.
2171
2172 =cut
2173
2174 sub run { my $c = shift; return $c->engine->run( $c, @_ ) }
2175
2176 =head2 $c->set_action( $action, $code, $namespace, $attrs )
2177
2178 Sets an action in a given namespace.
2179
2180 =cut
2181
2182 sub set_action { my $c = shift; $c->dispatcher->set_action( $c, @_ ) }
2183
2184 =head2 $c->setup_actions($component)
2185
2186 Sets up actions for a component.
2187
2188 =cut
2189
2190 sub setup_actions { my $c = shift; $c->dispatcher->setup_actions( $c, @_ ) }
2191
2192 =head2 $c->setup_components
2193
2194 This method is called internally to set up the application's components.
2195
2196 It finds modules by calling the L<locate_components> method, expands them to
2197 package names with the L<expand_component_module> method, and then installs
2198 each component into the application.
2199
2200 The C<setup_components> config option is passed to both of the above methods.
2201
2202 Installation of each component is performed by the L<setup_component> method,
2203 below.
2204
2205 =cut
2206
2207 sub setup_components {
2208     my $class = shift;
2209
2210     my $config  = $class->config->{ setup_components };
2211
2212     my @comps = sort { length $a <=> length $b }
2213                 $class->locate_components($config);
2214     my %comps = map { $_ => 1 } @comps;
2215
2216     my $deprecatedcatalyst_component_names = grep { /::[CMV]::/ } @comps;
2217     $class->log->warn(qq{Your application is using the deprecated ::[MVC]:: type naming scheme.\n}.
2218         qq{Please switch your class names to ::Model::, ::View:: and ::Controller: as appropriate.\n}
2219     ) if $deprecatedcatalyst_component_names;
2220
2221     for my $component ( @comps ) {
2222
2223         # We pass ignore_loaded here so that overlay files for (e.g.)
2224         # Model::DBI::Schema sub-classes are loaded - if it's in @comps
2225         # we know M::P::O found a file on disk so this is safe
2226
2227         Catalyst::Utils::ensure_class_loaded( $component, { ignore_loaded => 1 } );
2228
2229         # Needs to be done as soon as the component is loaded, as loading a sub-component
2230         # (next time round the loop) can cause us to get the wrong metaclass..
2231         $class->_controller_init_base_classes($component);
2232     }
2233
2234     for my $component (@comps) {
2235         $class->components->{ $component } = $class->setup_component($component);
2236         for my $component ($class->expand_component_module( $component, $config )) {
2237             next if $comps{$component};
2238             $class->_controller_init_base_classes($component); # Also cover inner packages
2239             $class->components->{ $component } = $class->setup_component($component);
2240         }
2241     }
2242 }
2243
2244 =head2 $c->locate_components( $setup_component_config )
2245
2246 This method is meant to provide a list of component modules that should be
2247 setup for the application.  By default, it will use L<Module::Pluggable>.
2248
2249 Specify a C<setup_components> config option to pass additional options directly
2250 to L<Module::Pluggable>. To add additional search paths, specify a key named
2251 C<search_extra> as an array reference. Items in the array beginning with C<::>
2252 will have the application class name prepended to them.
2253
2254 =cut
2255
2256 sub locate_components {
2257     my $class  = shift;
2258     my $config = shift;
2259
2260     my @paths   = qw( ::Controller ::C ::Model ::M ::View ::V );
2261     my $extra   = delete $config->{ search_extra } || [];
2262
2263     push @paths, @$extra;
2264
2265     my $locator = Module::Pluggable::Object->new(
2266         search_path => [ map { s/^(?=::)/$class/; $_; } @paths ],
2267         %$config
2268     );
2269
2270     my @comps = $locator->plugins;
2271
2272     return @comps;
2273 }
2274
2275 =head2 $c->expand_component_module( $component, $setup_component_config )
2276
2277 Components found by C<locate_components> will be passed to this method, which
2278 is expected to return a list of component (package) names to be set up.
2279
2280 =cut
2281
2282 sub expand_component_module {
2283     my ($class, $module) = @_;
2284     return Devel::InnerPackage::list_packages( $module );
2285 }
2286
2287 =head2 $c->setup_component
2288
2289 =cut
2290
2291 # FIXME - Ugly, ugly hack to ensure the we force initialize non-moose base classes
2292 #         nearest to Catalyst::Controller first, no matter what order stuff happens
2293 #         to be loaded. There are TODO tests in Moose for this, see
2294 #         f2391d17574eff81d911b97be15ea51080500003
2295 sub _controller_init_base_classes {
2296     my ($app_class, $component) = @_;
2297     return unless $component->isa('Catalyst::Controller');
2298     foreach my $class ( reverse @{ mro::get_linear_isa($component) } ) {
2299         Moose::Meta::Class->initialize( $class )
2300             unless find_meta($class);
2301     }
2302 }
2303
2304 sub setup_component {
2305     my( $class, $component ) = @_;
2306
2307     unless ( $component->can( 'COMPONENT' ) ) {
2308         return $component;
2309     }
2310
2311     my $suffix = Catalyst::Utils::class2classsuffix( $component );
2312     my $config = $class->config->{ $suffix } || {};
2313     # Stash catalyst_component_name in the config here, so that custom COMPONENT
2314     # methods also pass it. local to avoid pointlessly shitting in config
2315     # for the debug screen, as $component is already the key name.
2316     local $config->{catalyst_component_name} = $component;
2317
2318     my $instance = eval { $component->COMPONENT( $class, $config ); };
2319
2320     if ( my $error = $@ ) {
2321         chomp $error;
2322         Catalyst::Exception->throw(
2323             message => qq/Couldn't instantiate component "$component", "$error"/
2324         );
2325     }
2326
2327     unless (blessed $instance) {
2328         my $metaclass = Moose::Util::find_meta($component);
2329         my $method_meta = $metaclass->find_method_by_name('COMPONENT');
2330         my $component_method_from = $method_meta->associated_metaclass->name;
2331         my $value = defined($instance) ? $instance : 'undef';
2332         Catalyst::Exception->throw(
2333             message =>
2334             qq/Couldn't instantiate component "$component", COMPONENT() method (from $component_method_from) didn't return an object-like value (value was $value)./
2335         );
2336     }
2337     return $instance;
2338 }
2339
2340 =head2 $c->setup_dispatcher
2341
2342 Sets up dispatcher.
2343
2344 =cut
2345
2346 sub setup_dispatcher {
2347     my ( $class, $dispatcher ) = @_;
2348
2349     if ($dispatcher) {
2350         $dispatcher = 'Catalyst::Dispatcher::' . $dispatcher;
2351     }
2352
2353     if ( my $env = Catalyst::Utils::env_value( $class, 'DISPATCHER' ) ) {
2354         $dispatcher = 'Catalyst::Dispatcher::' . $env;
2355     }
2356
2357     unless ($dispatcher) {
2358         $dispatcher = $class->dispatcher_class;
2359     }
2360
2361     Class::MOP::load_class($dispatcher);
2362
2363     # dispatcher instance
2364     $class->dispatcher( $dispatcher->new );
2365 }
2366
2367 =head2 $c->setup_engine
2368
2369 Sets up engine.
2370
2371 =cut
2372
2373 sub setup_engine {
2374     my ( $class, $engine ) = @_;
2375
2376     if ($engine) {
2377         $engine = 'Catalyst::Engine::' . $engine;
2378     }
2379
2380     if ( my $env = Catalyst::Utils::env_value( $class, 'ENGINE' ) ) {
2381         $engine = 'Catalyst::Engine::' . $env;
2382     }
2383
2384     if ( $ENV{MOD_PERL} ) {
2385         my $meta = Class::MOP::get_metaclass_by_name($class);
2386
2387         # create the apache method
2388         $meta->add_method('apache' => sub { shift->engine->apache });
2389
2390         my ( $software, $version ) =
2391           $ENV{MOD_PERL} =~ /^(\S+)\/(\d+(?:[\.\_]\d+)+)/;
2392
2393         $version =~ s/_//g;
2394         $version =~ s/(\.[^.]+)\./$1/g;
2395
2396         if ( $software eq 'mod_perl' ) {
2397
2398             if ( !$engine ) {
2399
2400                 if ( $version >= 1.99922 ) {
2401                     $engine = 'Catalyst::Engine::Apache2::MP20';
2402                 }
2403
2404                 elsif ( $version >= 1.9901 ) {
2405                     $engine = 'Catalyst::Engine::Apache2::MP19';
2406                 }
2407
2408                 elsif ( $version >= 1.24 ) {
2409                     $engine = 'Catalyst::Engine::Apache::MP13';
2410                 }
2411
2412                 else {
2413                     Catalyst::Exception->throw( message =>
2414                           qq/Unsupported mod_perl version: $ENV{MOD_PERL}/ );
2415                 }
2416
2417             }
2418
2419             # install the correct mod_perl handler
2420             if ( $version >= 1.9901 ) {
2421                 *handler = sub  : method {
2422                     shift->handle_request(@_);
2423                 };
2424             }
2425             else {
2426                 *handler = sub ($$) { shift->handle_request(@_) };
2427             }
2428
2429         }
2430
2431         elsif ( $software eq 'Zeus-Perl' ) {
2432             $engine = 'Catalyst::Engine::Zeus';
2433         }
2434
2435         else {
2436             Catalyst::Exception->throw(
2437                 message => qq/Unsupported mod_perl: $ENV{MOD_PERL}/ );
2438         }
2439     }
2440
2441     unless ($engine) {
2442         $engine = $class->engine_class;
2443     }
2444
2445     Class::MOP::load_class($engine);
2446
2447     # check for old engines that are no longer compatible
2448     my $old_engine;
2449     if ( $engine->isa('Catalyst::Engine::Apache')
2450         && !Catalyst::Engine::Apache->VERSION )
2451     {
2452         $old_engine = 1;
2453     }
2454
2455     elsif ( $engine->isa('Catalyst::Engine::Server::Base')
2456         && Catalyst::Engine::Server->VERSION le '0.02' )
2457     {
2458         $old_engine = 1;
2459     }
2460
2461     elsif ($engine->isa('Catalyst::Engine::HTTP::POE')
2462         && $engine->VERSION eq '0.01' )
2463     {
2464         $old_engine = 1;
2465     }
2466
2467     elsif ($engine->isa('Catalyst::Engine::Zeus')
2468         && $engine->VERSION eq '0.01' )
2469     {
2470         $old_engine = 1;
2471     }
2472
2473     if ($old_engine) {
2474         Catalyst::Exception->throw( message =>
2475               qq/Engine "$engine" is not supported by this version of Catalyst/
2476         );
2477     }
2478
2479     # engine instance
2480     $class->engine( $engine->new );
2481 }
2482
2483 =head2 $c->setup_home
2484
2485 Sets up the home directory.
2486
2487 =cut
2488
2489 sub setup_home {
2490     my ( $class, $home ) = @_;
2491
2492     if ( my $env = Catalyst::Utils::env_value( $class, 'HOME' ) ) {
2493         $home = $env;
2494     }
2495
2496     $home ||= Catalyst::Utils::home($class);
2497
2498     if ($home) {
2499         #I remember recently being scolded for assigning config values like this
2500         $class->config->{home} ||= $home;
2501         $class->config->{root} ||= Path::Class::Dir->new($home)->subdir('root');
2502     }
2503 }
2504
2505 =head2 $c->setup_log
2506
2507 Sets up log by instantiating a L<Catalyst::Log|Catalyst::Log> object and
2508 passing it to C<log()>. Pass in a comma-delimited list of levels to set the
2509 log to.
2510
2511 This method also installs a C<debug> method that returns a true value into the
2512 catalyst subclass if the "debug" level is passed in the comma-delimited list,
2513 or if the C<$CATALYST_DEBUG> environment variable is set to a true value.
2514
2515 Note that if the log has already been setup, by either a previous call to
2516 C<setup_log> or by a call such as C<< __PACKAGE__->log( MyLogger->new ) >>,
2517 that this method won't actually set up the log object.
2518
2519 =cut
2520
2521 sub setup_log {
2522     my ( $class, $levels ) = @_;
2523
2524     $levels ||= '';
2525     $levels =~ s/^\s+//;
2526     $levels =~ s/\s+$//;
2527     my %levels = map { $_ => 1 } split /\s*,\s*/, $levels;
2528
2529     my $env_debug = Catalyst::Utils::env_value( $class, 'DEBUG' );
2530     if ( defined $env_debug ) {
2531         $levels{debug} = 1 if $env_debug; # Ugly!
2532         delete($levels{debug}) unless $env_debug;
2533     }
2534
2535     unless ( $class->log ) {
2536         $class->log( Catalyst::Log->new(keys %levels) );
2537     }
2538
2539     if ( $levels{debug} ) {
2540         Class::MOP::get_metaclass_by_name($class)->add_method('debug' => sub { 1 });
2541         $class->log->debug('Debug messages enabled');
2542     }
2543 }
2544
2545 =head2 $c->setup_plugins
2546
2547 Sets up plugins.
2548
2549 =cut
2550
2551 =head2 $c->setup_stats
2552
2553 Sets up timing statistics class.
2554
2555 =cut
2556
2557 sub setup_stats {
2558     my ( $class, $stats ) = @_;
2559
2560     Catalyst::Utils::ensure_class_loaded($class->stats_class);
2561
2562     my $env = Catalyst::Utils::env_value( $class, 'STATS' );
2563     if ( defined($env) ? $env : ($stats || $class->debug ) ) {
2564         Class::MOP::get_metaclass_by_name($class)->add_method('use_stats' => sub { 1 });
2565         $class->log->debug('Statistics enabled');
2566     }
2567 }
2568
2569
2570 =head2 $c->registered_plugins
2571
2572 Returns a sorted list of the plugins which have either been stated in the
2573 import list or which have been added via C<< MyApp->plugin(@args); >>.
2574
2575 If passed a given plugin name, it will report a boolean value indicating
2576 whether or not that plugin is loaded.  A fully qualified name is required if
2577 the plugin name does not begin with C<Catalyst::Plugin::>.
2578
2579  if ($c->registered_plugins('Some::Plugin')) {
2580      ...
2581  }
2582
2583 =cut
2584
2585 {
2586
2587     sub registered_plugins {
2588         my $proto = shift;
2589         return sort keys %{ $proto->_plugins } unless @_;
2590         my $plugin = shift;
2591         return 1 if exists $proto->_plugins->{$plugin};
2592         return exists $proto->_plugins->{"Catalyst::Plugin::$plugin"};
2593     }
2594
2595     sub _register_plugin {
2596         my ( $proto, $plugin, $instant ) = @_;
2597         my $class = ref $proto || $proto;
2598
2599         Class::MOP::load_class( $plugin );
2600         $class->log->warn( "$plugin inherits from 'Catalyst::Component' - this is decated and will not work in 5.81" )
2601             if $plugin->isa( 'Catalyst::Component' );
2602         $proto->_plugins->{$plugin} = 1;
2603         unless ($instant) {
2604             no strict 'refs';
2605             if ( my $meta = Class::MOP::get_metaclass_by_name($class) ) {
2606               my @superclasses = ($plugin, $meta->superclasses );
2607               $meta->superclasses(@superclasses);
2608             } else {
2609               unshift @{"$class\::ISA"}, $plugin;
2610             }
2611         }
2612         return $class;
2613     }
2614
2615     sub setup_plugins {
2616         my ( $class, $plugins ) = @_;
2617
2618         $class->_plugins( {} ) unless $class->_plugins;
2619         $plugins ||= [];
2620
2621         my @plugins = Catalyst::Utils::resolve_namespace($class . '::Plugin', 'Catalyst::Plugin', @$plugins);
2622
2623         for my $plugin ( reverse @plugins ) {
2624             Class::MOP::load_class($plugin);
2625             my $meta = find_meta($plugin);
2626             next if $meta && $meta->isa('Moose::Meta::Role');
2627
2628             $class->_register_plugin($plugin);
2629         }
2630
2631         my @roles =
2632             map { $_->name }
2633             grep { $_ && blessed($_) && $_->isa('Moose::Meta::Role') }
2634             map { find_meta($_) }
2635             @plugins;
2636
2637         Moose::Util::apply_all_roles(
2638             $class => @roles
2639         ) if @roles;
2640     }
2641 }
2642
2643 =head2 $c->stack
2644
2645 Returns an arrayref of the internal execution stack (actions that are
2646 currently executing).
2647
2648 =head2 $c->stats_class
2649
2650 Returns or sets the stats (timing statistics) class.
2651
2652 =head2 $c->use_stats
2653
2654 Returns 1 when stats collection is enabled.  Stats collection is enabled
2655 when the -Stats options is set, debug is on or when the <MYAPP>_STATS
2656 environment variable is set.
2657
2658 Note that this is a static method, not an accessor and should be overridden
2659 by declaring C<sub use_stats { 1 }> in your MyApp.pm, not by calling C<< $c->use_stats(1) >>.
2660
2661 =cut
2662
2663 sub use_stats { 0 }
2664
2665
2666 =head2 $c->write( $data )
2667
2668 Writes $data to the output stream. When using this method directly, you
2669 will need to manually set the C<Content-Length> header to the length of
2670 your output data, if known.
2671
2672 =cut
2673
2674 sub write {
2675     my $c = shift;
2676
2677     # Finalize headers if someone manually writes output
2678     $c->finalize_headers;
2679
2680     return $c->engine->write( $c, @_ );
2681 }
2682
2683 =head2 version
2684
2685 Returns the Catalyst version number. Mostly useful for "powered by"
2686 messages in template systems.
2687
2688 =cut
2689
2690 sub version { return $Catalyst::VERSION }
2691
2692 =head1 CONFIGURATION
2693
2694 There are a number of 'base' config variables which can be set:
2695
2696 =over
2697
2698 =item *
2699
2700 C<default_model> - The default model picked if you say C<< $c->model >>. See L<< /$c->model($name) >>.
2701
2702 =item *
2703
2704 C<default_view> - The default view to be rendered or returned when C<< $c->view >> is called. See L<< /$c->view($name) >>.
2705
2706 =item *
2707
2708 C<disable_component_resolution_regex_fallback> - Turns
2709 off the deprecated component resolution functionality so
2710 that if any of the component methods (e.g. C<< $c->controller('Foo') >>)
2711 are called then regex search will not be attempted on string values and
2712 instead C<undef> will be returned.
2713
2714 =item *
2715
2716 C<home> - The application home directory. In an uninstalled application,
2717 this is the top level application directory. In an installed application,
2718 this will be the directory containing C<< MyApp.pm >>.
2719
2720 =item *
2721
2722 C<ignore_frontend_proxy> - See L</PROXY SUPPORT>
2723
2724 =item *
2725
2726 C<name> - The name of the application in debug messages and the debug and
2727 welcome screens
2728
2729 =item *
2730
2731 C<parse_on_demand> - The request body (for example file uploads) will not be parsed
2732 until it is accessed. This allows you to (for example) check authentication (and reject
2733 the upload) before actually recieving all the data. See L</ON-DEMAND PARSER>
2734
2735 =item *
2736
2737 C<root> - The root directory for templates. Usually this is just a
2738 subdirectory of the home directory, but you can set it to change the
2739 templates to a different directory.
2740
2741 =item *
2742
2743 C<search_extra> - Array reference passed to Module::Pluggable to for additional
2744 namespaces from which components will be loaded (and constructed and stored in
2745 C<< $c->components >>).
2746
2747 =item *
2748
2749 C<show_internal_actions> - If true, causes internal actions such as C<< _DISPATCH >>
2750 to be shown in hit debug tables in the test server.
2751
2752 =item *
2753
2754 C<using_frontend_proxy> - See L</PROXY SUPPORT>.
2755
2756 =back
2757
2758 =head1 INTERNAL ACTIONS
2759
2760 Catalyst uses internal actions like C<_DISPATCH>, C<_BEGIN>, C<_AUTO>,
2761 C<_ACTION>, and C<_END>. These are by default not shown in the private
2762 action table, but you can make them visible with a config parameter.
2763
2764     MyApp->config(show_internal_actions => 1);
2765
2766 =head1 ON-DEMAND PARSER
2767
2768 The request body is usually parsed at the beginning of a request,
2769 but if you want to handle input yourself, you can enable on-demand
2770 parsing with a config parameter.
2771
2772     MyApp->config(parse_on_demand => 1);
2773
2774 =head1 PROXY SUPPORT
2775
2776 Many production servers operate using the common double-server approach,
2777 with a lightweight frontend web server passing requests to a larger
2778 backend server. An application running on the backend server must deal
2779 with two problems: the remote user always appears to be C<127.0.0.1> and
2780 the server's hostname will appear to be C<localhost> regardless of the
2781 virtual host that the user connected through.
2782
2783 Catalyst will automatically detect this situation when you are running
2784 the frontend and backend servers on the same machine. The following
2785 changes are made to the request.
2786
2787     $c->req->address is set to the user's real IP address, as read from
2788     the HTTP X-Forwarded-For header.
2789
2790     The host value for $c->req->base and $c->req->uri is set to the real
2791     host, as read from the HTTP X-Forwarded-Host header.
2792
2793 Additionally, you may be running your backend application on an insecure
2794 connection (port 80) while your frontend proxy is running under SSL.  If there
2795 is a discrepancy in the ports, use the HTTP header C<X-Forwarded-Port> to
2796 tell Catalyst what port the frontend listens on.  This will allow all URIs to
2797 be created properly.
2798
2799 In the case of passing in:
2800
2801     X-Forwarded-Port: 443
2802
2803 All calls to C<uri_for> will result in an https link, as is expected.
2804
2805 Obviously, your web server must support these headers for this to work.
2806
2807 In a more complex server farm environment where you may have your
2808 frontend proxy server(s) on different machines, you will need to set a
2809 configuration option to tell Catalyst to read the proxied data from the
2810 headers.
2811
2812     MyApp->config(using_frontend_proxy => 1);
2813
2814 If you do not wish to use the proxy support at all, you may set:
2815
2816     MyApp->config(ignore_frontend_proxy => 1);
2817
2818 =head1 THREAD SAFETY
2819
2820 Catalyst has been tested under Apache 2's threading C<mpm_worker>,
2821 C<mpm_winnt>, and the standalone forking HTTP server on Windows. We
2822 believe the Catalyst core to be thread-safe.
2823
2824 If you plan to operate in a threaded environment, remember that all other
2825 modules you are using must also be thread-safe. Some modules, most notably
2826 L<DBD::SQLite>, are not thread-safe.
2827
2828 =head1 SUPPORT
2829
2830 IRC:
2831
2832     Join #catalyst on irc.perl.org.
2833
2834 Mailing Lists:
2835
2836     http://lists.scsys.co.uk/cgi-bin/mailman/listinfo/catalyst
2837     http://lists.scsys.co.uk/cgi-bin/mailman/listinfo/catalyst-dev
2838
2839 Web:
2840
2841     http://catalyst.perl.org
2842
2843 Wiki:
2844
2845     http://dev.catalyst.perl.org
2846
2847 =head1 SEE ALSO
2848
2849 =head2 L<Task::Catalyst> - All you need to start with Catalyst
2850
2851 =head2 L<Catalyst::Manual> - The Catalyst Manual
2852
2853 =head2 L<Catalyst::Component>, L<Catalyst::Controller> - Base classes for components
2854
2855 =head2 L<Catalyst::Engine> - Core engine
2856
2857 =head2 L<Catalyst::Log> - Log class.
2858
2859 =head2 L<Catalyst::Request> - Request object
2860
2861 =head2 L<Catalyst::Response> - Response object
2862
2863 =head2 L<Catalyst::Test> - The test suite.
2864
2865 =head1 PROJECT FOUNDER
2866
2867 sri: Sebastian Riedel <sri@cpan.org>
2868
2869 =head1 CONTRIBUTORS
2870
2871 abw: Andy Wardley
2872
2873 acme: Leon Brocard <leon@astray.com>
2874
2875 abraxxa: Alexander Hartmaier <abraxxa@cpan.org>
2876
2877 Andrew Bramble
2878
2879 Andrew Ford E<lt>A.Ford@ford-mason.co.ukE<gt>
2880
2881 Andrew Ruthven
2882
2883 andyg: Andy Grundman <andy@hybridized.org>
2884
2885 audreyt: Audrey Tang
2886
2887 bricas: Brian Cassidy <bricas@cpan.org>
2888
2889 Caelum: Rafael Kitover <rkitover@io.com>
2890
2891 chansen: Christian Hansen
2892
2893 chicks: Christopher Hicks
2894
2895 Chisel Wright C<pause@herlpacker.co.uk>
2896
2897 Danijel Milicevic C<me@danijel.de>
2898
2899 David Kamholz E<lt>dkamholz@cpan.orgE<gt>
2900
2901 David Naughton, C<naughton@umn.edu>
2902
2903 David E. Wheeler
2904
2905 dhoss: Devin Austin <dhoss@cpan.org>
2906
2907 dkubb: Dan Kubb <dan.kubb-cpan@onautopilot.com>
2908
2909 Drew Taylor
2910
2911 dwc: Daniel Westermann-Clark <danieltwc@cpan.org>
2912
2913 esskar: Sascha Kiefer
2914
2915 fireartist: Carl Franks <cfranks@cpan.org>
2916
2917 frew: Arthur Axel "fREW" Schmidt <frioux@gmail.com>
2918
2919 gabb: Danijel Milicevic
2920
2921 Gary Ashton Jones
2922
2923 Gavin Henry C<ghenry@perl.me.uk>
2924
2925 Geoff Richards
2926
2927 groditi: Guillermo Roditi <groditi@gmail.com>
2928
2929 hobbs: Andrew Rodland <andrew@cleverdomain.org>
2930
2931 ilmari: Dagfinn Ilmari Mannsåker <ilmari@ilmari.org>
2932
2933 jcamacho: Juan Camacho
2934
2935 jester: Jesse Sheidlower C<jester@panix.com>
2936
2937 jhannah: Jay Hannah <jay@jays.net>
2938
2939 Jody Belka
2940
2941 Johan Lindstrom
2942
2943 jon: Jon Schutz <jjschutz@cpan.org>
2944
2945 Jonathan Rockway C<< <jrockway@cpan.org> >>
2946
2947 Kieren Diment C<kd@totaldatasolution.com>
2948
2949 konobi: Scott McWhirter <konobi@cpan.org>
2950
2951 marcus: Marcus Ramberg <mramberg@cpan.org>
2952
2953 miyagawa: Tatsuhiko Miyagawa <miyagawa@bulknews.net>
2954
2955 mst: Matt S. Trout <mst@shadowcatsystems.co.uk>
2956
2957 mugwump: Sam Vilain
2958
2959 naughton: David Naughton
2960
2961 ningu: David Kamholz <dkamholz@cpan.org>
2962
2963 nothingmuch: Yuval Kogman <nothingmuch@woobling.org>
2964
2965 numa: Dan Sully <daniel@cpan.org>
2966
2967 obra: Jesse Vincent
2968
2969 Octavian Rasnita
2970
2971 omega: Andreas Marienborg
2972
2973 Oleg Kostyuk <cub.uanic@gmail.com>
2974
2975 phaylon: Robert Sedlacek <phaylon@dunkelheit.at>
2976
2977 rafl: Florian Ragwitz <rafl@debian.org>
2978
2979 random: Roland Lammel <lammel@cpan.org>
2980
2981 Robert Sedlacek C<< <rs@474.at> >>
2982
2983 sky: Arthur Bergman
2984
2985 t0m: Tomas Doran <bobtfish@bobtfish.net>
2986
2987 Ulf Edvinsson
2988
2989 Viljo Marrandi C<vilts@yahoo.com>
2990
2991 Will Hawes C<info@whawes.co.uk>
2992
2993 willert: Sebastian Willert <willert@cpan.org>
2994
2995 Yuval Kogman, C<nothingmuch@woobling.org>
2996
2997 =head1 LICENSE
2998
2999 This library is free software. You can redistribute it and/or modify it under
3000 the same terms as Perl itself.
3001
3002 =cut
3003
3004 no Moose;
3005
3006 __PACKAGE__->meta->make_immutable;
3007
3008 1;