require Module::Pluggable::Fast;
# Helper script generation
-our $CATALYST_SCRIPT_GEN = 11;
+our $CATALYST_SCRIPT_GEN = 21;
__PACKAGE__->mk_classdata($_)
for qw/components arguments dispatcher engine log dispatcher_class
__PACKAGE__->request_class('Catalyst::Request');
__PACKAGE__->response_class('Catalyst::Response');
-our $VERSION = '5.49_04';
+our $VERSION = '5.59';
sub import {
my ( $class, @arguments ) = @_;
use Catalyst qw/-Debug/; # include plugins here as well
sub foo : Global { # called for /foo, /foo/1, /foo/1/2, etc.
- my ( $self, $c, @args ) = @_; # args are qw/on you/ for /foo/on/you
- $c->stash->{template} = 'foo.tt';
+ my ( $self, $c, @args ) = @_; # args are qw/1 2/ for /foo/1/2
+ $c->stash->{template} = 'foo.tt'; # set the template
# lookup something from db -- stash vars are passed to TT
- $c->stash->{data} = MyApp::Model::Database::Foo->search;
+ $c->stash->{data} =
+ MyApp::Model::Database::Foo->search( { country => $args[0] } );
if ( $c->req->params->{bar} ) { # access GET or POST parameters
$c->forward( 'bar' ); # process another action
# do something else after forward returns
}
}
- # The foo.tt TT template can easily use the stash data from the database
+ # The foo.tt TT template can use the stash data from the database
[% WHILE (item = data.next) %]
[% item.foo %]
[% END %]
# called for /bar/of/soap, /bar/of/soap/10, etc.
sub bar : Path('/bar/of/soap') { ... }
- # called for / and only /, no other args
- sub baz : Path { ... }
- sub baz : Index { ... }
-
- # called for all actions, from the top-most controller inwards
+ # called for all actions, from the top-most controller downwards
sub auto : Private {
my ( $self, $c ) = @_;
if ( !$c->user ) {
$c->res->redirect( '/login' ); # require login
return 0; # abort request and go immediately to end()
}
- return 1;
+ return 1; # success; carry on to next action
}
- # called after the main action is finished
+ # called after all actions are finished
sub end : Private {
my ( $self, $c ) = @_;
if ( scalar @{ $c->error } ) { ... } # handle errors
# called for /foo/bar
sub bar : Local { ... }
- # overrides /foo, but not /foo/1, etc.
- sub index : Path { ... }
+ # called for /blargle
+ sub blargle : Global { ... }
+
+ # an index action matches /foo, but not /foo/1, etc.
+ sub index : Private { ... }
### in MyApp/Controller/Foo/Bar.pm
# called for /foo/bar/baz
See L<Catalyst::Manual> for more documentation.
-Catalyst plugins can be loaded by naming them as arguments to the "use Catalyst" statement.
-Omit the C<Catalyst::Plugin::> prefix from the plugin name, i.e.,
-C<Catalyst::Plugin::My::Module> becomes C<My::Module>.
+Catalyst plugins can be loaded by naming them as arguments to the "use
+Catalyst" statement. Omit the C<Catalyst::Plugin::> prefix from the
+plugin name, i.e., C<Catalyst::Plugin::My::Module> becomes
+C<My::Module>.
use Catalyst qw/My::Module/;
-Special flags like -Debug and -Engine can also be specified as arguments when
-Catalyst is loaded:
+Special flags like C<-Debug> and C<-Engine> can also be specified as
+arguments when Catalyst is loaded:
use Catalyst qw/-Debug My::Module/;
-The position of plugins and flags in the chain is important, because they are
-loaded in exactly the order that they appear.
+The position of plugins and flags in the chain is important, because
+they are loaded in exactly the order in which they appear.
The following flags are supported:
-=over 4
-
-=item -Debug
+=head2 -Debug
Enables debug output.
-=item -Engine
+=head2 -Engine
-Forces Catalyst to use a specific engine.
-Omit the C<Catalyst::Engine::> prefix of the engine name, i.e.:
+Forces Catalyst to use a specific engine. Omit the
+C<Catalyst::Engine::> prefix of the engine name, i.e.:
use Catalyst qw/-Engine=CGI/;
-=item -Home
+=head2 -Home
-Forces Catalyst to use a specific home directory.
+Forces Catalyst to use a specific home directory, e.g.:
-=item -Log
+ use Catalyst qw[-Home=/usr/sri];
-Specifies log level.
+=head2 -Log
-=back
+Specifies log level.
=head1 METHODS
=head2 Information about the current request
-=over 4
-
-=item $c->action
+=head2 $c->action
-Returns a L<Catalyst::Action> object for the current action, which stringifies to the action name.
+Returns a L<Catalyst::Action> object for the current action, which
+stringifies to the action name. See L<Catalyst::Action>.
-=item $c->namespace
+=head2 $c->namespace
-Returns the namespace of the current action, i.e., the uri prefix corresponding to the
-controller of the current action.
+Returns the namespace of the current action, i.e., the uri prefix
+corresponding to the controller of the current action. For example:
-=item $c->request
+ # in Controller::Foo::Bar
+ $c->namespace; # returns 'foo/bar';
-=item $c->req
+=head2 $c->request
-Returns the current L<Catalyst::Request> object.
+=head2 $c->req
- my $req = $c->req;
-
-=back
+Returns the current L<Catalyst::Request> object. See
+L<Catalyst::Request>.
=head2 Processing and response to the current request
-=over 4
-
-=item $c->forward( $action [, \@arguments ] )
+=head2 $c->forward( $action [, \@arguments ] )
-=item $c->forward( $class, $method, [, \@arguments ] )
+=head2 $c->forward( $class, $method, [, \@arguments ] )
-Forwards processing to a private action. If you give a class name but
-no method, process() is called. You may also optionally pass arguments
-in an arrayref. The action will receive the arguments in @_ and $c->req->args.
-Upon returning from the function, $c->req->args will be restored to the previous
-values.
+Forwards processing to a private action. If you give a class name but no
+method, C<process()> is called. You may also optionally pass arguments
+in an arrayref. The action will receive the arguments in C<@_> and
+C<$c-E<gt>req-E<gt>args>. Upon returning from the function,
+C<$c-E<gt>req-E<gt>args> will be restored to the previous values.
$c->forward('/foo');
$c->forward('index');
sub forward { my $c = shift; $c->dispatcher->forward( $c, @_ ) }
-=item $c->detach( $action [, \@arguments ] )
+=head2 $c->detach( $action [, \@arguments ] )
-=item $c->detach( $class, $method, [, \@arguments ] )
+=head2 $c->detach( $class, $method, [, \@arguments ] )
The same as C<forward>, but doesn't return.
sub detach { my $c = shift; $c->dispatcher->detach( $c, @_ ) }
-=item $c->error
+=head2 $c->error
-=item $c->error($error, ...)
+=head2 $c->error($error, ...)
-=item $c->error($arrayref)
+=head2 $c->error($arrayref)
-Returns an arrayref containing error messages.
+Returns an arrayref containing error messages. If Catalyst encounters an
+error while processing a request, it stores the error in $c->error. This
+method should not be used to store non-fatal error messages.
my @error = @{ $c->error };
$c->error('Something bad happened');
-Clear errors.
+Clear errors. You probably don't want to clear the errors unless you are
+implementing a custom error screen.
$c->error(0);
return $c->{error} || [];
}
-=item $c->response
+=head2 $c->response
-=item $c->res
+=head2 $c->res
Returns the current L<Catalyst::Response> object.
- my $res = $c->res;
-
-=item $c->stash
+=head2 $c->stash
-Returns a hashref to the stash, which may be used to store data and pass it
-between components. You can also set hash keys by passing arguments. The
-stash is automatically sent to the view.
+Returns a hashref to the stash, which may be used to store data and pass
+it between components during a request. You can also set hash keys by
+passing arguments. The stash is automatically sent to the view. The
+stash is cleared at the end of a request; it cannot be used for
+persistent storage.
$c->stash->{foo} = $bar;
$c->stash( { moose => 'majestic', qux => 0 } );
return $c->{stash};
}
-=item $c->state
+=head2 $c->state
Contains the return value of the last executed action.
-=back
-
=head2 Component Accessors
-=over 4
-
-=item $c->comp($name)
-
-=item $c->component($name)
+=head2 $c->comp($name)
-Gets a component object by name.
+=head2 $c->component($name)
- $c->comp('MyApp::Model::MyModel')->do_stuff;
+Gets a component object by name. This method is no longer recommended,
+unless you want to get a specific component by full
+class. C<$c-E<gt>controller>, C<$c-E<gt>model>, and C<$c-E<gt>view>
+should be used instead.
=cut
my @names = (
$name, "${appclass}::${name}",
- map { "${appclass}::${_}::${name}" } qw/M V C/
+ map { "${appclass}::${_}::${name}" }
+ qw/Model M Controller C View V/
);
foreach my $try (@names) {
return sort keys %{ $c->components };
}
-=item $c->controller($name)
+=head2 $c->controller($name)
Gets a L<Catalyst::Controller> instance by name.
return $c->comp("C::$name");
}
-=item $c->model($name)
+=head2 $c->model($name)
Gets a L<Catalyst::Model> instance by name.
return $c->comp("M::$name");
}
-=item $c->view($name)
+=head2 $c->view($name)
Gets a L<Catalyst::View> instance by name.
return $c->comp("V::$name");
}
-=back
-
=head2 Class data and helper classes
-=over 4
-
-=item $c->config
+=head2 $c->config
Returns or takes a hashref containing the application's configuration.
__PACKAGE__->config({ db => 'dsn:SQLite:foo.db' });
-=item $c->debug
+=head2 $c->debug
Overload to enable debug messages (same as -Debug option).
sub debug { 0 }
-=item $c->dispatcher
+=head2 $c->dispatcher
-Returns the dispatcher instance. Stringifies to class name.
+Returns the dispatcher instance. Stringifies to class name. See
+L<Catalyst::Dispatcher>.
-=item $c->engine
+=head2 $c->engine
-Returns the engine instance. Stringifies to the class name.
+Returns the engine instance. Stringifies to the class name. See
+L<Catalyst::Engine>.
-=item $c->log
+=head2 $c->log
-Returns the logging object instance. Unless it is already set, Catalyst sets this up with a
-L<Catalyst::Log> object. To use your own log class:
+Returns the logging object instance. Unless it is already set, Catalyst
+sets this up with a L<Catalyst::Log> object. To use your own log class:
$c->log( MyLogger->new );
- $c->log->info( 'now logging with my own logger!' );
+ $c->log->info( 'Now logging with my own logger!' );
-Your log class should implement the methods described in the L<Catalyst::Log>
-man page.
+Your log class should implement the methods described in the
+L<Catalyst::Log> man page.
=cut
-=back
-
=head2 Utility methods
-=over 4
+=head2 $c->path_to(@path)
-=item $c->path_to(@path)
-
-Merges C<@path> with $c->config->{home} and returns a L<Path::Class> object.
+Merges C<@path> with C<$c-E<gt>config-E<gt>{home}> and returns a
+L<Path::Class> object.
For example:
else { return file( $c->config->{home}, @path ) }
}
-=item $c->plugin( $name, $class, @args )
+=head2 $c->plugin( $name, $class, @args )
-Helper method for plugins. It creates a classdata accessor/mutator and loads
-and instantiates the given class.
+Helper method for plugins. It creates a classdata accessor/mutator and
+loads and instantiates the given class.
MyApp->plugin( 'prototype', 'HTML::Prototype' );
if $class->debug;
}
-=item MyApp->setup
+=head2 MyApp->setup
Initializes the dispatcher and engine, loads any plugins, and loads the
-model, view, and controller components. You may also specify an array of
-plugins to load here, if you choose to not load them in the 'use Catalyst'
-line.
+model, view, and controller components. You may also specify an array
+of plugins to load here, if you choose to not load them in the C<use
+Catalyst> line.
MyApp->setup;
MyApp->setup( qw/-Debug/ );
<<"EOF") if ( $ENV{CATALYST_SCRIPT_GEN} && ( $ENV{CATALYST_SCRIPT_GEN} < $Catalyst::CATALYST_SCRIPT_GEN ) );
You are running an old script!
- Please update by running:
- catalyst.pl -nonew -scripts $class
+ Please update by running (this will overwrite existing files):
+ catalyst.pl -force -scripts $class
+
+ or (this will not overwrite existing files):
+ catalyst.pl -scripts $class
EOF
if ( $class->debug ) {
$class->log->_flush() if $class->log->can('_flush');
}
-=item $c->uri_for( $path, [ @args ] )
+=head2 $c->uri_for( $path, [ @args ] )
-Merges path with $c->request->base for absolute uri's and with
-$c->request->match for relative uri's, then returns a normalized
-L<URI> object. If any args are passed, they are added at the end
-of the path.
+Merges path with C<$c-E<gt>request-E<gt>base> for absolute uri's and
+with C<$c-E<gt>namespace> for relative uri's, then returns a
+normalized L<URI> object. If any args are passed, they are added at the
+end of the path.
=cut
my $basepath = $base->path;
$basepath =~ s/\/$//;
$basepath .= '/';
- my $match = $c->request->match;
+ my $namespace = $c->namespace;
- # massage match, empty if absolute path
- $match =~ s/^\///;
- $match .= '/' if $match;
+ # massage namespace, empty if absolute path
+ $namespace =~ s/^\///;
+ $namespace .= '/' if $namespace;
$path ||= '';
- $match = '' if $path =~ /^\//;
+ $namespace = '' if $path =~ /^\//;
$path =~ s/^\///;
# join args with '/', or a blank string
my $args = ( scalar @args ? '/' . join( '/', @args ) : '' );
- return URI->new_abs( URI->new_abs( "$path$args", "$basepath$match" ),
- $base )->canonical;
+ $args =~ s/^\/// unless $path;
+ my $res =
+ URI->new_abs( URI->new_abs( "$path$args", "$basepath$namespace" ), $base )
+ ->canonical;
+ $res;
}
-=item $c->welcome_message
+=head2 $c->welcome_message
Returns the Catalyst welcome HTML page.
EOF
}
-=back
-
=head1 INTERNAL METHODS
-=over 4
-
-=item $c->benchmark( $coderef )
-
-Takes a coderef with arguments and returns elapsed time as float.
-
- my ( $elapsed, $status ) = $c->benchmark( sub { return 1 } );
- $c->log->info( sprintf "Processing took %f seconds", $elapsed );
-
-=cut
-
-sub benchmark {
- my $c = shift;
- my $code = shift;
- my $time = [gettimeofday];
- my @return = &$code(@_);
- my $elapsed = tv_interval $time;
- return wantarray ? ( $elapsed, @return ) : $elapsed;
-}
+These methods are not meant to be used by end users.
-=item $c->components
+=head2 $c->components
Returns a hash of components.
-=item $c->context_class
+=head2 $c->context_class
Returns or sets the context class.
-=item $c->counter
+=head2 $c->counter
-Returns a hashref containing coderefs and execution counts (needed for deep
-recursion detection).
+Returns a hashref containing coderefs and execution counts (needed for
+deep recursion detection).
-=item $c->depth
+=head2 $c->depth
Returns the number of actions on the current internal execution stack.
-=item $c->dispatch
+=head2 $c->dispatch
Dispatches a request to actions.
sub dispatch { my $c = shift; $c->dispatcher->dispatch( $c, @_ ) }
-=item $c->dispatcher_class
+=head2 $c->dispatcher_class
Returns or sets the dispatcher class.
-=item dump_these
+=head2 $c->dump_these
-Returns a list of 2-element array references (name, structure) pairs that will
-be dumped on the error page in debug mode.
+Returns a list of 2-element array references (name, structure) pairs
+that will be dumped on the error page in debug mode.
=cut
[ Request => $c->req ], [ Response => $c->res ], [ Stash => $c->stash ],;
}
-=item $c->engine_class
+=head2 $c->engine_class
Returns or sets the engine class.
-=item $c->execute( $class, $coderef )
+=head2 $c->execute( $class, $coderef )
Execute a coderef in given class and catch exceptions. Errors are available
via $c->error.
$action = "-> $action" if $callsub =~ /forward$/;
}
push( @{ $c->stack }, $code );
- eval {
- if ( $c->debug )
+ my $elapsed = 0;
+ my $start = 0;
+ $start = [gettimeofday] if $c->debug;
+ eval { $c->state( &$code( $class, $c, @{ $c->req->args } ) || 0 ) };
+ $elapsed = tv_interval($start) if $c->debug;
+
+ if ( $c->debug ) {
+ unless ( ( $code->name =~ /^_.*/ )
+ && ( !$c->config->{show_internal_actions} ) )
{
- my ( $elapsed, @state ) =
- $c->benchmark( $code, $class, $c, @{ $c->req->args } );
- unless ( ( $code->name =~ /^_.*/ )
- && ( !$c->config->{show_internal_actions} ) )
- {
- push @{ $c->{stats} }, [ $action, sprintf( '%fs', $elapsed ) ];
- }
- $c->state(@state);
- }
- else {
- $c->state( &$code( $class, $c, @{ $c->req->args } ) || 0 );
+ push @{ $c->{stats} }, [ $action, sprintf( '%fs', $elapsed ) ];
}
- };
+ }
pop( @{ $c->stack } );
if ( my $error = $@ ) {
return $c->state;
}
-=item $c->finalize
+=head2 $c->finalize
Finalizes the request.
return $c->response->status;
}
-=item $c->finalize_body
+=head2 $c->finalize_body
Finalizes body.
sub finalize_body { my $c = shift; $c->engine->finalize_body( $c, @_ ) }
-=item $c->finalize_cookies
+=head2 $c->finalize_cookies
Finalizes cookies.
sub finalize_cookies { my $c = shift; $c->engine->finalize_cookies( $c, @_ ) }
-=item $c->finalize_error
+=head2 $c->finalize_error
Finalizes error.
sub finalize_error { my $c = shift; $c->engine->finalize_error( $c, @_ ) }
-=item $c->finalize_headers
+=head2 $c->finalize_headers
Finalizes headers.
$c->response->{_finalized_headers} = 1;
}
-=item $c->finalize_output
+=head2 $c->finalize_output
An alias for finalize_body.
-=item $c->finalize_read
+=head2 $c->finalize_read
Finalizes the input after reading is complete.
sub finalize_read { my $c = shift; $c->engine->finalize_read( $c, @_ ) }
-=item $c->finalize_uploads
+=head2 $c->finalize_uploads
-Finalizes uploads. Cleans up any temporary files.
+Finalizes uploads. Cleans up any temporary files.
=cut
sub finalize_uploads { my $c = shift; $c->engine->finalize_uploads( $c, @_ ) }
-=item $c->get_action( $action, $namespace )
+=head2 $c->get_action( $action, $namespace )
Gets an action in a given namespace.
sub get_action { my $c = shift; $c->dispatcher->get_action(@_) }
-=item $c->get_actions( $action, $namespace )
+=head2 $c->get_actions( $action, $namespace )
-Gets all actions of a given name in a namespace and all parent namespaces.
+Gets all actions of a given name in a namespace and all parent
+namespaces.
=cut
sub get_actions { my $c = shift; $c->dispatcher->get_actions( $c, @_ ) }
-=item handle_request( $class, @arguments )
+=head2 handle_request( $class, @arguments )
Called to handle each HTTP request.
};
if ( $class->debug ) {
- my $elapsed;
- ( $elapsed, $status ) = $class->benchmark($handler);
+ my $start = [gettimeofday];
+ $status = &$handler;
+ my $elapsed = tv_interval $start;
$elapsed = sprintf '%f', $elapsed;
my $av = sprintf '%.3f',
( $elapsed == 0 ? '??' : ( 1 / $elapsed ) );
return $status;
}
-=item $c->prepare( @arguments )
+=head2 $c->prepare( @arguments )
-Creates a Catalyst context from an engine-specific request
-(Apache, CGI, etc.).
+Creates a Catalyst context from an engine-specific request (Apache, CGI,
+etc.).
=cut
# On-demand parsing
$c->prepare_body unless $c->config->{parse_on_demand};
- $c->prepare_action;
my $method = $c->req->method || '';
my $path = $c->req->path || '';
my $address = $c->req->address || '';
- $c->log->debug(qq/"$method" request for "$path" from $address/)
+ $c->log->debug(qq/"$method" request for "$path" from "$address"/)
if $c->debug;
+ $c->prepare_action;
+
return $c;
}
-=item $c->prepare_action
+=head2 $c->prepare_action
Prepares action.
sub prepare_action { my $c = shift; $c->dispatcher->prepare_action( $c, @_ ) }
-=item $c->prepare_body
+=head2 $c->prepare_body
Prepares message body.
}
}
-=item $c->prepare_body_chunk( $chunk )
+=head2 $c->prepare_body_chunk( $chunk )
Prepares a chunk of data before sending it to L<HTTP::Body>.
$c->engine->prepare_body_chunk( $c, @_ );
}
-=item $c->prepare_body_parameters
+=head2 $c->prepare_body_parameters
Prepares body parameters.
$c->engine->prepare_body_parameters( $c, @_ );
}
-=item $c->prepare_connection
+=head2 $c->prepare_connection
Prepares connection.
$c->engine->prepare_connection( $c, @_ );
}
-=item $c->prepare_cookies
+=head2 $c->prepare_cookies
Prepares cookies.
sub prepare_cookies { my $c = shift; $c->engine->prepare_cookies( $c, @_ ) }
-=item $c->prepare_headers
+=head2 $c->prepare_headers
Prepares headers.
sub prepare_headers { my $c = shift; $c->engine->prepare_headers( $c, @_ ) }
-=item $c->prepare_parameters
+=head2 $c->prepare_parameters
Prepares parameters.
$c->engine->prepare_parameters( $c, @_ );
}
-=item $c->prepare_path
+=head2 $c->prepare_path
Prepares path and base.
sub prepare_path { my $c = shift; $c->engine->prepare_path( $c, @_ ) }
-=item $c->prepare_query_parameters
+=head2 $c->prepare_query_parameters
Prepares query parameters.
}
}
-=item $c->prepare_read
+=head2 $c->prepare_read
Prepares the input for reading.
sub prepare_read { my $c = shift; $c->engine->prepare_read( $c, @_ ) }
-=item $c->prepare_request
+=head2 $c->prepare_request
Prepares the engine request.
sub prepare_request { my $c = shift; $c->engine->prepare_request( $c, @_ ) }
-=item $c->prepare_uploads
+=head2 $c->prepare_uploads
Prepares uploads.
}
}
-=item $c->prepare_write
+=head2 $c->prepare_write
Prepares the output for writing.
sub prepare_write { my $c = shift; $c->engine->prepare_write( $c, @_ ) }
-=item $c->request_class
+=head2 $c->request_class
Returns or sets the request class.
-=item $c->response_class
+=head2 $c->response_class
Returns or sets the response class.
-=item $c->read( [$maxlength] )
+=head2 $c->read( [$maxlength] )
-Reads a chunk of data from the request body. This method is designed to be
-used in a while loop, reading $maxlength bytes on every call. $maxlength
-defaults to the size of the request if not specified.
+Reads a chunk of data from the request body. This method is designed to
+be used in a while loop, reading C<$maxlength> bytes on every call.
+C<$maxlength> defaults to the size of the request if not specified.
-You have to set MyApp->config->{parse_on_demand} to use this directly.
+You have to set C<MyApp-E<gt>config-E<gt>{parse_on_demand}> to use this
+directly.
=cut
sub read { my $c = shift; return $c->engine->read( $c, @_ ) }
-=item $c->run
+=head2 $c->run
Starts the engine.
sub run { my $c = shift; return $c->engine->run( $c, @_ ) }
-=item $c->set_action( $action, $code, $namespace, $attrs )
+=head2 $c->set_action( $action, $code, $namespace, $attrs )
Sets an action in a given namespace.
sub set_action { my $c = shift; $c->dispatcher->set_action( $c, @_ ) }
-=item $c->setup_actions($component)
+=head2 $c->setup_actions($component)
Sets up actions for a component.
sub setup_actions { my $c = shift; $c->dispatcher->setup_actions( $c, @_ ) }
-=item $c->setup_components
+=head2 $c->setup_components
Sets up components.
return $instance;
};
- eval {
- Module::Pluggable::Fast->import(
+ eval "package $class;\n" . q!Module::Pluggable::Fast->import(
name => '_catalyst_components',
search => [
"$class\::Controller", "$class\::C",
],
callback => $callback
);
- };
+ !;
if ( my $error = $@ ) {
}
}
-=item $c->setup_dispatcher
+=head2 $c->setup_dispatcher
+
+Sets up dispatcher.
=cut
$class->dispatcher( $dispatcher->new );
}
-=item $c->setup_engine
+=head2 $c->setup_engine
+
+Sets up engine.
=cut
$class->engine( $engine->new );
}
-=item $c->setup_home
+=head2 $c->setup_home
+
+Sets up the home directory.
=cut
}
}
-=item $c->setup_log
+=head2 $c->setup_log
+
+Sets up log.
=cut
}
}
-=item $c->setup_plugins
+=head2 $c->setup_plugins
+
+Sets up plugins.
=cut
}
}
-=item $c->stack
+=head2 $c->stack
Returns the stack.
-=item $c->write( $data )
+=head2 $c->write( $data )
-Writes $data to the output stream. When using this method directly, you will
-need to manually set the Content-Length header to the length of your output
-data, if known.
+Writes $data to the output stream. When using this method directly, you
+will need to manually set the C<Content-Length> header to the length of
+your output data, if known.
=cut
return $c->engine->write( $c, @_ );
}
-=item version
+=head2 version
-Returns the Catalyst version number. Mostly useful for "powered by" messages
-in template systems.
+Returns the Catalyst version number. Mostly useful for "powered by"
+messages in template systems.
=cut
sub version { return $Catalyst::VERSION }
-=back
-
=head1 INTERNAL ACTIONS
-Catalyst uses internal actions like C<_DISPATCH>, C<_BEGIN>, C<_AUTO>
-C<_ACTION> and C<_END>, these are by default not shown in the private
-action table.
-
-But you can deactivate this with a config parameter.
+Catalyst uses internal actions like C<_DISPATCH>, C<_BEGIN>, C<_AUTO>,
+C<_ACTION>, and C<_END>. These are by default not shown in the private
+action table, but you can make them visible with a config parameter.
MyApp->config->{show_internal_actions} = 1;
=head1 CASE SENSITIVITY
-By default Catalyst is not case sensitive, so C<MyApp::C::FOO::Bar> becomes
-C</foo/bar>.
-
-But you can activate case sensitivity with a config parameter.
+By default Catalyst is not case sensitive, so C<MyApp::C::FOO::Bar> is
+mapped to C</foo/bar>. You can activate case sensitivity with a config
+parameter.
MyApp->config->{case_sensitive} = 1;
-So C<MyApp::C::Foo::Bar> becomes C</Foo/Bar>.
+This causes C<MyApp::C::Foo::Bar> to map to C</Foo/Bar>.
=head1 ON-DEMAND PARSER
The request body is usually parsed at the beginning of a request,
-but if you want to handle input yourself or speed things up a bit
+but if you want to handle input yourself or speed things up a bit,
you can enable on-demand parsing with a config parameter.
MyApp->config->{parse_on_demand} = 1;
=head1 PROXY SUPPORT
-Many production servers operate using the common double-server approach, with
-a lightweight frontend web server passing requests to a larger backend
-server. An application running on the backend server must deal with two
-problems: the remote user always appears to be '127.0.0.1' and the server's
-hostname will appear to be 'localhost' regardless of the virtual host the
-user connected through.
+Many production servers operate using the common double-server approach,
+with a lightweight frontend web server passing requests to a larger
+backend server. An application running on the backend server must deal
+with two problems: the remote user always appears to be C<127.0.0.1> and
+the server's hostname will appear to be C<localhost> regardless of the
+virtual host that the user connected through.
-Catalyst will automatically detect this situation when you are running both
-the frontend and backend servers on the same machine. The following changes
-are made to the request.
+Catalyst will automatically detect this situation when you are running
+the frontend and backend servers on the same machine. The following
+changes are made to the request.
- $c->req->address is set to the user's real IP address, as read from the
- HTTP_X_FORWARDED_FOR header.
+ $c->req->address is set to the user's real IP address, as read from
+ the HTTP X-Forwarded-For header.
- The host value for $c->req->base and $c->req->uri is set to the real host,
- as read from the HTTP_X_FORWARDED_HOST header.
+ The host value for $c->req->base and $c->req->uri is set to the real
+ host, as read from the HTTP X-Forwarded-Host header.
-Obviously, your web server must support these 2 headers for this to work.
+Obviously, your web server must support these headers for this to work.
-In a more complex server farm environment where you may have your frontend
-proxy server(s) on different machines, you will need to set a configuration
-option to tell Catalyst to read the proxied data from the headers.
+In a more complex server farm environment where you may have your
+frontend proxy server(s) on different machines, you will need to set a
+configuration option to tell Catalyst to read the proxied data from the
+headers.
MyApp->config->{using_frontend_proxy} = 1;
=head1 THREAD SAFETY
Catalyst has been tested under Apache 2's threading mpm_worker, mpm_winnt,
-and the standalone forking HTTP server on Windows. We believe the Catalyst
+and the standalone forking HTTP server on Windows. We believe the Catalyst
core to be thread-safe.
If you plan to operate in a threaded environment, remember that all other
-modules you are using must also be thread-safe. Some modules, most notably
-DBD::SQLite, are not thread-safe.
+modules you are using must also be thread-safe. Some modules, most notably
+L<DBD::SQLite>, are not thread-safe.
=head1 SUPPORT
Join #catalyst on irc.perl.org.
-Mailing-Lists:
+Mailing Lists:
http://lists.rawmode.org/mailman/listinfo/catalyst
http://lists.rawmode.org/mailman/listinfo/catalyst-dev
=head1 SEE ALSO
-=over 4
-
-=item L<Catalyst::Manual> - The Catalyst Manual
+=head2 L<Task::Catalyst> - All you need to start with Catalyst
-=item L<Catalyst::Component>, L<Catalyst::Base> - Base classes for components
+=head2 L<Catalyst::Manual> - The Catalyst Manual
-=item L<Catalyst::Engine> - Core Engine
+=head2 L<Catalyst::Component>, L<Catalyst::Base> - Base classes for components
-=item L<Catalyst::Log> - The Log Class.
+=head2 L<Catalyst::Engine> - Core engine
-=item L<Catalyst::Request> - The Request Object
+=head2 L<Catalyst::Log> - Log class.
-=item L<Catalyst::Response> - The Response Object
+=head2 L<Catalyst::Request> - Request object
-=item L<Catalyst::Test> - The test suite.
+=head2 L<Catalyst::Response> - Response object
-=back
+=head2 L<Catalyst::Test> - The test suite.
=head1 CREDITS
David Naughton
+Drew Taylor
+
Gary Ashton Jones
Geoff Richards