=head1 DESCRIPTION
-This is a brief overview of why and how to use Catalyst. It explains how Catalyst works and shows how to get a simple application up and running quickly.
+This is a brief overview of why and how to use Catalyst. It explains how
+Catalyst works and shows how to get a simple application up and running quickly.
=head2 What is Catalyst?
-Catalyst is an elegant web application framework, extremely flexible yet extremely simple. It's similar to Ruby on Rails, Spring (Java) and L<Maypole>, upon which it was originally based.
+Catalyst is an elegant web application framework, extremely flexible yet
+extremely simple. It's similar to Ruby on Rails, Spring (Java) and L<Maypole>,
+upon which it was originally based.
=head3 MVC
-Catalyst follows the Model-View-Controller (MVC) design pattern, allowing you to easily separate concerns, like content, presentation, and flow control, into separate modules. This separation allows you to modify code that handles one concern without affecting code that handles the others. Catalyst promotes the re-use of existing Perl modules that already handle common web application concerns well.
+Catalyst follows the Model-View-Controller (MVC) design pattern, allowing you to
+easily separate concerns, like content, presentation, and flow control, into
+separate modules. This separation allows you to modify code that handles one
+concern without affecting code that handles the others. Catalyst promotes the
+re-use of existing Perl modules that already handle common web application
+concerns well.
-Here's how the M, V, and C map to those concerns, with examples of well-known Perl modules you may want to use for each.
+Here's how the M, V, and C map to those concerns, with examples of well-known
+Perl modules you may want to use for each.
=over 4
=item * B<View>
-Present content to the user. L<Template Toolkit|Template>, L<Mason|HTML::Mason>, L<HTML::Template>...
+Present content to the user. L<Template Toolkit|Template>, L<Mason|HTML::Mason>,
+L<HTML::Template>...
=item * B<Controller>
-Control the whole request phase, check parameters, dispatch actions, flow control. Catalyst!
+Control the whole request phase, check parameters, dispatch actions, flow
+control. Catalyst!
=back
-If you're unfamiliar with MVC and design patterns, you may want to check out the original book on the subject, I<Design Patterns>, by Gamma, Helm, Johson and Vlissides, also known as the Gang of Four (GoF). You can also just google it. Many, many web application frameworks are based on MVC, including all those listed above.
+If you're unfamiliar with MVC and design patterns, you may want to check out the
+original book on the subject, I<Design Patterns>, by Gamma, Helm, Johson and
+Vlissides, also known as the Gang of Four (GoF). You can also just google it.
+Many, many web application frameworks are based on MVC, including all those
+listed above.
=head3 Flexibility
-Catalyst is much more flexible than many other frameworks. We'll talk more about this later, but rest assured you can use your favorite Perl modules with Catalyst.
+Catalyst is much more flexible than many other frameworks. We'll talk more about
+this later, but rest assured you can use your favorite Perl modules with
+Catalyst.
=over 4
=item * B<Multiple Models, Views, and Controllers>
-To build a Catalyst application, you handle each type of concern inside special modules called L</Components>. Often this code will be very simple, just calling out to Perl modules like those listed above under L</MVC>. Catalyst handles these components in a very flexible way. Use as many Models, Views, and Controllers as you like, using as many different Perl modules as you like, all in the same application. Want to manipulate multiple databases, and retrieve some data via LDAP? No problem. Want to present data from the same Model using L<Template Toolkit|Template> and L<PDF::Template>? Easy.
+To build a Catalyst application, you handle each type of concern inside special
+modules called L</Components>. Often this code will be very simple, just calling
+out to Perl modules like those listed above under L</MVC>. Catalyst handles
+these components in a very flexible way. Use as many Models, Views, and
+Controllers as you like, using as many different Perl modules as you like, all
+in the same application. Want to manipulate multiple databases, and retrieve
+some data via LDAP? No problem. Want to present data from the same Model using
+L<Template Toolkit|Template> and L<PDF::Template>? Easy.
=item * B<Reuseable Components>
-Not only does Catalyst promote the re-use of already existing Perl modules, it also allows you to re-use your Catalyst components in multiple Catalyst applications.
+Not only does Catalyst promote the re-use of already existing Perl modules, it
+also allows you to re-use your Catalyst components in multiple Catalyst
+applications.
=item * B<Unrestrained URL-to-Action Dispatching>
-Catalyst allows you to dispatch any URLs to any application L<Actions>, even through regular expressions! Unlike most other frameworks, it doesn't require mod_rewrite or class and method names in URLs.
+Catalyst allows you to dispatch any URLs to any application L<Actions>, even
+through regular expressions! Unlike most other frameworks, it doesn't require
+mod_rewrite or class and method names in URLs.
With Catalyst you register your actions and address them directly. For example:
=head3 Simplicity
-The best part is that Catalyst implements all this flexibility in a very simple way.
+The best part is that Catalyst implements all this flexibility in a very simple
+way.
=over 4
=item * B<Building Block Interface>
-Components interoperate very smoothly. For example, Catalyst automatically makes a L<Context> object available to every component. Via the context, you can access the request object, share data between components, and control the flow of your application. Building a Catalyst application feels a lot like snapping together toy building blocks, and everything just works.
+Components interoperate very smoothly. For example, Catalyst automatically makes
+a L<Context> object available to every component. Via the context, you can
+access the request object, share data between components, and control the flow
+of your application. Building a Catalyst application feels a lot like snapping
+together toy building blocks, and everything just works.
=item * B<Component Auto-Discovery>
-No need to C<use> all of your components. Catalyst automatically finds and loads them.
+No need to C<use> all of your components. Catalyst automatically finds and loads
+them.
=item * B<Pre-Built Components for Popular Modules>
-See L<Catalyst::Model::CDBI> for L<Class::DBI>, or L<Catalyst::View::TT> for L<Template Toolkit|Template>. You can even get an instant web database front end with L<Catalyst::Model::CDBI::CRUD>.
+See L<Catalyst::Model::CDBI> for L<Class::DBI>, or L<Catalyst::View::TT> for
+L<Template Toolkit|Template>. You can even get an instant web database front end
+with L<Catalyst::Model::CDBI::CRUD>.
=item * B<Built-in Test Framework>
-Catalyst comes with a built-in, lightweight http server and test framework, making it easy to test applications from the command line.
+Catalyst comes with a built-in, lightweight http server and test framework,
+making it easy to test applications from the command line.
=item * B<Helper Scripts>
-Catalyst provides helper scripts to quickly generate running starter code for components and unit tests.
+Catalyst provides helper scripts to quickly generate running starter code for
+components and unit tests.
=back
=head2 Quickstart
-Here's how to install Catalyst and get a simple application up and running, using the helper scripts described above.
+Here's how to install Catalyst and get a simple application up and running,
+using the helper scripts described above.
=head3 Install
$ script/myapp_server.pl
-Now visit these locations with your favorite browser or user agent to see Catalyst in action:
+Now visit these locations with your favorite browser or user agent to see
+Catalyst in action:
=over 4
=head2 How It Works
-Let's see how Catalyst works, by taking a closer look at the components and other parts of a Catalyst application.
+Let's see how Catalyst works, by taking a closer look at the components and
+other parts of a Catalyst application.
=head3 Application Class
-In addition to the Model, View, and Controller components, there's a single class that represents your application itself. This is where you configure your application, load plugins, define application-wide actions, and extend Catalyst.
+In addition to the Model, View, and Controller components, there's a single
+class that represents your application itself. This is where you configure your
+application, load plugins, define application-wide actions, and extend Catalyst.
package MyApp;
1;
-For most applications, Catalyst requires you to define only two config parameters:
+For most applications, Catalyst requires you to define only two config
+parameters:
=over 4
=back
-However, you can define as many parameters as you want for plugins or whatever you need. You can access them anywhere in your application via C<$context-E<gt>config-E<gt>{$param_name}>.
+However, you can define as many parameters as you want for plugins or whatever
+you need. You can access them anywhere in your application via
+C<$context-E<gt>config-E<gt>{$param_name}>.
=head3 Context
-Catalyst automatically blesses a Context object into your application class and makes it available everywhere in your application. Use the Context to directly interact with Catalyst and glue your L<Components> together. For example, if you need to use the Context from within a Template Toolkit template, it's already there:
+Catalyst automatically blesses a Context object into your application class and
+makes it available everywhere in your application. Use the Context to directly
+interact with Catalyst and glue your L<Components> together. For example, if you
+need to use the Context from within a Template Toolkit template, it's already
+there:
<h1>Welcome to [% c.config.name %]!</h1>
-As illustrated earlier in our URL-to-Action dispatching example, the Context is always the second method parameter, behind the Component object reference or class name itself. Previously we called it C<$context> for clarity, but most Catalyst developers just call it C<$c>:
+As illustrated earlier in our URL-to-Action dispatching example, the Context is
+always the second method parameter, behind the Component object reference or
+class name itself. Previously we called it C<$context> for clarity, but most
+Catalyst developers just call it C<$c>:
sub hello : Global {
my ( $self, $c ) = @_;
$c->request
$c->req # alias
-The request object contains all kinds of request-specific information, like query parameters, cookies, uploads, headers, and more.
+The request object contains all kinds of request-specific information, like
+query parameters, cookies, uploads, headers, and more.
$c->req->params->{foo};
$c->req->cookies->{sessionid};
$c->response
$c->res # alias
-The response is like the request, but contains just response-specific information.
+The response is like the request, but contains just response-specific
+information.
$c->res->output('Hello World');
$c->res->status(404);
=back
-The last of these, the stash, is a universal hash for sharing data among application components. For an example, we return to our 'hello' action:
+The last of these, the stash, is a universal hash for sharing data among
+application components. For an example, we return to our 'hello' action:
sub hello : Global {
my ( $self, $c ) = @_;
$c->res->output( $c->stash->{message} );
}
-Note that the stash should be used only for passing data in an individual request cycle; it gets cleared at a new request. If you need to maintain more persistent data, use a session.
+Note that the stash should be used only for passing data in an individual
+request cycle; it gets cleared at a new request. If you need to maintain more
+persistent data, use a session.
=head3 Actions
-A Catalyst controller is defined by its actions. An action is a sub with
-a special attribute. You've already seen some examples of actions in
-this document.
+A Catalyst controller is defined by its actions. An action is a sub with a
+special attribute. You've already seen some examples of actions in this
+document. The URL (for example http://localhost.3000/foo/bar) consists of two
+parts, the base (http://localhost:3000/ in this example) and the path (foo/bar).
+Please note that the trailing slash after the hostname[:port] always belongs to
+base and not to the action.
Catalyst supports several types of actions:
sub bar : Regex('^item(\d+)/order(\d+)$') { }
-Matches any URL that matches the pattern in the action key, e.g. http://localhost:3000/item23/order42. The '' around the regexp is optional, but perltidy likes it. :)
+Matches any URL that matches the pattern in the action key, e.g.
+http://localhost:3000/item23/order42. The '' around the regexp is optional, but
+perltidy likes it. :)
-Regex matches act globally, i.e. without reference to the namespace from which it is called, so that a C<bar> method in the C<MyApp::Controller::Catalog::Order::Process> namespace won't match any form of C<bar>, C<Catalog>, C<Order>, or C<Process> unless you explicitly put this in the regex.
+Regex matches act globally, i.e. without reference to the namespace from which
+it is called, so that a C<bar> method in the
+C<MyApp::Controller::Catalog::Order::Process> namespace won't match any form of
+C<bar>, C<Catalog>, C<Order>, or C<Process> unless you explicitly put this in
+the regex.
-If you use capturing parentheses to extract values within the matching URL (23, 42 in the above example), those values are available in the $c->req->snippets array. If you want to pass arguments at the end of your URL, you must use regex action keys. See L</URL Argument Handling> below.
+If you use capturing parentheses to extract values within the matching URL (23,
+42 in the above example), those values are available in the $c->req->snippets
+array. If you want to pass arguments at the end of your URL, you must use regex
+action keys. See L</URL Argument Handling> below.
=item * B<Top-level>
Matches http://localhost:3000/my/controller/foo.
-This action type indicates that the matching URL must be prefixed with a modified form of the component's class (package) name. This modified class name excludes the parts that have a pre-defined meaning in Catalyst ("MyApp::C" in the above example), replaces "::" with "/", and converts the name to lower case. See L</Components> for a full explanation of the pre-defined meaning of Catalyst component class names.
+This action type indicates that the matching URL must be prefixed with a
+modified form of the component's class (package) name. This modified class name
+excludes the parts that have a pre-defined meaning in Catalyst ("MyApp::C" in
+the above example), replaces "::" with "/", and converts the name to lower case.
+See L</Components> for a full explanation of the pre-defined meaning of Catalyst
+component class names.
=item * B<Private>
sub foo : Private { }
-Matches no URL, and cannot be executed by requesting a URL that corresponds to the action key. Private actions can be executed only inside a Catalyst application, by calling the C<forward> method:
+Matches no URL, and cannot be executed by requesting a URL that corresponds to
+the action key. Private actions can be executed only inside a Catalyst
+application, by calling the C<forward> method:
$c->forward('foo');
-See L</Flow Control> for a full explanation of C<forward>. Note that, as discussed there, when forwarding from another component, you must use the absolute path to the method, so that a private C<bar> method in your C<MyApp::Controller::Catalog::Order::Process> controller must, if called from elsewhere, be reach with C<$c-E<gt>forward('/catalog/order/process/bar')>.
+See L</Flow Control> for a full explanation of C<forward>. Note that, as
+discussed there, when forwarding from another component, you must use the
+absolute path to the method, so that a private C<bar> method in your
+C<MyApp::Controller::Catalog::Order::Process> controller must, if called from
+elsewhere, be reach with C<$c-E<gt>forward('/catalog/order/process/bar')>.
=back
=head4 Built-in Private Actions
-In response to specific application states, Catalyst will automatically call these built-in private actions:
+In response to specific application states, Catalyst will automatically call
+these built-in private actions:
=over 4
=head4 B<URL Argument Handling>
-If you want to pass variable arguments at the end of a URL, you must use regex actions keys with '^' and '$' anchors, and the arguments must be separated with forward slashes (/) in the URL. For example, suppose you want to handle /foo/$bar/$baz, where $bar and $baz may vary:
+If you want to pass variable arguments at the end of a URL, you must use regex
+actions keys with '^' and '$' anchors, and the arguments must be separated with
+forward slashes (/) in the URL. For example, suppose you want to handle
+/foo/$bar/$baz, where $bar and $baz may vary:
sub foo : Regex('^foo$') { my ($self, $context, $bar, $baz) = @_; }
=head3 Flow Control
-You control the application flow with the C<forward> method, which accepts the key of an action to execute.
+You control the application flow with the C<forward> method, which accepts the
+key of an action to execute.
sub hello : Global {
my ( $self, $c ) = @_;
$c->res->output( $c->stash->{message} );
}
-As you can see from these examples, you can just use the method name as long as you are referring to methods in the same controller. If you want to forward to a method in another controller, or the main application, you will have to refer to the method by absolute path.
+As you can see from these examples, you can just use the method name as long as
+you are referring to methods in the same controller. If you want to forward to a
+method in another controller, or the main application, you will have to refer to
+the method by absolute path.
$c->forward('/my/controller/action');
$c->forward('/default');
$c->res->output('Goodbye World!');
}
-Note that C<forward> returns to the calling action and continues processing after the action finishes.
-Catalyst will automatically try to call process() if you omit the method.
+Note that C<forward> returns to the calling action and continues processing
+after the action finishes. Catalyst will automatically try to call process() if
+you omit the method.
=head3 Components
-Catalyst has an uncommonly flexible component system. You can define as many L<Models>, L<Views>, and L<Controllers> as you like.
+Catalyst has an uncommonly flexible component system. You can define as many
+L<Models>, L<Views>, and L<Controllers> as you like.
-All components must inherit from L<Catalyst::Base>, which provides a simple class structure and some common class methods like C<config> and C<new> (constructor).
+All components must inherit from L<Catalyst::Base>, which provides a simple
+class structure and some common class methods like C<config> and C<new>
+(constructor).
package MyApp::C::Catalog;
1;
-You don't have to C<use> or otherwise register Models, Views, and Controllers. Catalyst automatically discovers and instantiates them when you call C<setup> in the main application. All you need to do is put them in directories named for each Component type. Notice that you can use some very terse aliases for each one.
+You don't have to C<use> or otherwise register Models, Views, and Controllers.
+Catalyst automatically discovers and instantiates them when you call C<setup> in
+the main application. All you need to do is put them in directories named for
+each Component type. Notice that you can use some very terse aliases for each
+one.
=over 4
=head4 Views
-To show how to define views, we'll use an already-existing base class for the L<Template Toolkit|Template>, L<Catalyst::View::TT>. All we need to do is inherit from this class:
+To show how to define views, we'll use an already-existing base class for the
+L<Template Toolkit|Template>, L<Catalyst::View::TT>. All we need to do is
+inherit from this class:
package MyApp::V::TT;
where the first C<TT> tells the script to create a Template Toolkit
view, and the second tells the script that its name should be C<TT>.)
-This gives us a process() method and we can now just do $c->forward('MyApp::V::TT') to render our templates. The base class makes process() implicit, so we don't have to say C<$c-E<gt>forward(qw/MyApp::V::TT process/)>.
+This gives us a process() method and we can now just do
+$c->forward('MyApp::V::TT') to render our templates. The base class makes
+process() implicit, so we don't have to say C<$c-E<gt>forward(qw/MyApp::V::TT
+process/)>.
sub hello : Global {
my ( $self, $c ) = @_;
$c->forward('MyApp::V::TT');
}
-You normally render templates at the end of a request, so it's a perfect use for the global C<end> action.
+You normally render templates at the end of a request, so it's a perfect use for
+the global C<end> action.
-Also, be sure to put the template under the directory specified in C<$c-E<gt>config-E<gt>{root}>, or you'll be forced to look at our eyecandy debug screen. ;)
+Also, be sure to put the template under the directory specified in
+C<$c-E<gt>config-E<gt>{root}>, or you'll be forced to look at our eyecandy debug
+screen. ;)
=head4 Models
-To show how to define models, again we'll use an already-existing base class, this time for L<Class::DBI>: L<Catalyst::Model::CDBI>.
+To show how to define models, again we'll use an already-existing base class,
+this time for L<Class::DBI>: L<Catalyst::Model::CDBI>.
But first, we need a database.
1;
-Catalyst automatically loads table layouts and relationships. Use the stash to pass data to your templates.
+Catalyst automatically loads table layouts and relationships. Use the stash to
+pass data to your templates.
package MyApp;
=head4 Controllers
-Multiple controllers are a good way to separate logical domains of your application.
+Multiple controllers are a good way to separate logical domains of your
+application.
package MyApp::C::Login;
=head3 Testing
-Catalyst has a built-in http server for testing! (Later, you can easily use a more powerful server, e.g. Apache/mod_perl, in a production environment.)
+Catalyst has a built-in http server for testing! (Later, you can easily use a
+more powerful server, e.g. Apache/mod_perl, in a production environment.)
Start your application on the command line...
David Naughton, C<naughton@umn.edu>
Marcus Ramberg, C<mramberg@cpan.org>
Jesse Sheidlower, C<jester@panix.com>
+Danijel Milicevic, C<me@danijel.de>
=head1 COPYRIGHT
projects / catagits/Catalyst-Runtime.git / commitdiff