use Scalar::Util qw/weaken/;
use attributes;
+# For PAR
+require Catalyst::Helper;
+require Catalyst::PAR;
+require Catalyst::Build;
+require Catalyst::Test;
+
+require Catalyst::Engine::HTTP;
+require Catalyst::Engine::CGI;
+
+require Catalyst::Controller;
+require Catalyst::Model;
+require Catalyst::View;
+
__PACKAGE__->mk_accessors(
qw/counter request response state action stack namespace/
);
require Module::Pluggable::Fast;
# Helper script generation
-our $CATALYST_SCRIPT_GEN = 11;
+our $CATALYST_SCRIPT_GEN = 18;
__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.57';
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 { ... }
-
- # 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:
=item -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
-Forces Catalyst to use a specific home directory.
+Forces Catalyst to use a specific home directory, e.g.:
+
+ use Catalyst qw[-Home=/usr/sri];
=item -Log
=item $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
-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:
+
+ # in Controller::Foo::Bar
+ $c->namespace; # returns 'foo/bar';
=item $c->request
=item $c->req
-Returns the current L<Catalyst::Request> object.
-
- my $req = $c->req;
+Returns the current L<Catalyst::Request> object. See
+L<Catalyst::Request>.
=back
=item $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');
Returns the current L<Catalyst::Response> object.
- my $res = $c->res;
-
=item $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 } );
=item $c->component($name)
-Gets a component object by name. This method is no longer recommended.
-$c->controller, $c->model, and $c->view should be used instead.
+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) {
=item $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
-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
-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
=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:
=item $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' );
=item 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/ );
=item $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" ),
+ return URI->new_abs( URI->new_abs( "$path$args", "$basepath$namespace" ),
$base )->canonical;
}
=head1 INTERNAL METHODS
-=over 4
+These methods are not meant to be used by end users.
-=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;
-}
+=over 4
=item $c->components
=item $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
Returns or sets the dispatcher class.
-=item dump_these
+=item $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
$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);
+ push @{ $c->{stats} }, [ $action, sprintf( '%fs', $elapsed ) ];
}
- else {
- $c->state( &$code( $class, $c, @{ $c->req->args } ) || 0 );
- }
- };
+ }
pop( @{ $c->stack } );
if ( my $error = $@ ) {
=item $c->finalize_uploads
-Finalizes uploads. Cleans up any temporary files.
+Finalizes uploads. Cleans up any temporary files.
=cut
=item $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
};
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 ) );
=item $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->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
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
+Sets up dispatcher.
+
=cut
sub setup_dispatcher {
=item $c->setup_engine
+Sets up engine.
+
=cut
sub setup_engine {
=item $c->setup_home
+Sets up the home directory.
+
=cut
sub setup_home {
=item $c->setup_log
+Sets up log.
+
=cut
sub setup_log {
=item $c->setup_plugins
+Sets up plugins.
+
=cut
sub setup_plugins {
=item $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
=item 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
=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
=item L<Catalyst::Component>, L<Catalyst::Base> - Base classes for components
-=item L<Catalyst::Engine> - Core Engine
+=item L<Catalyst::Engine> - Core engine
-=item L<Catalyst::Log> - The Log Class.
+=item L<Catalyst::Log> - Log class.
-=item L<Catalyst::Request> - The Request Object
+=item L<Catalyst::Request> - Request object
-=item L<Catalyst::Response> - The Response Object
+=item L<Catalyst::Response> - Response object
=item L<Catalyst::Test> - The test suite.
projects / catagits/Catalyst-Runtime.git / blobdiff