1Catalyst::Component(3)User Contributed Perl DocumentationCatalyst::Component(3)
2
6 Catalyst::Component - Catalyst Component Base Class
7
9 # lib/MyApp/Model/Something.pm
10 package MyApp::Model::Something;
11 use base 'Catalyst::Component';
13 __PACKAGE__->config( foo => 'bar' );
15 has foo => (
17 is => 'ro',
18 );
19 sub test {
21 my $self = shift;
22 return $self->foo;
23 }
24 sub forward_to_me {
26 my ( $self, $c ) = @_;
27 $c->response->output( $self->foo );
28 }
29 1;
31 # Methods can be a request step
33 $c->forward(qw/MyApp::Model::Something forward_to_me/);
34 # Or just methods
36 print $c->comp('MyApp::Model::Something')->test;
37 print $c->comp('MyApp::Model::Something')->foo;
39
41 This is the universal base class for Catalyst components
42 (Model/View/Controller).
43 It provides you with a generic new() for component construction through
45 Catalyst's component loader with config() support and a process()
46 method placeholder.
47 Note that calling "$self->config" inside a component is strongly not
49 recommended - the correctly merged config should have already been
50 passed to the constructor and stored in attributes - accessing the
51 config accessor directly from an instance is likely to get the wrong
52 values (as it only holds the class wide config, not things loaded from
53 the config file!)
54
56 new($app, $arguments)
57 Called by COMPONENT to instantiate the component; should return an
58 object to be stored in the application's component hash.
59 COMPONENT
61 "my $component_instance = $component->COMPONENT($app, $arguments);"
62 If this method is present (as it is on all Catalyst::Component
64 subclasses), it is called by Catalyst during setup_components with the
65 application class as $app and any config entry on the application for
66 this component (for example, in the case of MyApp::Controller::Foo this
67 would be "MyApp->config('Controller::Foo' => \%conf").
68 The arguments are expected to be a hashref and are merged with the
70 "__PACKAGE__->config" hashref before calling "->new" to instantiate the
71 component.
72 You can override it in your components to do custom construction, using
74 something like this:
75 sub COMPONENT {
77 my ($class, $app, $args) = @_;
78 $args = $class->merge_config_hashes($class->config, $args);
79 return $class->new($app, $args);
80 }
81 NOTE: Generally when Catalyst starts, it initializes all the components
83 and passes the hashref present in any configuration information to the
84 COMPONENT method. For example
85 MyApp->config(
87 'Model::Foo' => {
88 bar => 'baz',
89 });
90 You would expect COMPONENT to be called like this ->COMPONENT( 'MyApp',
92 +{ bar=>'baz'});
93 This would happen ONCE during setup.
95 $c->config
97 $c->config($hashref)
98 $c->config($key, $value, ...)
99 Accessor for this component's config hash. Config values can be set as
100 key value pair, or you can specify a hashref. In either case the keys
101 will be merged with any existing config settings. Each component in a
102 Catalyst application has its own config hash.
103 The component's config hash is merged with any config entry on the
105 application for this component and passed to "new()" (as mentioned
106 above at "COMPONENT"). The recommended practice to access the merged
107 config is to use a Moose attribute for each config entry on the
108 receiving component.
109 $c->process()
111 This is the default method called on a Catalyst component in the
112 dispatcher. For instance, Views implement this action to render the
113 response body when you forward to them. The default is an abstract
114 method.
115 $c->merge_config_hashes( $hashref, $hashref )
117 Merges two hashes together recursively, giving right-hand precedence.
118 Alias for the method in Catalyst::Utils.
119 $c->expand_modules( $setup_component_config )
121 Return a list of extra components that this component has created. By
122 default, it just looks for a list of inner packages of this component
123
125 ACCEPT_CONTEXT($c, @args)
126 Catalyst components are normally initialized during server startup,
127 either as a Class or a Instance. However, some components require
128 information about the current request. To do so, they can implement an
129 ACCEPT_CONTEXT method.
130 If this method is present, it is called during
132 $c->comp/controller/model/view with the current $c and any additional
133 args (e.g. $c->model('Foo', qw/bar baz/) would cause your
134 MyApp::Model::Foo instance's ACCEPT_CONTEXT to be called with ($c,
135 'bar', 'baz')) and the return value of this method is returned to the
136 calling code in the application rather than the component itself.
137 NOTE: All classes that are Catalyst::Components will have a COMPONENT
139 method, but classes that are intended to be factories or generators
140 will have ACCEPT_CONTEXT. If you have initialization arguments (such
141 as from configuration) that you wish to expose to the ACCEPT_CONTEXT
142 you should proxy them in the factory instance. For example:
143 MyApp::Model::FooFactory;
145 use Moose;
147 extends 'Catalyst::Model';
148 has type => (is=>'ro', required=>1);
150 sub ACCEPT_CONTEXT {
152 my ($self, $c, @args) = @_;
153 return bless { args=>\@args }, $self->type;
154 }
155 MyApp::Model::Foo->meta->make_immutable;
157 MyApp::Model::Foo->config( type => 'Type1' );
158 And in a controller:
160 my $type = $c->model('FooFactory', 1,2,3,4): # $type->isa('Type1')
162 NOTE: If you define a ACCEPT_CONTEXT method it MUST check to see if the
164 second argument is blessed (is a context) or not (is an application
165 class name) and it MUST return something valid for the case when the
166 scope is application. This is required because a component maybe be
167 called from the application scope even if it requires a context and you
168 must prevent errors from being issued if this happens. Remember not
169 all components that ACCEPT_CONTEXT actually need or use context
170 information (and there is a school of thought that suggestions doing so
171 is a design error anyway...)
172
174 Catalyst, Catalyst::Model, Catalyst::View, Catalyst::Controller.
175
177 Catalyst Contributors, see Catalyst.pm
178
180 This library is free software. You can redistribute it and/or modify it
181 under the same terms as Perl itself.
182perl v5.30.1 2020-01-29 Catalyst::Component(3)