NAME

    # Install Catalyst::Devel for helpers and other development tools
    # use the helper to create a new application
    catalyst.pl MyApp
    # add models, views, controllers
    script/myapp_create.pl model MyDatabase DBIC::Schema create=dynamic dbi:SQLite:/path/to/db
    script/myapp_create.pl view MyTemplate TT
    script/myapp_create.pl controller Search
    # built in testserver -- use -r to restart automatically on changes
    # --help to see all available options
    script/myapp_server.pl
    # command line testing interface
    script/myapp_test.pl /yada
    ### in lib/MyApp.pm
    use Catalyst qw/-Debug/; # include plugins here as well
    
    ### In lib/MyApp/Controller/Root.pm (autocreated)
    sub foo : Global { # called for /foo, /foo/1, /foo/1/2, etc.
        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} = 
          $c->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 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 all actions, from the top-most controller downwards
    sub auto : Private { 
        my ( $self, $c ) = @_;
        if ( !$c->user_exists ) { # Catalyst::Plugin::Authentication
            $c->res->redirect( '/login' ); # require login
            return 0; # abort request and go immediately to end()
        }
        return 1; # success; carry on to next action
    }
    
    # called after all actions are finished
    sub end : Private { 
        my ( $self, $c ) = @_;
        if ( scalar @{ $c->error } ) { ... } # handle errors
        return if $c->res->body; # already have a response
        $c->forward( 'MyApp::View::TT' ); # render template
    }
    ### in MyApp/Controller/Foo.pm
    # called for /foo/bar
    sub bar : Local { ... }
    
    # 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
    sub baz : Local { ... }
    
    # first Root auto is called, then Foo auto, then this
    sub auto : Private { ... }
    
    # powerful regular expression paths are also possible
    sub details : Regex('^product/(\w+)/details$') {
        my ( $self, $c ) = @_;
        # extract the (\w+) from the URI
        my $product = $c->req->captures->[0];
    }
    use Catalyst qw/My::Module/;
    use Catalyst qw/
        My::Module
        +Fully::Qualified::Plugin::Name
    /;
    use Catalyst qw/-Debug My::Module/;
    use Catalyst qw/-Engine=CGI/;
    use Catalyst qw[-Home=/usr/mst];
   use Catalyst qw/-Stats=1/
    # in Controller::Foo::Bar
    $c->namespace; # returns 'foo/bar';
    my $foodata = $c->forward('/foo');
    $c->forward('index');
    $c->forward(qw/MyApp::Model::DBIC::Foo do_stuff/);
    $c->forward('MyApp::View::TT');
    $c->forward('foo');
    die $c->error if $c->error;
    $c->forward('foo') || return;
    $c->stash->{foo} = $bar;
    $c->stash( { moose => 'majestic', qux => 0 } );
    $c->stash( bar => 1, gorch => 2 ); # equivalent to passing a hashref
    
    # stash is automatically passed to the view for use in a template
    $c->forward( 'MyApp::View::TT' );
    my @error = @{ $c->error };
    $c->error('Something bad happened');
    $c->error(0);
    $c->controller('Foo')->do_stuff;
    $c->model('Foo')->do_stuff;
    $c->view('Foo')->do_stuff;
    __PACKAGE__->config( { db => 'dsn:SQLite:foo.db' } );
    ---
    db: dsn:SQLite:foo.db
 __PACKAGE__->log( MyLogger->new );
 __PACKAGE__->setup;
    $c->log->info( 'Now logging with my own logger!' );
    $c->path_to( 'db', 'sqlite.db' );
    MyApp->plugin( 'prototype', 'HTML::Prototype' );
    $c->prototype->define_javascript_functions;
    MyApp->setup;
    MyApp->setup( qw/-Debug/ );
 if ($c->registered_plugins('Some::Plugin')) {
     ...
 }
    MyApp->config->{show_internal_actions} = 1;
    MyApp->config->{case_sensitive} = 1;
    MyApp->config->{parse_on_demand} = 1;
    
=head1 PROXY SUPPORT
    $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.
    MyApp->config->{using_frontend_proxy} = 1;
    
If you do not wish to use the proxy support at all, you may set:
    MyApp->config->{ignore_frontend_proxy} = 1;
    Join #catalyst on irc.perl.org.
    http://lists.rawmode.org/mailman/listinfo/catalyst
    http://lists.rawmode.org/mailman/listinfo/catalyst-dev
    http://catalyst.perl.org
    http://dev.catalyst.perl.org

the Task::Catalyst manpage - All you need to start with Catalyst

the Catalyst::Manual manpage - The Catalyst Manual

the Catalyst::Component manpage, the Catalyst::Base manpage - Base classes for components

the Catalyst::Engine manpage - Core engine

the Catalyst::Log manpage - Log class.

the Catalyst::Request manpage - Request object

the Catalyst::Response manpage - Response object

the Catalyst::Test manpage - The test suite.