=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, a.k.a. the Gang of Four (GoF). Or just search the web. Many, many web application frameworks follow 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.
+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 is very flexible about these Components. 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, plus 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<Re-Useable Components>
+=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 via regular expressions! Unlike some 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:
- MyApp->action( 'hello' => sub {
+ sub hello : Global {
my ( $self, $context ) = @_;
$context->response->output('Hello World!');
- });
+ }
Now http://localhost:3000/hello prints "Hello World!".
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 in 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>
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.
=head3 Setup
- $ catalyst My::App
- $ cd My-App
- $ perl bin/create controller My::Controller
+ $ catalyst.pl MyApp
+ $ cd MyApp
+ $ script/create.pl controller My::Controller
=head3 Run
- $ perl bin/server
+ $ script/server.pl
Now visit these locations with your favorite browser or user agent to see Catalyst in action:
# my_param_name => $my_param_value,
);
- MyApp->action( '!default' => sub {
+ sub default : Private {
my ( $self, $context ) = @_;
$context->response->output('Catalyst rockz!');
- });
+ }
1;
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>:
- MyApp->action( 'hello' => sub {
+ sub hello : Global {
my ( $self, $c ) = @_;
$c->res->output('Hello World!');
- });
+ }
The Context contains several important objects:
$c->request
$c->req # alias
-The request 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};
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:
- MyApp->action(
-
- 'hello' => sub {
- my ( $self, $c ) = @_;
- $c->stash->{message} = 'Hello World!';
- $c->forward('!show-message');
- },
-
- '!show-message' => sub {
- my ( $self, $c ) = @_;
- $c->res->output( $c->stash->{message} );
- },
+ sub hello : Global {
+ my ( $self, $c ) = @_;
+ $c->stash->{message} = 'Hello World!';
+ $c->forward('show-message');
+ }
- );
+ sub show-message : Private {
+ my ( $self, $c ) = @_;
+ $c->res->output( $c->stash->{message} );
+ }
=head3 Actions
-To define a Catalyst action, register it into your application with the C<action> method. C<action> accepts a key-value pair, where the key represents one or more URLs or application states and the value is a code reference, the action to execute in reponse to the URL(s) or application state(s).
+A Catalyst controller is defined by it's actions. An action is a sub
+with a special attribute. You've already seen some example of actions
+
+in this document.
-Catalyst supports several ways to define Actions:
+Catalyst supports several types of actions:
=over 4
=item * B<Literal>
- MyApp->action( 'foo/bar' => sub { } );
+ sub bar : Path('/foo/bar') { }
Matches only http://localhost:3000/foo/bar.
=item * B<Regex>
- MyApp->action( '/^foo(\d+)/bar(\d+)$/' => sub { } );
+ sub bar : Regex('^foo(\d+)/bar(\d+)$') { }
-Matches any URL that matches the pattern in the action key, e.g. http://localhost:3000/foo23/bar42. The pattern must be enclosed with forward slashes, i.e. '/$pattern/'.
+Matches any URL that matches the pattern in the action key, e.g. http://localhost:3000/foo23/bar42. The '' around the regexp is optional, but perltidy likes it. :)
If you use capturing parantheses 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<Toplevel>
+
+ package MyApp;
+ sub foo : Global { }
+
+Matches http://localhost:3000/foo. The function name is mapped
+directly to the application base.
+
=item * B<Namespace-Prefixed>
- package MyApp::Controller::My::Controller;
- MyApp->action( '?foo' => sub { } );
+ package MyApp::C::My::Controller;
+ sub foo : Local { }
-Matches http://localhost:3000/my_controller/foo. The action key must be prefixed with '?'.
+Matches http://localhost:3000/my/controller/foo.
-Prefixing the action key with '?' 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::Controller" 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>
- MyApp->action( '!foo' => sub { } );
+ 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:
- $c->forward('!foo');
+ $c->forward('foo');
See L</Flow Control> for a full explanation of C<forward>.
=back
+B<Note> After seeing these examples, you probably wonder what the point is of defining names for regex and path actions. Actually, every public
+action is also a private one, so you have one unified way of addressing components in your forwards.
+
=head4 Builtin Private Actions
In response to specific application states, Catalyst will automatically call these built in private actions:
=over 4
-=item * B<!default>
+=item * B<default : Private>
Called when no other action matches.
-=item * B<!begin>
+=item * B<begin : Private>
Called at the beginning of a request, before any matching actions are called.
-=item * B<!end>
+=item * B<end : Private>
=back
Called at the end of a request, after all matching actions are called.
-=head4 B<Namespace-Prefixed Private Actions>
+=head4 B<Builtin actions in controllers/autochaining>
- MyApp->action( '!?foo' => sub { } );
- MyApp->action( '!?default' => sub { } );
+ Package MyApp::C::Foo;
+ sub begin : Private { }
+ sub default : Private { }
+
+You can define the Builtin Private Actions within your controllers as
+well. The actions will override the ones in lower level controllers/
+global.
+
+In addition to the normal builtins, you have a special action for
+making inheritance chains, 'auto'. These will be run after begin,
+but before your action is processed.
+
+=over 4
+
+=item for a request for /foo/foo
+
+ MyApp::begin
+ MyApp::auto
+ MyApp::default
+ MyApp::end
+
+=item for a request for /foo/bar/foo
+
+ MyApp::C::Foo::Bar::begin
+ MyApp::auto
+ MyApp::C::Foo::auto
+ MyApp::C::Foo::Bar::default
+ MyApp::C::Foo::Bar::end
+
+=back
+
+Also, if you need to break out of the chain in one of your auto
+actions, you can return 0, if so, your action will not be processed,
+but the end will, so for the request above, if the first auto returns
+false, it would look like this:
+
+=over 4
+
+=item for a request for /foo/bar/foo where auto returns false
+
+ MyApp::C::Foo::Bar::begin
+ MyApp::auto
+ MyApp::C::Foo::Bar::end
+
+=back
+
+I<Note:> You can also die in the autochain action, in that case,
+the request will go straight to the finalize stage, without processing
+further actions.
-The leading '!?' indicates that these are namespace-prefixed private actions. These override any application-wide private actions with the same names, and can be called only from within the namespace in which they are defined. Any private action can be namespace-prefixed, including the builtins. One use for this might be to give a Controller its own !?default, !?begin and !?end.
=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:
- MyApp->action( '/^foo$/' => sub { my ($self, $context, $bar, $baz) = @_; } );
+ sub foo : Regex('^foo$') { my ($self, $context, $bar, $baz) = @_; }
But what if you also defined actions for /foo/boo and /foo/boo/hoo ?
- MyApp->action( '/foo/boo' => sub { .. } );
- MyApp->action( '/foo/boo/hoo' => sub { .. } );
+ sub boo : Path('/foo/boo') { .. }
+ sub hoo : Path('/foo/boo/hoo') { .. }
Catalyst matches actions in most specific to least specific order:
/foo/boo
/foo # might be /foo/bar/baz
-So Catalyst would never mistakenly dispatch the first two URLs to the '/^foo$/' action.
+So Catalyst would never mistakenly dispatch the first two URLs to the '^foo$' action.
=head3 Flow Control
-Control the application flow with the C<forward> method, which accepts the key of an action to execute.
-
- MyApp->action(
+You control the application flow with the C<forward> method, which accepts the key of an action to execute.
- 'hello' => sub {
- my ( $self, $c ) = @_;
- $c->stash->{message} = 'Hello World!';
- $c->forward('!check-message');
- },
+ sub hello : Global {
+ my ( $self, $c ) = @_;
+ $c->stash->{message} = 'Hello World!';
+ $c->forward('check-message');
+ }
- '!check-message' => sub {
- my ( $self, $c ) = @_;
- return unless $c->stash->{message};
- $c->forward('!show-message');
- },
+ sub check-message : Private {
+ my ( $self, $c ) = @_;
+ return unless $c->stash->{message};
+ $c->forward('show-message');
+ }
- '!show-message' => sub {
- my ( $self, $c ) = @_;
- $c->res->output( $c->stash->{message} );
- },
+ sub show-message : Private {
+ 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 asbolute path.
- );
+ $c->forward('/my/controller/action');
+ $c->forward('/default');
You can also forward to classes and methods.
- MyApp->action(
-
- 'hello' => sub {
- my ( $self, $c ) = @_;
- $c->forward(qw/MyApp::M::Hello say_hello/);
- },
-
- 'bye' => sub {
- my ( $self, $c ) = @_;
- $c->forward('MyApp::M::Hello');
- },
+ sub hello : Global {
+ my ( $self, $c ) = @_;
+ $c->forward(qw/MyApp::M::Hello say_hello/);
+ }
- );
+ sub bye : Global {
+ my ( $self, $c ) = @_;
+ $c->forward('MyApp::M::Hello');
+ }
package MyApp::M::Hello;
$c->res->output('Goodbye World!');
}
-Note that C<forward> returns after processing.
+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
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::Controller::MyController;
+ package MyApp::C::MyController;
use strict;
use base 'Catalyst::Base';
1;
-You don't have to C<use> or otherwise register Models, Views and Controllers. Catalyst automatically discovers and instantiates them, at startup. 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 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
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/)>.
- MyApp->action(
-
- 'hello' => sub {
- my ( $self, $c ) = @_;
- $c->stash->{template} = 'hello.tt';
- },
-
- '!end' => sub {
- my ( $self, $c ) = @_;
- $c->forward('MyApp::View::TT');
- },
+ sub hello : Global {
+ my ( $self, $c ) = @_;
+ $c->stash->{template} = 'hello.tt';
+ }
- );
+ sub end : Private {
+ 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 !end action.
+You normally render templates at the end of a request, so it's a perfect use for the global end action.
Also, be sure to put the template under the directory specified in C<$c-E<gt>config->{root}>, or you'll be forced to look at our eyecandy debug screen. ;)
name => 'My Application',
root => '/home/joeuser/myapp/root'
);
+
+ __PACKAGE__->setup;
- __PACKAGE__->action(
-
- '!end' => sub {
- my ( $self, $c ) = @_;
- $c->stash->{template} ||= 'index.tt';
- $c->forward('MyApp::V::TT');
- },
-
- 'view' => sub {
- my ( $self, $c, $id ) = @_;
- $c->stash->{item} = MyApp::M::CDBI::Foo->retrieve($id);
- }
+ sub end : Private {
+ my ( $self, $c ) = @_;
+ $c->stash->{template} ||= 'index.tt';
+ $c->forward('MyApp::V::TT');
+ }
- );
+ sub view : Global {
+ my ( $self, $c, $id ) = @_;
+ $c->stash->{item} = MyApp::M::CDBI::Foo->retrieve($id);
+ }
1;
package MyApp::C::Login;
- MyApp->action(
- '?sign-in' => sub { },
- '?new-password' => sub { },
- '?sign-out' => sub { },
- );
+ sign-in : Relative { }
+ new-password :Relative { }
+ sign-out : Relative { }
package MyApp::C::Catalog;
- MyApp->action(
- '?view' => sub { },
- '?list' => sub { },
- );
+ sub view : Local { }
+ sub list : Local { }
package MyApp::C::Cart;
- MyApp->action(
- '?add' => sub { },
- '?update' => sub { },
- '?order' => sub { },
- );
+ sub add : Local { }
+ sub update : Local { }
+ sub order : Local { }
=head3 Testing
Start your application on the command line...
- perl bin/server
-
-or
-
- perl -I/home/joeuser/myapp/lib -MCatalyst::Test=MyApp -e1 3000
+ script/server.pl
...then visit http://localhost:3000/ in a browser to view the output.
You can also do it all from the command line:
- perl bin/test http://localhost/
+ script/test.pl http://localhost/
-or
+Have fun!
- perl -I/home/joeuser/myapp/lib -MCatalyst::Test=MyApp -e1 http://localhost/
+=head1 SUPPORT
-Have fun!
+IRC:
+
+ Join #catalyst on irc.perl.org.
+
+Mailing-Lists:
+
+ http://lists.rawmode.org/mailman/listinfo/catalyst
+ http://lists.rawmode.org/mailman/listinfo/catalyst-dev
=head1 AUTHOR
-Sebastian Riedel, C<sri@oook.de> and David Naughton, C<naughton@umn.edu>
+Sebastian Riedel, C<sri@oook.de>
+David Naughton, C<naughton@umn.edu>
+Marcus Ramberg, C<mramberg@cpan.org>
=head1 COPYRIGHT
projects / catagits/Catalyst-Runtime.git / blobdiff