Made abstract process method die.
=head1 SEE ALSO
-L<Catalyst::Manual>, L<Catalyst::Test>, L<Catalyst::Request>,
-L<Catalyst::Response>, L<Catalyst::Engine>
+=over 4
+
+=item L<Catalyst::Manual> - The Catalyst Manual
+
+=item L<Catalyst::Engine> - Core Engine
+
+=item L<Catalyst::Log> - The Log Class.
+
+=item L<Catalyst::Request> - The Request Object
+
+=item L<Catalyst::Response> - The Response Object
+
+=item L<Catalyst::Test> - The test suite.
+
+=back
=head1 AUTHOR
__PACKAGE__->mk_classdata($_) for qw/_cache _config/;
__PACKAGE__->_cache( [] );
+# note - see attributes(3pm)
sub MODIFY_CODE_ATTRIBUTES {
my ( $class, $code, @attrs ) = @_;
push @{ $class->_cache }, [ $code, [@attrs] ];
# Methods can be a request step
$c->forward(qw/MyApp::Model::Something forward_to_me/);
- MyApp->action( 'index.html' => \&MyApp::Model::Something::forward_to_me );
# Or just methods
print $c->comp('MyApp::Model::Something')->test;
=cut
-sub process { 1 }
+sub process { die __PACKAGE__." did not override process."; }
=back
=head1 AUTHOR
Sebastian Riedel, C<sri@cpan.org>
+Marcus Ramberg, C<mramberg@cpan.org>
=head1 COPYRIGHT
=head1 DESCRIPTION
+This is the core of catalyst. The various drivers are subclasses
+of this class.
+
=head1 METHODS
=over 4
=item $c->comp($name)
+Shortcut for $c->component
+
=item $c->component($name)
Get a component object by name.
=item $c->finalize
-Finalize request.
+Finalize request. This function can typically be overloaded with
+NEXT by plugins that need to do something at the end of the request.
=cut
=item $c->finalize_error
-Finalize error.
+This is the default error screen displayed from finalize. Override
+with your own output if you need something special.
=cut
=item $c->finalize_headers
-Finalize headers.
+Finalize headers. Null action by default.
=cut
=item $c->finalize_output
-Finalize output.
+Finalize output. Null action by default
=cut
If you define a class without method it will default to process().
$c->forward('/foo');
+ $c->forward('/controller/action');
$c->forward('index');
$c->forward(qw/MyApp::Model::CDBI::Foo do_stuff/);
$c->forward('MyApp::View::TT');
=item $c->handler( $class, $r )
-Handles the request.
+The main request handler.
=cut
=item $c->prepare_action
-Prepare action.
+Prepare action for processing.
=cut
=item $c->prepare_connection
-Prepare connection.
+Prepare connection. Null action by default
=cut
=item $c->prepare_cookies
-Prepare cookies.
+Prepare cookies.
=cut
=item $c->prepare_headers
-Prepare headers.
+Prepare headers. Null action by default
=cut
=item $c->prepare_parameters
-Prepare parameters.
+Prepare parameters. Null action by default
=cut
=item $c->prepare_path
-Prepare path and base.
+Prepare path and base. Null action by default
=cut
=item $c->prepare_request
-Prepare the engine request.
+Prepare the engine request. Null action by default
=cut
=item $c->prepare_uploads
-Prepare uploads.
+Prepare uploads. Null action by default
=cut
=item $c->run
-Starts the engine.
+Starts the engine. Null action by default
=cut
sub run { }
-=item $c->request
-
=item $c->req
-Returns a C<Catalyst::Request> object.
+Shortcut for $c->request
- my $req = $c->req;
+=item $c->request
-=item $c->response
+Returns a C<Catalyst::Request> object.
+
+ my $req = $c->request;
=item $c->res
+Shortcut for $c->response
+
+=item $c->response
+
Returns a C<Catalyst::Response> object.
my $res = $c->res;
=item $c->set_action( $action, $code, $namespace, $attrs )
-Set an action in a given namespace.
+Set an action in a given namespace. Used to defined the actions
+in the attribute handlers.
=cut
=item $class->setup
-Setup.
+Setup the application. required to initialize actions.
MyApp->setup;
=item $class->setup_components
-Setup components.
+Setup all the components in YourApp::(M|V|C|Model|View|Controller)::*
=cut
=item $c->stash
-Returns a hashref containing all your data.
+The stash is a global hash which can be used to pass around data
+between your components.
$c->stash->{foo} ||= 'yada';
print $c->stash->{foo};
=back
+=head1 SEE ALSO
+
+=over 4
+
+=item L<Catalyst::Engine::Apache> - Apache Engines for MP1/2
+=item L<Catalyst::Engine::CGI> - CGI Engine
+=item L<Catalyst::Engine::FCGI> - FastCGI Engine
+=item L<Catalyst::Engine::HTTP> - Standalone Catalyst Server
+=item L<Catalyst::Engine::Test> - Engine for testing
+
+=back
+
=head1 AUTHOR
Sebastian Riedel, C<sri@cpan.org>
+Marcus Ramberg, C<mramberg@cpan.org>
=head1 COPYRIGHT
=head1 DESCRIPTION
-This module provides the default, simple logging functionality for Catalyst.
-If you want something different set C<$c->log> in your application module, e.g.:
+This module provides the default, simple logging functionality for
+Catalyst.
+If you want something different set C<$c->log> in your application
+module, e.g.:
$c->log( MyLogger->new );
=back
-=head1 DEPRECATED METHODS
-
-=over 4
-
-=item $log->dump($reference)
-
-Logs a Data::Dumper of reference.
-
=cut
-sub dump { shift->_format( 'dump', Dumper( $_[0] ) ) }
+# Private - Logs a Data::Dumper of reference.
+sub _dump { shift->_format( 'dump', Dumper( $_[0] ) ) }
-=back
=head1 SEE ALSO
=head1 AUTHOR
Sebastian Riedel, C<sri@cpan.org>
+Marcus Ramberg, C<mramberg@cpan.org>
=head1 COPYRIGHT
-This program is free software, you can redistribute it and/or modify it under
-the same terms as Perl itself.
+This program is free software, you can redistribute it and/or modify
+it under the same terms as Perl itself.
=cut
You can force Catalyst to display the debug screen at the end of the request by
placing a die() call in the _end action.
- __PACKAGE__->action(
- '!end' => sub {
- my ( $self, $c ) = @_;
- die "testing";
- }
- );
+ sub end : Private {
+ my ( $self, $c ) = @_;
+ die "testing";
+ }
If you're tired of removing and adding this all the time, you
can easily add a condition. for example:
root => '/home/joeuser/myapp/root'
);
- __PACKAGE__->action(
- 'table' => sub {
- my ( $self, $c ) = @_;
- $c->form( optional => [ MyApp::Model::CDBI::Table->columns ] );
- $c->forward('MyApp::Model::CDBI::Table');
- }
- );
+ sub my_table : Global {
+ my ( $self, $c ) = @_;
+ $c->form( optional => [ MyApp::Model::CDBI::Table->columns ] );
+ $c->forward('MyApp::Model::CDBI::Table');
+ }
1;
Modify the $c->form() parameters to match your needs, and don't forget to copy
the templates. ;)
-=head2 Serving static files and CSS as text/css
-
-If you want to serve static content (like images, txt or CSS) via Catalyst,
-then all you need is the plugin Catalyst::Plugin::Static as well as a small
-regex to set the MIME type for CSS to text/css.
-
- # lib/MyApp.pm
- package MyApp;
-
- use strict;
- use Catalyst qw/-Debug Static/;
-
- __PACKAGE__->action(
-
- '!default' => sub {
- my ( $self, $c ) = @_;
- $c->serve_static;
- },
-
- '/^.*\.css$/' => sub {
- my ( $self, $c ) = @_;
- $c->serve_static('text/css');
- },
- );
-
=head2 Uploads with Catalyst
To implement uploads in Catalyst you need to have a HTML form similiar to
Catalyst Controller module 'upload' action:
- MyApp->action(
-
- 'upload' => sub {
+ sub upload : Global {
my ($self, $c) = @_;
if ($c->req->parameters->{form_submit} eq 'yes') {
my $filename = $c->req->parameters->{my_file};
}
$c->stash->{template} = 'upload_form.tt';
$c->forward('MyApp::V::View');
- },
- );
+ }
If you want to upload bigger files than 1MB, then just add to your Controller
module:
To log in a user you might use a action like this:
- '?login' => sub {
+ sub 'login' : Local {
my ($self, $c) = @_;
if ($c->req->params->{username}) {
$c->session_login($c->req->params->{username},
- $c->req->params->{password} );
+ $c->req->params->{password} );
if ($c->req->{user}) {
$c->forward('?restricted_area');
}
}
- },
+ }
$c->req->params->{username} and $c->req->params->{password} are html
-form parameters from a login form. If login succeeds, then $c->req->{user}
-contains the username of the authenticated user.
+form parameters from a login form. If login succeeds, then
+$c->req->{user} contains the username of the authenticated user.
-If you want to remember the users login status inbetween further requests,
-then just use the $c->session_login method, Catalyst will create a session
-id, session cookie and automatically append session id to all urls. So
-all you have to do, is just check $c->req->{user} where needed.
+If you want to remember the users login status inbetween further
+requests, then just use the $c->session_login method, Catalyst will
+create a session id, session cookie and automatically append session
+id to all urls. So all you have to do, is just check $c->req->{user}
+where needed.
To log out user, just call $c->session_logout.
foreign key(role_id) references roles(role_id)
);
-The 'roles' table is a list of role names and the 'user_role' table is used for
-the user -> role lookup.
+The 'roles' table is a list of role names and the 'user_role' table is
+used for the user -> role lookup.
-Now if a logged in user wants to see a location which is allowed only for
-people with 'admin' role then in you controller you can check it with:
+Now if a logged in user wants to see a location which is allowed only
+for people with 'admin' role then in you controller you can check it
+with:
- '?add' => sub {
+ sub add : Local {
my ($self, $c) = @_;
if ($c->roles(qw/admin/)) {
$c->req->output("Your account has the role 'admin.'");
} else {
$c->req->output("You're not allowed to be here");
}
- },
+ }
One thing you might need is to forward non-authenticated users to login
form, if they try to access restricted areas. If you want to do this
controller-wide (if you have one controller for admin section) then it's
best to add user check to '!begin' action:
- '!begin' => sub {
+ sub begin : Private {
my ($self, $c) = @_;
unless ($c->req->{user}) {
$c->req->action(undef); ## notice this!!
$c->forward('?login');
}
- },
+ }
Pay attention to $c->req->action(undef). This is needed, because of the
way $c->forward works - forward to login gets called, but after that
-Catalyst executes anyway the action defined in the uri (eg. if you tried to
-watch /add, then first '!begin' forwards to '?login', but after that
-anyway '?add' is executed). So $c->req->action(undef) undefines any
+Catalyst executes anyway the action defined in the uri (eg. if you
+tried to watch /add, then first 'begin' forwards to 'login', but after
+that anyway 'add' is executed). So $c->req->action(undef) undefines any
actions that were to be called and forwards user where we want him/her
to be.
=head2 How to use Catalyst without mod_perl
Catalyst applications give optimum performance when run under mod_perl.
-However sometimes mod_perl is not an option, and running under CGI is just too
-slow. There are two alternatives to mod_perl that give reasonable
-performance: FastCGI and PersistentPerl.
+However sometimes mod_perl is not an option, and running under CGI is
+just too slow. There are two alternatives to mod_perl that give
+reasonable performance: FastCGI and PersistentPerl.
B<Using FastCGI>
-To quote from L<http://www.fastcgi.com/>: "FastCGI is a language independent,
-scalable, extension to CGI that provides high performance without the
-limitations of specific server APIs." Web server support is provided for
-Apache in the form of C<mod_fastcgi> and there is Perl support in the C<FCGI>
-module. To convert a CGI Catalyst application to FastCGI one needs to
-initialize an C<FCGI::Request> object and loop while the C<Accept> method
-returns zero. The following code shows how it is done - and it also works as
-a normal, single-shot CGI script.
+To quote from L<http://www.fastcgi.com/>: "FastCGI is a language
+independent, scalable, extension to CGI that provides high performance
+without the limitations of specific server APIs." Web server support
+is provided for Apache in the form of C<mod_fastcgi> and there is Perl
+support in the C<FCGI> module. To convert a CGI Catalyst application
+to FastCGI one needs to initialize an C<FCGI::Request> object and loop
+while the C<Accept> method returns zero. The following code shows how
+it is done - and it also works as a normal, single-shot CGI script.
#!/usr/bin/perl
use strict;
MyApp->run;
}
-Any initialization code should be included outside the request-accept loop.
+Any initialization code should be included outside the request-accept
+loop.
There is one little complication, which is that C<MyApp->run> outputs a
-complete HTTP response including the status line (e.g.: "C<HTTP/1.1 200>").
-FastCGI just wants a set of headers, so the sample code captures the output
-and drops the first line if it is an HTTP status line (note: this may change).
-
-The Apache C<mod_fastcgi> module is provided by a number of Linux distros and
-is straightforward to compile for most Unix-like systems. The module provides
-a FastCGI Process Manager, which manages FastCGI scripts. You configure your
-script as a FastCGI script with the following Apache configuration directives:
+complete HTTP response including the status line (e.g.:
+"C<HTTP/1.1 200>").
+FastCGI just wants a set of headers, so the sample code captures the
+output and drops the first line if it is an HTTP status line (note:
+this may change).
+
+The Apache C<mod_fastcgi> module is provided by a number of Linux
+distros and is straightforward to compile for most Unix-like systems.
+The module provides a FastCGI Process Manager, which manages FastCGI
+scripts. You configure your script as a FastCGI script with the
+following Apache configuration directives:
<Location /fcgi-bin>
AddHandler fastcgi-script fcgi
scripts spawned; it also allows scripts to be run to handle the
authentication, authorization and access check phases.
-For more information see the FastCGI documentation, the C<FCGI> module and
-L<http://www.fastcgi.com/>.
+For more information see the FastCGI documentation, the C<FCGI> module
+and L<http://www.fastcgi.com/>.
B<PersistentPerl>
-PersistentPerl (previously known as C<CGI::SpeedyCGI>) is a persistent Perl
-interpreter. After the script is initially run, instead of exiting, the perl
-interpreter is kept running. During subsequent runs, this interpreter is used
-to handle new executions instead of starting a new perl interpreter each
-time. A very fast frontend program contacts the persistent Perl process, which
-is usually already running, to do the work and return the results.
-PersistentPerl can be used to speed up perl CGI scripts. It also provides an
-Apache module so that scripts can be run without the overhead of doing a
-fork/exec for each request.
+PersistentPerl (previously known as C<CGI::SpeedyCGI>) is a persistent
+Perl interpreter. After the script is initially run, instead of
+exiting, the perl interpreter is kept running. During subsequent runs,
+this interpreter is used to handle new executions instead of starting
+a new perl interpreter each time. A very fast frontend program contacts
+the persistent Perl process, which is usually already running, to do
+the work and return the results.
+PersistentPerl can be used to speed up perl CGI scripts. It also
+provides an Apache module so that scripts can be run without the
+overhead of doing a fork/exec for each request.
-The code for PersistentPerl is simpler than for FastCGI; rather than waiting
-in an accept loop the script runs to completion, however variables are not
-reinitialized on subsequent runs but maintain their values from the previous
-run.
+The code for PersistentPerl is simpler than for FastCGI; rather than
+waiting in an accept loop the script runs to completion, however
+variables are not reinitialized on subsequent runs but maintain their
+values from the previous run.
#!/usr/bin/perperl
Sebastian Riedel, C<sri@oook.de>
Danijel Milicevic C<me@danijel.de>
Viljo Marrandi C<vilts@yahoo.com>
+Marcus Ramberg C<mramberg@cpan.org>
=head1 COPYRIGHT
-This program is free software, you can redistribute it and/or modify it under
-the same terms as Perl itself.
+This program is free software, you can redistribute it and/or modify it
+under the same terms as Perl itself.
This document aims to get you up and running with Catalyst.
-NOTE: THIS DOCUMENT IS STILL VERY MUCH IN AN EARLY DRAFT STATE. SEE THE NOTES
-AT THE BOTTOM OF THE DOCUMENT.
-
-
+NOTE: THIS DOCUMENT IS STILL VERY MUCH IN AN EARLY DRAFT STATE. SEE
+THE NOTES AT THE BOTTOM OF THE DOCUMENT.
=head2 Installation
-The first step is to install Catalyst, and the simplest way to do this is to
-install the Catalyst bundle from CPAN:
+The first step is to install Catalyst, and the simplest way to do this
+is to install the Catalyst bundle from CPAN:
$ perl -MCPAN -e 'install Bundle::Catalyst'
-This will retrieve Catalyst and a number of useful extensions and install them
-for you.
+This will retrieve Catalyst and a number of useful extensions and
+install them for you.
=head2 Setting up your application
-Catalyst includes a helper script, C<catalyst.pl>, that will set up a skeleton
-application for you:
+Catalyst includes a helper script, C<catalyst.pl>, that will set up a
+skeleton application for you:
$ catalyst.pl My::App
created "My-App"
created "My-App/script/test.pl"
created "My-App/script/create.pl"
-This creates the directory structure shown, populated with skeleton files.
+This creates the directory structure shown, populated with skeleton
+files.
$ cd My-App
$ script/server.pl
[...] [catalyst] [debug] Debug messages enabled
- [...] [catalyst] [debug] Loaded engine "Catalyst::Engine::CGI"
- [...] [catalyst] [debug] Initialized components ""
- [...] [catalyst] [info] My::App powered by Catalyst 4.26
- [...] [catalyst] [debug] "My::App" defined "!default" as "CODE(0x83fd570)"
+ [...] [catalyst] [debug] Loaded engine "Catalyst::Engine::HTTP"
+ [...] [catalyst] [debug] Loaded private actions
+ .=----------------------+----------------------+---------------=.
+ | Private | Class | Code |
+ |=----------------------+----------------------+---------------=|
+ | /default | MyApp | CODE(0x86f08ac |
+ '=----------------------+----------------------+---------------='
+ "My::App" defined "!default" as "CODE(0x83fd570)"
+ [...] [catalyst] [info] My::App powered by Catalyst 5.00
You can connect to your server at http://localhost:3000
-(Note that each line logged by Catalyst includes a timestamp, which has been
-replaced here with "C<...>" so that the text fits onto the lines.)
+(Note that each line logged by Catalyst includes a timestamp, which has
+been replaced here with "C<...>" so that the text fits onto the lines.)
-The server is now waiting for you to make requests of it. Try using telnet to
-manually make a simple GET request of the server (when telnet responds with
-"Escape character is '^]'.", type "GET / HTTP/1.0" and hit return twice):
+The server is now waiting for you to make requests of it. Try using
+telnet to manually make a simple GET request of the server (when
+telnet responds with "Escape character is '^]'.", type "GET / HTTP/1.0"
+and hit return twice):
$ telnet localhost 3000
Trying 127.0.0.1...
GET / HTTP/1.0
HTTP/1.0 200
- Server: Catalyst/4.26
+ Server: Catalyst/5.00
Status: 200
Date: Sun, 20 Mar 2005 12:31:55 GMT
- X-catalyst: 4.26
+ X-catalyst: 5.00
Content-length: 40
Content-Type: text/html; charset=ISO-8859-1
[...] [catalyst] [debug] ********************************
[...] [catalyst] [debug] * Request 1 (0.027/s) [9818]
[...] [catalyst] [debug] ********************************
- [...] [catalyst] [debug] "GET" request for ""
- [...] [catalyst] [debug] Using default action
- [...] [catalyst] [info] Processing "!default" took 0.000033s
+ [...] [catalyst] [debug] "GET" request for "" from localhost
[...] [catalyst] [info] Request took 0.051399s (19.456/s)
+ .=--------------------------------------------------+----------=.
+ | Action | Time |
+ |=--------------------------------------------------+----------=|
+ | /default | 0.000026s |
+ '=--------------------------------------------------+----------='
The server will continue running until you interrupt it.
=head2 Getting your application invoked
-Catalyst applications are usually run from mod_perl, but can also be run as
-CGI or FastCGI scripts. Running under mod_perl gives better performance, but
-for development purposes you may want to run your application as a CGI script,
-especially as changes to your application code take effect under CGI without
-having to restart the web server.
+Catalyst applications are usually run from mod_perl, but can also be
+run as CGI or FastCGI scripts. Running under mod_perl gives better
+performance, but for development purposes you may want to run your
+application as a CGI script, especially as changes to your application
+code take effect under CGI without having to restart the web server.
To run from mod_perl you need to add something like this to your Apache
configuration file:
My::App->run;
-Catalyst outputs a complete HTTP response, which is not what is expected of a
-CGI script. You need to configure the script as a so-called "Non-parsed
-Headers" script for it to function properly. To do this in Apache just name
-the script starting with C<nph->.
-
-CHECK: is this statement still valid for Cat5?
=head2 Examining the generated code
-The generated application code is quite simple and looks something like this:
+The generated application code is quite simple and looks something
+like this:
package My::App;
our $VERSION = '0.01';
My::App->config(
- name => 'My::App',
- root => '/home/andrew/My-App/root',
+ name => 'My::App',
+ root => '/home/andrew/My-App/root',
);
- My::App->action(
- '!default' => sub {
- my ( $self, $c ) = @_;
- $c->res->output('Congratulations, My::App is on Catalyst!');
- },
- );
+ __PACKAGE__->setup();
+
+ sub default : Private {
+ my ( $self, $c ) = @_;
+ $c->res->output('Congratulations, My::App is on Catalyst!');
+ }
1;
-When the C<Catalyst> module is imported by the application code, Catalyst
-performs the first stage of its initialization. This includes loading the
-appropriate Engine module for the environment in which the application is
-running, loading any plugins and ensuring that the calling module (the
-application module) inherits from C<Catalyst> (which makes the Catalyst
-methods C<config> and C<action> available to the application module).
+When the C<Catalyst> module is imported by the application code,
+Catalyst performs the first stage of its initialization. This includes
+loading the appropriate Engine module for the environment in which the
+application is running, loading any plugins and ensuring that the
+calling module (the application module) inherits from C<Catalyst>
+(which makes the Catalyst methods C<config> and C<setup> available to
+the application module).
-The call to C<config> sets up configuration data for the application. The
-C<name> and C<root> items are the minimum required, and specify the name of
-the application and the path to the root directory where documents, images and
-templates can be found.
+The call to C<config> sets up configuration data for the application.
+The C<name> and C<root> items are the minimum required, and specify
+the name of the application and the path to the root directory where
+documents, images and templates can be found.
-Catalyst associates I<actions> with URLs and on receiving a request dispatches
-to the action that matches to request URL. The call to C<action> in the code
-above registers a default action. With just this action registered the
-application will respond to all requests with the same message
-"Congratulations, My::App is on Catalyst!".
+Catalyst associates I<actions> with URLs and on receiving a request
+dispatches to the action that matches to request URL. The call to
+C<setup> in the code above registers a default action. With just
+this action registered the application will respond to all requests
+with the same message "Congratulations, My::App is on Catalyst!".
-TODO: mention private actions and attributes
+As you see, the default action is defined as a Private action.
+Most private actions are not directly available from a web url. The
+exceptions are the built-in actions, 'default','begin','end' and
+'auto'. The rest can only be reached by using C<forward>.
-The first call to the C<action> method triggers the second stage of Catalyst's
-initialization process. In this phase Catalyst searches for any component
-modules, locating and registering any actions it finds in those modules.
+The call to the C<setup> method also triggers the second stage of
+Catalyst's initialization process. In this phase Catalyst searches
+for any component modules, locating and registering any actions it
+finds in those modules.
+
Component modules have names prefixed with the application module name,
-followed by C<Model>, C<View> or C<Controller> (or the alternative short
+followed by C<Model>, C<View> or C<Controller> (or the default short
forms: C<M>, C<V> or C<C>) followed by the component name, for example:
- My::App::Controller::ShoppingCart
-
+ My::App::Controller::ShoppingCart # long version
+ My::App::C::ShoppingCart # short version
=head2 Extending the generated code
-NOTE: this section is outdated by Cat5.
You can start extending the application by adding new actions:
- My::App->action(
- 'test1' => sub {
- my ( $self, $c ) = @_;
- $c->res->output('In a new test action #1');
- },
- 'test1' => sub {
- my ( $self, $c ) = @_;
- $c->res->output('In a new test action #1');
- },
- '!default' => sub {
- my ( $self, $c ) = @_;
- $c->res->output('Congratulations, My::App is on Catalyst!');
- },
- );
+ sub test1 : Global {
+ my ( $self, $c ) = @_;
+ $c->res->output('In a new test action #1');
+ }
+ sub default : Private {
+ my ( $self, $c ) = @_;
+ $c->res->output('Congratulations, My::App is on Catalyst!');
+ }
TODO: explain briefly about plugins, actions and components
-regex actions passed subexpression matches in $c->req->snippets (array ref).
+regex actions passed subexpression matches in $c->req->snippets
+(array ref).
=head2 Hooking in to Template Toolkit
-One of the first things you will probably want to add to your application is a
-templating system for generating your output. Catalyst works well with
-Template Toolkit. If you are unfamiliar with Template Toolkit then I suggest
-you look at L<http://tt2.org>, install C<Template>, read the documentation and
-play around with it, and have a look at the I<Badger Book> (I<Template
-Toolkit> by Darren Chamberlain, Dave Cross and Andy Wardly, O'Reilly &
-Associates, 2004).
+One of the first things you will probably want to add to your
+application is a templating system for generating your output.
+Catalyst works well with Template Toolkit. If you are unfamiliar with
+Template Toolkit then I suggest you look at L<http://tt2.org>, install
+C<Template>, read the documentation and play around with it, and have
+a look at the I<Badger Book> (I<Template Toolkit> by Darren
+Chamberlain, Dave Cross and Andy Wardly, O'Reilly & Associates, 2004).
-You can create a stub Template Toolkit view component using the create script
-that Catalyst set up as part of the skeleton application:
+You can create a stub Template Toolkit view component using the create
+script that Catalyst set up as part of the skeleton application:
$ script/create.pl view TT TT
-this generates a view component named C<My::App::View::TT>, which you might
-use by forwarding from your C<end> action:
+this generates a view component named C<My::App::View::TT>, which you
+might use by forwarding from your C<end> action:
# In My::App or My::App::Controller::SomeController
$c->forward('My::App::View::TT');
}
-The generated TT view component simply subclasses the C<Catalyst::View::TT>
-class. It looks like this (with the POD stripped out):
+The generated TT view component simply subclasses the
+C<Catalyst::View::TT> class. It looks like this (with the POD
+stripped out):
package My::App::V::TT;
1;
-C<Catalyst::View::TT> initializes a Template Toolkit object with an options
-hash initialized with built-in default settings followed by the contents of
-the hash C<<%{__PACKAGE__->config()}>>. You can configure TT more to your
-needs by adding a C<new> method to the generated TT component:
+C<Catalyst::View::TT> initializes a Template Toolkit object with an
+options hash initialized with built-in default settings followed by
+the contents of the hash C<<%{__PACKAGE__->config()}>>. You can
+configure TT more to your needs by adding a C<new> method to the
+generated TT component:
sub new {
- my $self = shift;
- $self->config->{PRE_PROCESS} = 'config/main';
- $self->config->{WRAPPER} = 'site/wrapper';
- return $self->SUPER::new(@_);
+ my $self = shift;
+ $self->config->{PRE_PROCESS} = 'config/main';
+ $self->config->{WRAPPER} = 'site/wrapper';
+ return $self->SUPER::new(@_);
}
=head1 AUTHOR
Andrew Ford, C<A.Ford@ford-mason.co.uk>
+Marcus Ramberg, C<mramberg@cpan.org>
-As noted above, this document is at an alpha stage. My plan for this document
-is as follows:
+As noted above, this document is at an alpha stage. My plan for this
+document is as follows:
=over 4
=head1 COPYRIGHT
-This program is free software, you can redistribute it and/or modify it under
-the same terms as Perl itself.
+This program is free software, you can redistribute it and/or modify
+it under the same terms as Perl itself.
=item $req->action
-Contains the action.
+Contains the requested action.
print $c->request->action;
print $c->request->address
-=item $req->arguments
-
=item $req->args
+Shortcut for arguments
+
+=item $req->arguments
+
Returns a reference to an array containing the arguments.
print $c->request->arguments->[0];
=item $req->base
-Contains the uri base.
+Contains the url base. This will always have a trailing slash.
=item $req->content_encoding
=item $req->hostname
-Contains the remote hostname.
+Contains the hostname of the remote user.
print $c->request->hostname
=item $req->match
-Contains the match.
+This contains be the matching part of a regexp action. otherwise it
+returns the same as 'action'.
print $c->request->match;
print $c->request->method
-=item $req->parameters
-
=item $req->params
+Shortcut for $req->parameters.
+
+=item $req->parameters
+
Returns a reference to a hash containing the parameters.
print $c->request->parameters->{foo};
=item $req->referer
-Shortcut to $req->headers->referer
+Shortcut to $req->headers->referer. Referring page.
=item $req->snippets
=item $req->user_agent
-Shortcut to $req->headers->user_agent
+Shortcut to $req->headers->user_agent. User Agent version string.
=back
=head1 AUTHOR
Sebastian Riedel, C<sri@cpan.org>
+Marcus Ramberg, C<mramberg@cpan.org>
=head1 COPYRIGHT
-This program is free software, you can redistribute it and/or modify it under
-the same terms as Perl itself.
+This program is free software, you can redistribute it and/or modify
+it under the same terms as Perl itself.
=cut
=head1 DESCRIPTION
-This is the Catalyst Response class, which provides a set of accessors to
-response data.
+This is the Catalyst Response class, which provides a set of accessors
+to response data.
=head1 METHODS
=item $resp->cookies
-Returns a reference to a hash containing the cookies.
+Returns a reference to a hash containing the cookies to be set.
$c->response->cookies->{foo} = { value => '123' };
Contains the final output.
- $c->response->output('Catalyst rockz!');
+ $c->response->output('Catalyst rocks!');
=item $resp->redirect($url)
=head1 AUTHOR
Sebastian Riedel, C<sri@cpan.org>
+Marcus Ramberg, C<mramberg@cpan.org>
=head1 COPYRIGHT
-This program is free software, you can redistribute it and/or modify it under
-the same terms as Perl itself.
+This program is free software, you can redistribute it and/or modify
+it under the same terms as Perl itself.
=cut
projects / catagits/Catalyst-Runtime.git / commitdiff