[catagits/Catalyst-Runtime.git] / lib / Catalyst.pm

package Catalyst;

use strict;
use base 'Catalyst::Base';
use UNIVERSAL::require;
use Catalyst::Log;
use Catalyst::Utils;
use Text::ASCIITable;
use Path::Class;
our $CATALYST_SCRIPT_GEN = 4;

__PACKAGE__->mk_classdata($_) for qw/dispatcher engine log/;

our $VERSION = '5.24';
our @ISA;

=head1 NAME

Catalyst - The Elegant MVC Web Application Framework

=head1 SYNOPSIS

    # use the helper to start a new application
    catalyst.pl MyApp
    cd MyApp

    # add models, views, controllers
    script/myapp_create.pl model Something
    script/myapp_create.pl view Stuff
    script/myapp_create.pl controller Yada

    # built in testserver
    script/myapp_server.pl

    # command line interface
    script/myapp_test.pl /yada


    use Catalyst;

    use Catalyst qw/My::Module My::OtherModule/;

    use Catalyst '-Debug';

    use Catalyst qw/-Debug -Engine=CGI/;

    sub default : Private { $_[1]->res->output('Hello') } );

    sub index : Path('/index.html') {
        my ( $self, $c ) = @_;
        $c->res->output('Hello');
        $c->forward('foo');
    }

    sub product : Regex('^product[_]*(\d*).html$') {
        my ( $self, $c ) = @_;
        $c->stash->{template} = 'product.tt';
        $c->stash->{product} = $c->req->snippets->[0];
    }

See also L<Catalyst::Manual::Intro>

=head1 DESCRIPTION

The key concept of Catalyst is DRY (Don't Repeat Yourself).

See L<Catalyst::Manual> for more documentation.

Catalyst plugins can be loaded by naming them as arguments to the "use Catalyst" statement.
Omit the C<Catalyst::Plugin::> prefix from the plugin name,
so C<Catalyst::Plugin::My::Module> becomes C<My::Module>.

    use Catalyst 'My::Module';

Special flags like -Debug and -Engine can also be specifed as arguments when
Catalyst is loaded:

    use Catalyst qw/-Debug My::Module/;

The position of plugins and flags in the chain is important, because they are
loaded in exactly the order that they appear.

The following flags are supported:

=over 4

=item -Debug

enables debug output, i.e.:

    use Catalyst '-Debug';

this is equivalent to:

    use Catalyst;
    sub debug { 1 }

=item -Engine

Force Catalyst to use a specific engine.
Omit the C<Catalyst::Engine::> prefix of the engine name, i.e.:

    use Catalyst '-Engine=CGI';

=back

=head1 METHODS

=over 4

=item debug

Overload to enable debug messages.

=cut

sub debug { 0 }

=item config

Returns a hashref containing your applications settings.

=cut

sub import {
    my ( $self, @options ) = @_;
    my $caller = caller(0);

    # Prepare inheritance
    unless ( $caller->isa($self) ) {
        no strict 'refs';
        push @{"$caller\::ISA"}, $self;
    }

    if ( $caller->engine ) {
        return;    # Catalyst is already initialized
    }

    unless ( $caller->log ) {
        $caller->log( Catalyst::Log->new );
    }

    # Debug?
    if ( $ENV{CATALYST_DEBUG} || $ENV{ uc($caller) . '_DEBUG' } ) {
        no strict 'refs';
        *{"$caller\::debug"} = sub { 1 };
        $caller->log->debug('Debug messages enabled');
    }

    my $engine     = 'Catalyst::Engine::CGI';
    my $dispatcher = 'Catalyst::Dispatcher';

    if ( $ENV{MOD_PERL} ) {

        my ( $software, $version ) = $ENV{MOD_PERL} =~ /^(\S+)\/(\d+(?:[\.\_]\d+)+)/;

        $version =~ s/_//g;
        $version =~ s/(\.[^.]+)\./$1/g;

        if ( $software eq 'mod_perl') {

            if ( $version >= 1.99922 ) {

                $engine = 'Catalyst::Engine::Apache::MP20';

                if ( Apache2::Request->require ) {
                    $engine = 'Catalyst::Engine::Apache::MP20::Apreq';
                }
            }

            elsif ( $version >= 1.9901 ) {

                $engine = 'Catalyst::Engine::Apache::MP19';

                if ( Apache::Request->require ) {
                    $engine = 'Catalyst::Engine::Apache::MP19::Apreq';
                }
            }

            elsif ( $version >= 1.24 ) {

                $engine = 'Catalyst::Engine::Apache::MP13';

                if ( Apache::Request->require ) {
                    $engine = 'Catalyst::Engine::Apache::MP13::Apreq';
                }
            }

            else {
                die( qq/Unsupported mod_perl version: $ENV{MOD_PERL}/ );
            }
        }

        elsif ( $software eq 'Zeus-Perl' ) {
            $engine = 'Catalyst::Engine::Zeus';
        }

        else {
            die( qq/Unsupported mod_perl: $ENV{MOD_PERL}/ );
        }
    }

    $caller->log->info( "You are running an old helper script! "
          . "Please update your scripts by regenerating the "
          . "application and copying over the new scripts." )
      if ( $ENV{CATALYST_SCRIPT_GEN}
        && ( $ENV{CATALYST_SCRIPT_GEN} < $CATALYST_SCRIPT_GEN ) );

    # Process options
    my @plugins;
    foreach (@options) {

        if (/^\-Debug$/) {
            next if $caller->debug;
            no strict 'refs';
            *{"$caller\::debug"} = sub { 1 };
            $caller->log->debug('Debug messages enabled');
        }

        elsif (/^-Dispatcher=(.*)$/) {
            $dispatcher = "Catalyst::Dispatcher::$1";
        }

        elsif (/^-Engine=(.*)$/) { $engine = "Catalyst::Engine::$1" }
        elsif (/^-.*$/) { $caller->log->error(qq/Unknown flag "$_"/) }

        else {
            my $plugin = "Catalyst::Plugin::$_";

            $plugin->require;

            if ($@) { die qq/Couldn't load plugin "$plugin", "$@"/ }
            else {
                push @plugins, $plugin;
                no strict 'refs';
                push @{"$caller\::ISA"}, $plugin;
            }
        }

    }

    # Plugin table
    my $t = Text::ASCIITable->new( { hide_HeadRow => 1, hide_HeadLine => 1 } );
    $t->setCols('Class');
    $t->setColWidth( 'Class', 75, 1 );
    $t->addRow($_) for @plugins;
    $caller->log->debug( 'Loaded plugins', $t->draw )
      if ( @plugins && $caller->debug );

    # Dispatcher
    $dispatcher = "Catalyst::Dispatcher::$ENV{CATALYST_DISPATCHER}"
      if $ENV{CATALYST_DISPATCHER};
    my $appdis = $ENV{ uc($caller) . '_DISPATCHER' };
    $dispatcher = "Catalyst::Dispatcher::$appdis" if $appdis;

    $dispatcher->require;
    die qq/Couldn't load dispatcher "$dispatcher", "$@"/ if $@;
    {
        no strict 'refs';
        push @{"$caller\::ISA"}, $dispatcher;
    }
    $caller->dispatcher($dispatcher);
    $caller->log->debug(qq/Loaded dispatcher "$dispatcher"/) if $caller->debug;

    # Engine
    $engine = "Catalyst::Engine::$ENV{CATALYST_ENGINE}"
      if $ENV{CATALYST_ENGINE};
    my $appeng = $ENV{ uc($caller) . '_ENGINE' };
    $engine = "Catalyst::Engine::$appeng" if $appeng;

    $engine->require;
    die qq/Couldn't load engine "$engine", "$@"/ if $@;

    {
        no strict 'refs';
        push @{"$caller\::ISA"}, $engine;
    }

    $caller->engine($engine);
    $caller->log->debug(qq/Loaded engine "$engine"/) if $caller->debug;

    # Find home
    my $home = Catalyst::Utils::home($caller);

    if ( my $h = $ENV{CATALYST_HOME} ) {

        $home = $h if -d $h;

        unless ( -e _ ) {
            $caller->log->warn(qq/CATALYST_HOME does not exist "$h"/);
        }

        unless ( -e _ && -d _ ) {
            $caller->log->warn(qq/CATALYST_HOME is not a directory "$h"/);
        }
    }

    if ( my $h = $ENV{ uc($caller) . '_HOME' } ) {

        $home = $h if -d $h;

        unless ( -e _ ) {
            my $e = uc($caller) . '_HOME';
            $caller->log->warn(qq/$e does not exist "$h"/)
        }

        unless ( -e _ && -d _ ) {
            my $e = uc($caller) . '_HOME';
            $caller->log->warn(qq/$e is not a directory "$h"/);
        }
    }
    
    if ( $caller->debug ) {
        $home
          ? ( -d $home )
          ? $caller->log->debug(qq/Found home "$home"/)
          : $caller->log->debug(qq/Home "$home" doesn't exist/)
          : $caller->log->debug(q/Couldn't find home/);
    }
    $caller->config->{home} = $home || '';
    $caller->config->{root} = defined $home ? dir($home)->subdir('root') : '';
}

=item $c->engine

Contains the engine class.

=item $c->log

Contains the logging object.  Unless it is already set Catalyst sets this up with a
C<Catalyst::Log> object.  To use your own log class:

    $c->log( MyLogger->new );
    $c->log->info("now logging with my own logger!");

Your log class should implement the methods described in the C<Catalyst::Log>
man page.

=item $c->plugin( $name, $class, @args )

Instant plugins for Catalyst.
Classdata accessor/mutator will be created, class loaded and instantiated.

    MyApp->plugin( 'prototype', 'HTML::Prototype' );

    $c->prototype->define_javascript_functions;

=cut

sub plugin {
    my ( $class, $name, $plugin, @args ) = @_;
    $plugin->require;
    my $error = $UNIVERSAL::require::ERROR;
    die qq/Couldn't load instant plugin "$plugin", "$error"/ if $error;
    eval { $plugin->import };
    $class->mk_classdata($name);
    my $obj;
    eval { $obj = $plugin->new(@args) };
    die qq/Couldn't instantiate instant plugin "$plugin", "$@"/ if $@;
    $class->$name($obj);
    $class->log->debug(qq/Initialized instant plugin "$plugin" as "$name"/)
      if $class->debug;
}

=back

=head1 LIMITATIONS

mod_perl2 support is considered experimental and may contain bugs.

=head1 SUPPORT

IRC:

    Join #catalyst on irc.perl.org.

Mailing-Lists:

    http://lists.rawmode.org/mailman/listinfo/catalyst
    http://lists.rawmode.org/mailman/listinfo/catalyst-dev

Web:

    http://catalyst.perl.org

=head1 SEE ALSO

=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

Sebastian Riedel, C<sri@oook.de>

=head1 THANK YOU

Andy Grundman, Andrew Ford, Andrew Ruthven, Autrijus Tang, Christian Hansen,
Christopher Hicks, Dan Sully, Danijel Milicevic, David Naughton,
Gary Ashton Jones, Geoff Richards, Jesse Sheidlower, Jody Belka,
Johan Lindstrom, Juan Camacho, Leon Brocard, Marcus Ramberg,
Tatsuhiko Miyagawa and all the others who've helped.

=head1 LICENSE

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

=cut

1;
Commit	Line	Data
fc7ec1d9	1	package Catalyst;
	2
	3	use strict;
ac733264	4	use base 'Catalyst::Base';
fc7ec1d9	5	use UNIVERSAL::require;
fc7ec1d9	6	use Catalyst::Log;
812a28c9	7	use Catalyst::Utils;
0f7ecc53	8	use Text::ASCIITable;
4f6748f1	9	use Path::Class;
367d15f8	10	our $CATALYST_SCRIPT_GEN = 4;
fc7ec1d9	11
424b2705	12	__PACKAGE__->mk_classdata($_) for qw/dispatcher engine log/;
fc7ec1d9	13
abddf0b5	14	our $VERSION = '5.24';
fc7ec1d9	15	our @ISA;
	16
	17	=head1 NAME
	18
	19	Catalyst - The Elegant MVC Web Application Framework
	20
	21	=head1 SYNOPSIS
	22
	23	# use the helper to start a new application
91864987	24	catalyst.pl MyApp
fc7ec1d9	25	cd MyApp
	26
	27	# add models, views, controllers
ae4e40a7	28	script/myapp_create.pl model Something
	29	script/myapp_create.pl view Stuff
	30	script/myapp_create.pl controller Yada
fc7ec1d9	31
fc7ec1d9	32	# built in testserver
ae4e40a7	33	script/myapp_server.pl
fc7ec1d9	34
fc7ec1d9	35	# command line interface
ae4e40a7	36	script/myapp_test.pl /yada
fc7ec1d9	37
fc7ec1d9	38
fc7ec1d9	39	use Catalyst;
	40
	41	use Catalyst qw/My::Module My::OtherModule/;
	42
	43	use Catalyst '-Debug';
	44
	45	use Catalyst qw/-Debug -Engine=CGI/;
	46
5a8ed4fe	47	sub default : Private { $_[1]->res->output('Hello') } );
5a8ed4fe	48
e3dc9d78	49	sub index : Path('/index.html') {
5a8ed4fe	50	my ( $self, $c ) = @_;
5a8ed4fe	51	$c->res->output('Hello');
064834ea	52	$c->forward('foo');
5a8ed4fe	53	}
5a8ed4fe	54
064834ea	55	sub product : Regex('^product[_](\d).html$') {
5a8ed4fe	56	my ( $self, $c ) = @_;
	57	$c->stash->{template} = 'product.tt';
	58	$c->stash->{product} = $c->req->snippets->[0];
	59	}
fc7ec1d9	60
3803e98f	61	See also L<Catalyst::Manual::Intro>
3803e98f	62
fc7ec1d9	63	=head1 DESCRIPTION
fc7ec1d9	64
fc7ec1d9	65	The key concept of Catalyst is DRY (Don't Repeat Yourself).
	66
	67	See L<Catalyst::Manual> for more documentation.
	68
23f9d934	69	Catalyst plugins can be loaded by naming them as arguments to the "use Catalyst" statement.
1985c30b	70	Omit the C<Catalyst::Plugin::> prefix from the plugin name,
23f9d934	71	so C<Catalyst::Plugin::My::Module> becomes C<My::Module>.
fc7ec1d9	72
	73	use Catalyst 'My::Module';
	74
23f9d934	75	Special flags like -Debug and -Engine can also be specifed as arguments when
23f9d934	76	Catalyst is loaded:
fc7ec1d9	77
	78	use Catalyst qw/-Debug My::Module/;
	79
23f9d934	80	The position of plugins and flags in the chain is important, because they are
23f9d934	81	loaded in exactly the order that they appear.
fc7ec1d9	82
23f9d934	83	The following flags are supported:
	84
	85	=over 4
	86
	87	=item -Debug
	88
	89	enables debug output, i.e.:
fc7ec1d9	90
	91	use Catalyst '-Debug';
	92
23f9d934	93	this is equivalent to:
fc7ec1d9	94
	95	use Catalyst;
	96	sub debug { 1 }
	97
23f9d934	98	=item -Engine
fc7ec1d9	99
fc7ec1d9	100	Force Catalyst to use a specific engine.
23f9d934	101	Omit the C<Catalyst::Engine::> prefix of the engine name, i.e.:
fc7ec1d9	102
	103	use Catalyst '-Engine=CGI';
	104
23f9d934	105	=back
fc7ec1d9	106
23f9d934	107	=head1 METHODS
	108
	109	=over 4
	110
	111	=item debug
fc7ec1d9	112
	113	Overload to enable debug messages.
	114
	115	=cut
	116
	117	sub debug { 0 }
	118
23f9d934	119	=item config
fc7ec1d9	120
	121	Returns a hashref containing your applications settings.
	122
	123	=cut
	124
fc7ec1d9	125	sub import {
	126	my ( $self, @options ) = @_;
	127	my $caller = caller(0);
	128
99fe1710	129	# Prepare inheritance
22402712	130	unless ( $caller->isa($self) ) {
fc7ec1d9	131	no strict 'refs';
22402712	132	push @{"$caller\::ISA"}, $self;
1c99e125	133	}
1c99e125	134
d96e14c2	135	if ( $caller->engine ) {
42a57832	136	return; # Catalyst is already initialized
d96e14c2	137	}
d96e14c2	138
32620e3e	139	unless ( $caller->log ) {
32620e3e	140	$caller->log( Catalyst::Log->new );
fc7ec1d9	141	}
fc7ec1d9	142
99fe1710	143	# Debug?
1985c30b	144	if ( $ENV{CATALYST_DEBUG} \|\| $ENV{ uc($caller) . '_DEBUG' } ) {
	145	no strict 'refs';
	146	*{"$caller\::debug"} = sub { 1 };
	147	$caller->log->debug('Debug messages enabled');
	148	}
	149
424b2705	150	my $engine = 'Catalyst::Engine::CGI';
424b2705	151	my $dispatcher = 'Catalyst::Dispatcher';
6dc87a0f	152
	153	if ( $ENV{MOD_PERL} ) {
	154
316bf0f0	155	my ( $software, $version ) = $ENV{MOD_PERL} =~ /^(\S+)\/(\d+(?:[\.\_]\d+)+)/;
	156
	157	$version =~ s/_//g;
	158	$version =~ s/(\.[^.]+)\./$1/g;
	159
	160	if ( $software eq 'mod_perl') {
	161
	162	if ( $version >= 1.99922 ) {
	163
	164	$engine = 'Catalyst::Engine::Apache::MP20';
	165
	166	if ( Apache2::Request->require ) {
566ee5d7	167	$engine = 'Catalyst::Engine::Apache::MP20::Apreq';
316bf0f0	168	}
	169	}
	170
	171	elsif ( $version >= 1.9901 ) {
	172
	173	$engine = 'Catalyst::Engine::Apache::MP19';
	174
	175	if ( Apache::Request->require ) {
566ee5d7	176	$engine = 'Catalyst::Engine::Apache::MP19::Apreq';
316bf0f0	177	}
	178	}
	179
	180	elsif ( $version >= 1.24 ) {
	181
	182	$engine = 'Catalyst::Engine::Apache::MP13';
	183
	184	if ( Apache::Request->require ) {
566ee5d7	185	$engine = 'Catalyst::Engine::Apache::MP13::Apreq';
316bf0f0	186	}
316bf0f0	187	}
d837e1a7	188
316bf0f0	189	else {
	190	die( qq/Unsupported mod_perl version: $ENV{MOD_PERL}/ );
	191	}
6dc87a0f	192	}
d837e1a7	193
316bf0f0	194	elsif ( $software eq 'Zeus-Perl' ) {
316bf0f0	195	$engine = 'Catalyst::Engine::Zeus';
6dc87a0f	196	}
d837e1a7	197
d837e1a7	198	else {
316bf0f0	199	die( qq/Unsupported mod_perl: $ENV{MOD_PERL}/ );
d837e1a7	200	}
6dc87a0f	201	}
1985c30b	202
300aea89	203	$caller->log->info( "You are running an old helper script! "
	204	. "Please update your scripts by regenerating the "
	205	. "application and copying over the new scripts." )
	206	if ( $ENV{CATALYST_SCRIPT_GEN}
87232381	207	&& ( $ENV{CATALYST_SCRIPT_GEN} < $CATALYST_SCRIPT_GEN ) );
300aea89	208
99fe1710	209	# Process options
937fcdd8	210	my @plugins;
fc7ec1d9	211	foreach (@options) {
99fe1710	212
fc7ec1d9	213	if (/^\-Debug$/) {
1985c30b	214	next if $caller->debug;
fc7ec1d9	215	no strict 'refs';
1c99e125	216	*{"$caller\::debug"} = sub { 1 };
fc7ec1d9	217	$caller->log->debug('Debug messages enabled');
fc7ec1d9	218	}
99fe1710	219
424b2705	220	elsif (/^-Dispatcher=(.*)$/) {
	221	$dispatcher = "Catalyst::Dispatcher::$1";
	222	}
99fe1710	223
fc7ec1d9	224	elsif (/^-Engine=(.*)$/) { $engine = "Catalyst::Engine::$1" }
fc7ec1d9	225	elsif (/^-.*$/) { $caller->log->error(qq/Unknown flag "$_"/) }
99fe1710	226
fc7ec1d9	227	else {
	228	my $plugin = "Catalyst::Plugin::$_";
	229
c4695f3a	230	$plugin->require;
91dc9907	231
f88238ea	232	if ($@) { die qq/Couldn't load plugin "$plugin", "$@"/ }
fc7ec1d9	233	else {
f5f84847	234	push @plugins, $plugin;
502619e5	235	no strict 'refs';
502619e5	236	push @{"$caller\::ISA"}, $plugin;
fc7ec1d9	237	}
fc7ec1d9	238	}
99fe1710	239
fc7ec1d9	240	}
99fe1710	241
99fe1710	242	# Plugin table
d2d570d4	243	my $t = Text::ASCIITable->new( { hide_HeadRow => 1, hide_HeadLine => 1 } );
0f7ecc53	244	$t->setCols('Class');
0822f9a4	245	$t->setColWidth( 'Class', 75, 1 );
cd677e12	246	$t->addRow($_) for @plugins;
0f7ecc53	247	$caller->log->debug( 'Loaded plugins', $t->draw )
937fcdd8	248	if ( @plugins && $caller->debug );
fc7ec1d9	249
424b2705	250	# Dispatcher
	251	$dispatcher = "Catalyst::Dispatcher::$ENV{CATALYST_DISPATCHER}"
	252	if $ENV{CATALYST_DISPATCHER};
367d15f8	253	my $appdis = $ENV{ uc($caller) . '_DISPATCHER' };
367d15f8	254	$dispatcher = "Catalyst::Dispatcher::$appdis" if $appdis;
424b2705	255
	256	$dispatcher->require;
	257	die qq/Couldn't load dispatcher "$dispatcher", "$@"/ if $@;
	258	{
	259	no strict 'refs';
	260	push @{"$caller\::ISA"}, $dispatcher;
	261	}
	262	$caller->dispatcher($dispatcher);
	263	$caller->log->debug(qq/Loaded dispatcher "$dispatcher"/) if $caller->debug;
	264
e8bf1b2d	265	# Engine
	266	$engine = "Catalyst::Engine::$ENV{CATALYST_ENGINE}"
	267	if $ENV{CATALYST_ENGINE};
367d15f8	268	my $appeng = $ENV{ uc($caller) . '_ENGINE' };
367d15f8	269	$engine = "Catalyst::Engine::$appeng" if $appeng;
e8bf1b2d	270
	271	$engine->require;
	272	die qq/Couldn't load engine "$engine", "$@"/ if $@;
d837e1a7	273
e8bf1b2d	274	{
	275	no strict 'refs';
	276	push @{"$caller\::ISA"}, $engine;
	277	}
d837e1a7	278
e8bf1b2d	279	$caller->engine($engine);
e8bf1b2d	280	$caller->log->debug(qq/Loaded engine "$engine"/) if $caller->debug;
4f6748f1	281
4f6748f1	282	# Find home
812a28c9	283	my $home = Catalyst::Utils::home($caller);
895b2303	284
	285	if ( my $h = $ENV{CATALYST_HOME} ) {
	286
	287	$home = $h if -d $h;
	288
	289	unless ( -e _ ) {
	290	$caller->log->warn(qq/CATALYST_HOME does not exist "$h"/);
	291	}
	292
	293	unless ( -e _ && -d _ ) {
	294	$caller->log->warn(qq/CATALYST_HOME is not a directory "$h"/);
	295	}
	296	}
	297
	298	if ( my $h = $ENV{ uc($caller) . '_HOME' } ) {
	299
	300	$home = $h if -d $h;
	301
	302	unless ( -e _ ) {
	303	my $e = uc($caller) . '_HOME';
	304	$caller->log->warn(qq/$e does not exist "$h"/)
	305	}
	306
	307	unless ( -e _ && -d _ ) {
	308	my $e = uc($caller) . '_HOME';
	309	$caller->log->warn(qq/$e is not a directory "$h"/);
	310	}
	311	}
c571e72b	312
4f6748f1	313	if ( $caller->debug ) {
	314	$home
	315	? ( -d $home )
	316	? $caller->log->debug(qq/Found home "$home"/)
	317	: $caller->log->debug(qq/Home "$home" doesn't exist/)
	318	: $caller->log->debug(q/Couldn't find home/);
	319	}
75aeff23	320	$caller->config->{home} = $home \|\| '';
75aeff23	321	$caller->config->{root} = defined $home ? dir($home)->subdir('root') : '';
fc7ec1d9	322	}
fc7ec1d9	323
70cb38f0	324	=item $c->engine
	325
	326	Contains the engine class.
	327
145074c2	328	=item $c->log
	329
	330	Contains the logging object. Unless it is already set Catalyst sets this up with a
	331	C<Catalyst::Log> object. To use your own log class:
	332
	333	$c->log( MyLogger->new );
	334	$c->log->info("now logging with my own logger!");
	335
	336	Your log class should implement the methods described in the C<Catalyst::Log>
	337	man page.
	338
87232381	339	=item $c->plugin( $name, $class, @args )
	340
	341	Instant plugins for Catalyst.
	342	Classdata accessor/mutator will be created, class loaded and instantiated.
	343
	344	MyApp->plugin( 'prototype', 'HTML::Prototype' );
	345
	346	$c->prototype->define_javascript_functions;
	347
	348	=cut
	349
	350	sub plugin {
	351	my ( $class, $name, $plugin, @args ) = @_;
	352	$plugin->require;
	353	my $error = $UNIVERSAL::require::ERROR;
	354	die qq/Couldn't load instant plugin "$plugin", "$error"/ if $error;
	355	eval { $plugin->import };
	356	$class->mk_classdata($name);
	357	my $obj;
	358	eval { $obj = $plugin->new(@args) };
	359	die qq/Couldn't instantiate instant plugin "$plugin", "$@"/ if $@;
	360	$class->$name($obj);
	361	$class->log->debug(qq/Initialized instant plugin "$plugin" as "$name"/)
	362	if $class->debug;
	363	}
145074c2	364
23f9d934	365	=back
23f9d934	366
d1a31ac6	367	=head1 LIMITATIONS
d1a31ac6	368
b2b7d352	369	mod_perl2 support is considered experimental and may contain bugs.
d1a31ac6	370
3cb1db8c	371	=head1 SUPPORT
	372
	373	IRC:
	374
	375	Join #catalyst on irc.perl.org.
	376
	377	Mailing-Lists:
	378
	379	http://lists.rawmode.org/mailman/listinfo/catalyst
	380	http://lists.rawmode.org/mailman/listinfo/catalyst-dev
1985c30b	381
432d507d	382	Web:
	383
	384	http://catalyst.perl.org
	385
fc7ec1d9	386	=head1 SEE ALSO
fc7ec1d9	387
61b1e958	388	=over 4
	389
	390	=item L<Catalyst::Manual> - The Catalyst Manual
	391
	392	=item L<Catalyst::Engine> - Core Engine
	393
	394	=item L<Catalyst::Log> - The Log Class.
	395
	396	=item L<Catalyst::Request> - The Request Object
	397
	398	=item L<Catalyst::Response> - The Response Object
	399
	400	=item L<Catalyst::Test> - The test suite.
	401
	402	=back
fc7ec1d9	403
	404	=head1 AUTHOR
	405
	406	Sebastian Riedel, C<sri@oook.de>
	407
	408	=head1 THANK YOU
	409
84cf74e7	410	Andy Grundman, Andrew Ford, Andrew Ruthven, Autrijus Tang, Christian Hansen,
ce2b098c	411	Christopher Hicks, Dan Sully, Danijel Milicevic, David Naughton,
75aeff23	412	Gary Ashton Jones, Geoff Richards, Jesse Sheidlower, Jody Belka,
9cee9588	413	Johan Lindstrom, Juan Camacho, Leon Brocard, Marcus Ramberg,
9cee9588	414	Tatsuhiko Miyagawa and all the others who've helped.
fc7ec1d9	415
	416	=head1 LICENSE
	417
	418	This library is free software . You can redistribute it and/or modify it under
	419	the same terms as perl itself.
	420
	421	=cut
	422
	423	1;