NAME¶
Catalyst::Component - Catalyst Component Base Class
SYNOPSIS¶
# lib/MyApp/Model/Something.pm
package MyApp::Model::Something;
use base 'Catalyst::Component';
__PACKAGE__->config( foo => 'bar' );
has foo => (
is => 'ro',
);
sub test {
my $self = shift;
return $self->foo;
}
sub forward_to_me {
my ( $self, $c ) = @_;
$c->response->output( $self->foo );
}
1;
# Methods can be a request step
$c->forward(qw/MyApp::Model::Something forward_to_me/);
# Or just methods
print $c->comp('MyApp::Model::Something')->test;
print $c->comp('MyApp::Model::Something')->foo;
DESCRIPTION¶
This is the universal base class for Catalyst components
(Model/View/Controller).
It provides you with a generic
new() for component construction through
Catalyst's component loader with
config() support and a
process() method placeholder.
Note that calling "$self->config" inside a component is
strongly not recommended - the correctly merged config should have already
been passed to the constructor and stored in attributes - accessing the config
accessor directly from an instance is likely to get the wrong values (as it
only holds the class wide config, not things loaded from the config file!)
METHODS¶
new($app, $arguments)¶
Called by COMPONENT to instantiate the component; should return an object to be
stored in the application's component hash.
COMPONENT¶
"my $component_instance = $component->COMPONENT($app, $arguments);"
If this method is present (as it is on all Catalyst::Component subclasses), it
is called by Catalyst during setup_components with the application class as
$app and any config entry on the application for this component (for example,
in the case of MyApp::Controller::Foo this would be
"MyApp->config('Controller::Foo' => \%conf").
The arguments are expected to be a hashref and are merged with the
"__PACKAGE__->config" hashref before calling "->new"
to instantiate the component.
You can override it in your components to do custom construction, using
something like this:
sub COMPONENT {
my ($class, $app, $args) = @_;
$args = $class->merge_config_hashes($class->config, $args);
return $class->new($app, $args);
}
$c->config¶
$c->config($hashref)¶
$c->config($key, $value, ...)¶
Accessor for this component's config hash. Config values can be set as key value
pair, or you can specify a hashref. In either case the keys will be merged
with any existing config settings. Each component in a Catalyst application
has its own config hash.
The component's config hash is merged with any config entry on the application
for this component and passed to "new()" (as mentioned above at
"COMPONENT"). The recommended practice to access the merged config
is to use a Moose attribute for each config entry on the receiving component.
$c->process()¶
This is the default method called on a Catalyst component in the dispatcher. For
instance, Views implement this action to render the response body when you
forward to them. The default is an abstract method.
$c->merge_config_hashes( $hashref, $hashref )¶
Merges two hashes together recursively, giving right-hand precedence. Alias for
the method in Catalyst::Utils.
$c->expand_modules( $setup_component_config )¶
Return a list of extra components that this component has created. By default,
it just looks for a list of inner packages of this component
OPTIONAL METHODS¶
ACCEPT_CONTEXT($c, @args)¶
Catalyst components are normally initialized during server startup, either as a
Class or a Instance. However, some components require information about the
current request. To do so, they can implement an ACCEPT_CONTEXT method.
If this method is present, it is called during $c->comp/controller/model/view
with the current $c and any additional args (e.g. $c->model('Foo', qw/bar
baz/) would cause your MyApp::Model::Foo instance's ACCEPT_CONTEXT to be
called with ($c, 'bar', 'baz')) and the return value of this method is
returned to the calling code in the application rather than the component
itself.
SEE ALSO¶
Catalyst, Catalyst::Model, Catalyst::View, Catalyst::Controller.
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.