NAME

       Catalyst::Manual::Internals - Catalyst Internals

DESCRIPTION

       This document provides a brief overview of the internals of Catalyst.  As Catalyst is still developing
       rapidly, details may become out of date: please treat this as a guide, and look at the source for the
       last word.

       The coverage is split into initialization and request lifecycle.

   Initialization
       Catalyst initializes itself in two stages:

       1.  When the Catalyst module is imported in the main application module, it stores any options.

       2.  When "__PACKAGE__->setup" is called, it evaluates any options stored ("-Debug"), and makes the
           application inherit from Catalyst (if that hasn't already been done with an explicit "use base
           'Catalyst';" or "extends 'Catalyst';".  Any specified plugins are then loaded, the application module
           is made to inherit from the plugin classes. It also sets up a default log object and ensures that the
           application module inherits from "Catalyst" and from the selected specialized Engine module.

       3.  Catalyst automatically loads all components it finds in the $class::Controller, $class::C,
           $class::Model, $class::M, $class::View and $class::V namespaces (using Module::Pluggable). As each is
           loaded, if it has a COMPONENT method then this method will be called, and passed that component's
           configuration. It then returns an instance of the component, which becomes the $self when methods in
           that component are called later.

       4.  Each controller has it's "register_actions" method called. At this point, the subroutine attributes
           are retrieved from the metaclass, parsed, and used to build instances of Catalyst::Action, which are
           then registered with the dispatcher.

   Request Lifecycle
       For each request Catalyst builds a context object, which includes information about the request, and then
       searches the action table for matching actions.

       The handling of a request can be divided into three stages: preparation of the context, processing of the
       request, and finalization of the response.  These are the steps of a Catalyst request in detail; every
       step can be overloaded to extend Catalyst.

           handle_request
             prepare
               prepare_request
               prepare_connection
               prepare_query_parameters
               prepare_headers
               prepare_cookies
               prepare_path
               prepare_body (unless parse_on_demand)
                 prepare_body_parameters
                 prepare_parameters
                 prepare_uploads
               prepare_action
             dispatch
             finalize
               finalize_uploads
               finalize_error (if one happened)
               finalize_headers
                 finalize_cookies
               finalize_body

       These steps are normally overloaded from engine classes, and may also be extended by plugins. For more on
       extending Catalyst, see Catalyst::Manual::ExtendingCatalyst.

       The engine class populates the Catalyst request object with information from the underlying layer (PSGI)
       during the prepare phase, then push the generated response information down to the underlying layer
       during the finalize phase.

AUTHORS

       Catalyst Contributors, see Catalyst.pm

COPYRIGHT

       This library is free software. You can redistribute it and/or modify it under the same terms as Perl
       itself.