Mojolicious.pm

filter: Statementstmt 95.4% 187 / 196 Branchbran 83.3% 30 / 36 Conditioncond 66.6% 22 / 33 MC/DCmcdc 33.3% 6 / 18 Subroutinesub 95.5% 65 / 68 Podpod 96.0% 24 / 25 totaltotal 88.8% 334 / 376 CC 47 SCAR 9.9
CC
47
Cov
90%
dispatch
8.2
handler
5.5
build_controller
4.0
CRAP 2.7
« Mojolicious/Command/Author/generate/plugin.pm ↑ Summary Mojo/DynamicMethods.pm »
1 package Mojolicious;
2 20 ▶use Mojo::Base -base;
Subroutine BEGIN: called CC=1 SCAR=0.0
3  
4 # "Fry: Shut up and take my money!"
5 20 ▶use Carp ();
Subroutine BEGIN: called CC=1 SCAR=0.0
6 20 ▶use Mojo::DynamicMethods -dispatch;
Subroutine BEGIN: called CC=1 SCAR=0.0
7 20 ▶use Mojo::Exception;
Subroutine BEGIN: called CC=1 SCAR=0.0
8 20 ▶use Mojo::Home;
Subroutine BEGIN: called CC=1 SCAR=0.0
9 20 ▶use Mojo::Loader;
Subroutine BEGIN: called CC=1 SCAR=0.0
10 20 ▶use Mojo::Log;
Subroutine BEGIN: called CC=1 SCAR=0.0
11 20 ▶use Mojo::Server;
Subroutine BEGIN: called CC=1 SCAR=0.0
12 20 ▶use Mojo::Util;
Subroutine BEGIN: called CC=1 SCAR=0.0
13 20 ▶use Mojo::UserAgent;
Subroutine BEGIN: called CC=1 SCAR=0.0
14 20 ▶use Mojolicious::Commands;
Subroutine BEGIN: called CC=1 SCAR=0.0
15 20 ▶use Mojolicious::Controller;
Subroutine BEGIN: called CC=1 SCAR=0.0
16 20 ▶use Mojolicious::Plugins;
Subroutine BEGIN: called CC=1 SCAR=0.0
17 20 ▶use Mojolicious::Renderer;
Subroutine BEGIN: called CC=1 SCAR=0.0
18 20 ▶use Mojolicious::Routes;
Subroutine BEGIN: called CC=1 SCAR=0.0
19 20 ▶use Mojolicious::Sessions;
Subroutine BEGIN: called CC=1 SCAR=0.0
20 20 ▶use Mojolicious::Static;
Subroutine BEGIN: called CC=1 SCAR=0.0
21 20 ▶use Mojolicious::Types;
Subroutine BEGIN: called CC=1 SCAR=0.0
22 20 ▶use Mojolicious::Validator;
Subroutine BEGIN: called CC=1 SCAR=0.0
23 20 ▶use Scalar::Util ();
Subroutine BEGIN: called CC=1 SCAR=0.0
24  
25 26 ▶has commands => sub { Mojolicious::Commands->new(app => shift) };
Subroutine __ANON__: called CC=1 SCAR=0.0
26 20 has controller_class => 'Mojolicious::Controller';
27 20 has exception_format => 'html';
28 82 ▶has home => sub { Mojo::Home->new->detect(ref shift) };
Subroutine __ANON__: called CC=1 SCAR=0.0
29 42 ▶has log => sub {
Subroutine __ANON__: called CC=3 SCAR=11.0
30 42 my $self = shift;
31  
32 # Reduced log output outside of development mode
33 42 my $log = Mojo::Log->new;
34 42 ▶ return $log->level($ENV{MOJO_LOG_LEVEL}) if $ENV{MOJO_LOG_LEVEL};
Branch: 1 branch
BranchTrueFalseTotal
if $ENV{"MOJO_LOG_LEVEL"} 12 30 42
35 30 ▶ return $self->mode eq 'development' ? $log : $log->level('info');
Branch: 1 branch
BranchTrueFalseTotal
$self->mode eq 'development' ? : 28 2 30
36 20 };
37 20 has 'max_request_size';
38 55 ▶has mode => sub { $ENV{MOJO_MODE} || $ENV{PLACK_ENV} || 'development' };
Subroutine __ANON__: called CC=3 SCAR=11.0
Branch: 1 branch
BranchTrueFalseTotal
$ENV{"MOJO_MODE"} or $ENV{"PLACK_ENV"} or "development" 22 33 55
Condition100%3/3
$ENV{"MOJO_MODE"} or $ENV{"PLACK_ENV"}
l!l&&r!l&&!r
19333
MC/DC100%2/2
$ENV{"MOJO_MODE"} or $ENV{"PLACK_ENV"}
$ENV{"MOJO_MODE"} $ENV{"PLACK_ENV"}
Truth table100%3/3
A or B
A= $ENV{"MOJO_MODE"}B= $ENV{"PLACK_ENV"}
ABresult
1X1
011
000
39 13 ▶has moniker => sub { Mojo::Util::decamelize ref shift };
Subroutine __ANON__: called CC=1 SCAR=0.0
40 83 ▶has plugins => sub { Mojolicious::Plugins->new };
Subroutine __ANON__: called CC=1 SCAR=0.0
41 0 ▶has preload_namespaces => sub { [] };
Subroutine __ANON__: not called CC=1 SCAR=1.2
42 83 ▶has renderer => sub { Mojolicious::Renderer->new };
Subroutine __ANON__: called CC=1 SCAR=0.0
43 83 ▶has routes => sub { Mojolicious::Routes->new };
Subroutine __ANON__: called CC=1 SCAR=0.0
44 3 ▶has secrets => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
45 3 my $self = shift;
46  
47 # Warn developers about insecure default
48 3 $self->log->trace('Your secret passphrase needs to be changed (see FAQ for more)');
49  
50 # Default to moniker
51 3 return [$self->moniker];
52 20 };
53 35 ▶has sessions => sub { Mojolicious::Sessions->new };
Subroutine __ANON__: called CC=1 SCAR=0.0
54 83 ▶has static => sub { Mojolicious::Static->new };
Subroutine __ANON__: called CC=1 SCAR=0.0
55 19 ▶has types => sub { Mojolicious::Types->new };
Subroutine __ANON__: called CC=1 SCAR=0.0
56 3 ▶has ua => sub { Mojo::UserAgent->new };
Subroutine __ANON__: called CC=1 SCAR=0.0
57 3 ▶has validator => sub { Mojolicious::Validator->new };
Subroutine __ANON__: called CC=1 SCAR=0.0
58  
59 20 our $CODENAME = 'Waffle';
60 20 our $VERSION = '9.54';
61  
62 1271 ▶sub BUILD_DYNAMIC {
Subroutine BUILD_DYNAMIC: called CC=1 SCAR=2.2
Pod undocumented
63 1271 my ($class, $method, $dyn_methods) = @_;
64  
65 0 ▶ return sub {
Subroutine title: not called CC=2 SCAR=12.4
Subroutine accepts: called CC=2 SCAR=12.4
66 0 my $self = shift;
67 0 my $dynamic = $dyn_methods->{$self->renderer}{$method};
68 0 ▶ return $self->build_controller->$dynamic(@_) if $dynamic;
Branch: 2 branches
BranchTrueFalseTotal
if $dynamic 0 0 0
if $dynamic 3 0 3
69 0 my $package = ref $self;
70 0 Carp::croak qq{Can't locate object method "$method" via package "$package"};
71 1271 };
72 }
73  
74 1 ▶sub any { shift->routes->any(@_) }
Subroutine any: called CC=1 SCAR=0.0
Pod documented
75  
76 194 ▶sub build_controller {
Subroutine build_controller: called CC=4 SCAR=13.9
Pod documented
77 194 my ($self, $tx) = @_;
78  
79 # Embedded application
80 194 my $stash = {};
81 194 ▶ if ($tx && (my $sub = $tx->can('stash'))) { ($stash, $tx) = ($tx->$sub, $tx->tx) }
Branch: 1 branch
BranchTrueFalseTotal
if ($tx and my $sub = $tx->can("stash")) 1 193 194
Condition100%3/3
$tx and my $sub = $tx->can("stash")
!ll&&!rl&&r
281651
MC/DC100%2/2
$tx and my $sub = $tx->can("stash")
$tx my $sub = $tx->can("stash")
Truth table100%3/3
A and B
A= $txB= my $sub = $tx->can("stash")
ABresult
0X0
100
111
82  
83 # Build default controller
84 194 my $defaults = $self->defaults;
85 194 @$stash{keys %$defaults} = values %$defaults;
86 194 my $c = $self->controller_class->new(app => $self, stash => $stash, tx => $tx);
87 194 ▶ $c->{tx} ||= $self->build_tx;
Condition66%2/3
$c->{"tx"} ||= $self->build_tx
l!l&&r!l&&!r
166280
MC/DC0%0/2
$c->{"tx"} ||= $self->build_tx
$c->{"tx"} $self->build_tx
Truth table66%2/3
A ||= B
A= $c->{"tx"}B= $self->build_tx
ABresult
1X1
011
000
88  
89 194 return $c;
90 }
91  
92 192 ▶sub build_tx {
Subroutine build_tx: called CC=2 SCAR=7.0
Pod documented
93 192 my $self = shift;
94  
95 192 my $tx = Mojo::Transaction::HTTP->new;
96 192 my $max = $self->max_request_size;
97 192 ▶ $tx->req->max_message_size($max) if defined $max;
Branch: 1 branch
BranchTrueFalseTotal
if defined $max 0 192 192
98 192 $self->plugins->emit_hook(after_build_tx => $tx, $self);
99  
100 192 return $tx;
101 }
102  
103 85 ▶sub config { Mojo::Util::_stash(config => @_) }
Subroutine config: called CC=1 SCAR=0.0
Pod documented
104 206 ▶sub defaults { Mojo::Util::_stash(defaults => @_) }
Subroutine defaults: called CC=1 SCAR=0.0
Pod documented
105  
106 1 ▶sub delete { shift->routes->delete(@_) }
Subroutine delete: called CC=1 SCAR=0.0
Pod documented
107  
108 166 ▶sub dispatch {
Subroutine dispatch: called CC=8 SCAR=21.0
Pod documented
109 166 my ($self, $c) = @_;
110  
111 166 my $plugins = $self->plugins->emit_hook(before_dispatch => $c);
112  
113 166 my $stash = $c->stash;
114 166 ▶ return if $stash->{'mojo.rendered'};
Branch: 1 branch
BranchTrueFalseTotal
if $stash->{"mojo.rendered"} 4 162 166
115  
116 # Try to find a static file
117 162 my $tx = $c->tx;
118 162 ▶ $self->static->dispatch($c) and $plugins->emit_hook(after_static => $c) unless $tx->res->code;
Branch: 1 branch
BranchTrueFalseTotal
unless $tx->res->code 162 0 162
Condition50%3/6
$tx->res->code || $self->static->dispatch($c) && $plugins->emit_hook('after_static', $c)
l!l
01620
$self->static->dispatch($c) and $plugins->emit_hook("after_static", $c)
!ll
144180
MC/DC0%0/3
$tx->res->code || $self->static->dispatch($c) && $plugins->emit_hook('after_static', $c)
$tx->res->code $self->static->dispatch($c) $plugins->emit_hook("after_static", $c)
Truth table0%0/4
A || B and C
A= $tx->res->codeB= $self->static->dispatch($c)C= $plugins->emit_hook("after_static", $c)
ABCresult
1XX1
0111
00X0
0100
119  
120 # Start timer (ignore static files)
121 10 ▶ $c->helpers->log->trace(sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
122 10 my $req = $c->req;
123 10 my $method = $req->method;
124 10 my $path = $req->url->path->to_abs_string;
125 10 $c->helpers->timing->begin('mojo.timer');
126 10 return qq{$method "$path"};
127 162 ▶ }) unless $stash->{'mojo.static'};
Branch: 1 branch
BranchTrueFalseTotal
unless $stash->{"mojo.static"} 144 18 162
128  
129 # Routes
130 162 $plugins->emit_hook(before_routes => $c);
131 162 ▶ $c->helpers->reply->not_found unless $tx->res->code || $self->routes->dispatch($c) || $tx->res->code;
Branch: 1 branch
BranchTrueFalseTotal
unless $tx->res->code or $self->routes->dispatch($c) or $tx->res->code 23 114 137
Condition83%5/6
$tx->res->code or $self->routes->dispatch($c) or $tx->res->code
l!l&&r!l&&!r
114023
$tx->res->code or $self->routes->dispatch($c)
l!l&&r!l&&!r
1810737
MC/DC66%2/3
$tx->res->code or $self->routes->dispatch($c) or $tx->res->code
$tx->res->code $self->routes->dispatch($c) $tx->res->code
Truth table75%3/4
A or B or C
A= $tx->res->codeB= $self->routes->dispatch($c)C= $tx->res->code
ABCresult
1XX1
01X1
0011
0000
132 }
133  
134 1 ▶sub get { shift->routes->get(@_) }
Subroutine get: called CC=1 SCAR=0.0
Pod documented
135  
136 166 ▶sub handler {
Subroutine handler: called CC=5 SCAR=17.0
Pod documented
137 166 my $self = shift;
138  
139 # Dispatcher has to be last in the chain
140 ++$self->{dispatch}
141 and $self->hook(around_action => \&_action)
142 166 ▶ and $self->hook(around_dispatch => sub { $_[1]->app->dispatch($_[1]) })
Subroutine __ANON__: called CC=1 SCAR=0.0
143 166 ▶ unless $self->{dispatch};
Branch: 1 branch
BranchTrueFalseTotal
unless $self->{"dispatch"} 18 148 166
Condition44%4/9
$self->{'dispatch'} || ++$self->{'dispatch'} && $self->hook('around_action', \&Mojolicious::_action) && $self->hook('around_dispatch', sub { $_[1]->app->dispatch($_[1]); } )
l!l
148180
++$self->{"dispatch"} and $self->hook("around_action", \&Mojolicious::_action) and $self->hook("around_dispatch", sub { $_[1]->app->dispatch($_[1]); } )
!ll
0180
++$self->{"dispatch"} and $self->hook("around_action", \&Mojolicious::_action)
!ll&&!rl&&r
0018
MC/DC0%0/4
$self->{'dispatch'} || ++$self->{'dispatch'} && $self->hook('around_action', \&Mojolicious::_action) && $self->hook('around_dispatch', sub { $_[1]->app->dispatch($_[1]); } )
$self->{'dispatch'} ++$self->{"dispatch"} $self->hook("around_action", \&Mojolicious::_action) $self->hook("around_dispatch", sub { $_[1]->app->dispatch($_[1]); } )
Truth table0%0/5
A || B and C and D
A= $self->{'dispatch'}B= ++$self->{"dispatch"}C= $self->hook("around_action", \&Mojolicious::_action)D= $self->hook("around_dispatch", sub { $_[1]->app->dispatch($_[1]); } )
ABCDresult
1XXX1
01111
00XX0
010X0
01100
144  
145 # Process with chain
146 166 my $c = $self->build_controller(@_);
147 166 $self->plugins->emit_chain(around_dispatch => $c);
148  
149 # Delayed response
150 $c->helpers->log->trace('Nothing has been rendered, expecting delayed response (see FAQ for more)')
151 166 ▶ unless $c->stash->{'mojo.rendered'};
Branch: 1 branch
BranchTrueFalseTotal
unless $c->stash->{"mojo.rendered"} 1 165 166
152 }
153  
154 7271 ▶sub helper { shift->renderer->add_helper(@_) }
Subroutine helper: called CC=1 SCAR=0.0
Pod documented
155  
156 146 ▶sub hook { shift->plugins->on(@_) }
Subroutine hook: called CC=1 SCAR=0.0
Pod documented
157  
158 83 ▶sub new {
Subroutine new: called CC=3 SCAR=11.0
Pod documented
159 83 ▶ my $self = shift->SUPER::new((ref $_[0] ? %{shift()} : @_), @Mojo::Server::ARGS_OVERRIDE);
Branch: 1 branch
BranchTrueFalseTotal
ref $_[0] ? : 4 79 83
160  
161 83 my $home = $self->home;
162 83 push @{$self->renderer->paths}, $home->child('templates')->to_string;
163 83 push @{$self->static->paths}, $home->child('public')->to_string;
164  
165 # Default to controller and application namespace
166 83 my $controller = "@{[ref $self]}::Controller";
167 83 my $r = $self->preload_namespaces([$controller])->routes->namespaces([$controller, ref $self]);
168  
169 83 $self->plugin($_) for qw(HeaderCondition DefaultHelpers TagHelpers EPLRenderer EPRenderer);
170  
171 # Exception handling should be first in chain
172 83 $self->hook(around_dispatch => \&_exception);
173  
174 83 $self->startup;
175 82 $self->warmup;
176  
177 82 return $self;
178 }
179  
180 1 ▶sub options { shift->routes->options(@_) }
Subroutine options: called CC=1 SCAR=0.0
Pod documented
181 1 ▶sub patch { shift->routes->patch(@_) }
Subroutine patch: called CC=1 SCAR=0.0
Pod documented
182  
183 493 ▶sub plugin {
Subroutine plugin: called CC=1 SCAR=0.0
Pod documented
184 493 my $self = shift;
185 493 $self->plugins->register_plugin(shift, $self, @_);
186 }
187  
188 1 ▶sub post { shift->routes->post(@_) }
Subroutine post: called CC=1 SCAR=0.0
Pod documented
189 1 ▶sub put { shift->routes->put(@_) }
Subroutine put: called CC=1 SCAR=0.0
Pod documented
190 1 ▶sub query { shift->routes->query(@_) }
Subroutine query: called CC=1 SCAR=0.0
Pod documented
191  
192 46 ▶sub server { $_[0]->plugins->emit_hook(before_server_start => @_[1, 0]) }
Subroutine server: called CC=1 SCAR=0.0
Pod documented
193  
194 18 ▶sub start {
Subroutine start: called CC=3 SCAR=11.0
Pod documented
195 18 my $self = shift;
196 18 $_->warmup for $self->static, $self->renderer;
197 18 ▶ return $self->commands->run(@_ ? @_ : @ARGV);
Branch: 1 branch
BranchTrueFalseTotal
@_ ? : 10 8 18
198 }
199  
200 33 ▶sub startup { }
Subroutine startup: called CC=1 SCAR=0.0
Pod documented
201  
202 1 ▶sub under { shift->routes->under(@_) }
Subroutine under: called CC=1 SCAR=0.0
Pod documented
203  
204 82 ▶sub warmup { Mojo::Loader::load_classes $_ for @{shift->preload_namespaces} }
Subroutine warmup: called CC=2 SCAR=6.9
Pod documented
205  
206 1 ▶sub websocket { shift->routes->websocket(@_) }
Subroutine websocket: called CC=1 SCAR=0.0
Pod documented
207  
208 83 ▶sub _action {
Subroutine _action: called CC=3 SCAR=11.8
209 83 my ($next, $c, $action, $last) = @_;
210 83 my $val = $action->($c);
211 0 ▶ $val->catch(sub { $c->helpers->reply->exception(shift) }) if Scalar::Util::blessed $val && $val->isa('Mojo::Promise');
Subroutine __ANON__: not called CC=1 SCAR=0.8
Branch: 1 branch
BranchTrueFalseTotal
if builtin::blessed($val) and $val->isa("Mojo::Promise") 0 73 73
Condition66%2/3
builtin::blessed($val) and $val->isa("Mojo::Promise")
!ll&&!rl&&r
61120
MC/DC0%0/2
builtin::blessed($val) and $val->isa("Mojo::Promise")
builtin::blessed($val) $val->isa("Mojo::Promise")
Truth table66%2/3
A and B
A= builtin::blessed($val)B= $val->isa("Mojo::Promise")
ABresult
0X0
100
111
212 73 return $val;
213 }
214  
215 153 ▶sub _die { CORE::die ref $_[0] ? $_[0] : Mojo::Exception->new(shift)->trace }
Subroutine _die: called CC=2 SCAR=6.9
Branch: 1 branch
BranchTrueFalseTotal
ref $_[0] ? : 6 147 153
216  
217 166 ▶sub _exception {
Subroutine _exception: called CC=2 SCAR=6.9
218 166 my ($next, $c) = @_;
219 166 local $SIG{__DIE__} = \&_die;
220 166 ▶ $c->helpers->reply->exception($@) unless eval { $next->(); 1 };
Branch: 1 branch
BranchTrueFalseTotal
unless eval { do { &$next(); 1 } } 25 141 166
221 }
222  
223 20 1;
224  
225 =encoding utf8
226  
227 =head1 NAME
228  
229 Mojolicious - Real-time web framework
230  
231 =head1 SYNOPSIS
232  
233 # Application
234 package MyApp;
235 use Mojo::Base 'Mojolicious', -signatures;
236  
237 # Route
238 sub startup ($self) {
239 $self->get('/hello')->to('foo#hello');
240 }
241  
242 # Controller
243 package MyApp::Controller::Foo;
244 use Mojo::Base 'Mojolicious::Controller', -signatures;
245  
246 # Action
247 sub hello ($self) {
248 $self->render(text => 'Hello World!');
249 }
250  
251 =head1 DESCRIPTION
252  
253 An amazing real-time web framework built on top of the powerful L<Mojo> web development toolkit. With support for
254 RESTful routes, plugins, commands, Perl-ish templates, content negotiation, session management, form validation,
255 testing framework, static file server, C<CGI>/C<PSGI> detection, first class Unicode support and much more for you to
256 discover.
257  
258 Take a look at our excellent documentation in L<Mojolicious::Guides>!
259  
260 =head1 HOOKS
261  
262 L<Mojolicious> will emit the following hooks in the listed order.
263  
264 =head2 before_command
265  
266 Emitted right before the application runs a command through the command line interface.
267  
268 $app->hook(before_command => sub ($command, $args) {...});
269  
270 Useful for reconfiguring the application before running a command or to modify the behavior of a command. (Passed the
271 command object and the command arguments)
272  
273 =head2 before_server_start
274  
275 Emitted right before the application server is started, for web servers that support it, which includes all the
276 built-in ones.
277  
278 $app->hook(before_server_start => sub ($server, $app) {...});
279  
280 Useful for reconfiguring application servers dynamically or collecting server diagnostics information. (Passed the
281 server and application objects)
282  
283 =head2 after_build_tx
284  
285 Emitted right after the transaction is built and before the HTTP request gets parsed.
286  
287 $app->hook(after_build_tx => sub ($tx, $app) {...});
288  
289 This is a very powerful hook and should not be used lightly, it makes some rather advanced features such as upload
290 progress bars possible. Note that this hook will not work for embedded applications, because only the host application
291 gets to build transactions. (Passed the transaction and application objects)
292  
293 =head2 around_dispatch
294  
295 Emitted right after a new request has been received and wraps around the whole dispatch process, so you have to
296 manually forward to the next hook if you want to continue the chain. Default exception handling with
297 L<Mojolicious::Plugin::DefaultHelpers/"reply-E<gt>exception"> is the first hook in the chain and a call to
298 L</"dispatch"> the last, yours will be in between.
299  
300 $app->hook(around_dispatch => sub ($next, $c) {
301 ...
302 $next->();
303 ...
304 });
305  
306 This is a very powerful hook and should not be used lightly, it allows you to, for example, customize application-wide
307 exception handling, consider it the sledgehammer in your toolbox. (Passed a callback leading to the next hook and the
308 default controller object)
309  
310 =head2 before_dispatch
311  
312 Emitted right before the static file server and router start their work.
313  
314 $app->hook(before_dispatch => sub ($c) {...});
315  
316 Very useful for rewriting incoming requests and other preprocessing tasks. (Passed the default controller object)
317  
318 =head2 after_static
319  
320 Emitted after a static file response has been generated by the static file server.
321  
322 $app->hook(after_static => sub ($c) {...});
323  
324 Mostly used for post-processing static file responses. (Passed the default controller object)
325  
326 =head2 before_routes
327  
328 Emitted after the static file server determined if a static file should be served and before the router starts its
329 work.
330  
331 $app->hook(before_routes => sub ($c) {...});
332  
333 Mostly used for custom dispatchers and collecting metrics. (Passed the default controller object)
334  
335 =head2 around_action
336  
337 Emitted right before an action gets executed and wraps around it, so you have to manually forward to the next hook if
338 you want to continue the chain. Default action dispatching is the last hook in the chain, yours will run before it.
339  
340 $app->hook(around_action => sub ($next, $c, $action, $last) {
341 ...
342 return $next->();
343 });
344  
345 This is a very powerful hook and should not be used lightly, it allows you for example to pass additional arguments to
346 actions or handle return values differently. Note that this hook can trigger more than once for the same request if
347 there are nested routes. (Passed a callback leading to the next hook, the current controller object, the action
348 callback and a flag indicating if this action is an endpoint)
349  
350 =head2 before_render
351  
352 Emitted before content is generated by the renderer. Note that this hook can trigger out of order due to its dynamic
353 nature, and with embedded applications will only work for the application that is rendering.
354  
355 $app->hook(before_render => sub ($c, $args) {...});
356  
357 Mostly used for pre-processing arguments passed to the renderer. (Passed the current controller object and the render
358 arguments)
359  
360 =head2 after_render
361  
362 Emitted after content has been generated by the renderer that will be assigned to the response. Note that this hook can
363 trigger out of order due to its dynamic nature, and with embedded applications will only work for the application that
364 is rendering.
365  
366 $app->hook(after_render => sub ($c, $output, $format) {...});
367  
368 Mostly used for post-processing dynamically generated content. (Passed the current controller object, a reference to
369 the content and the format)
370  
371 =head2 after_dispatch
372  
373 Emitted in reverse order after a response has been generated. Note that this hook can trigger out of order due to its
374 dynamic nature, and with embedded applications will only work for the application that is generating the response.
375  
376 $app->hook(after_dispatch => sub ($c) {...});
377  
378 Useful for rewriting outgoing responses and other post-processing tasks. (Passed the current controller object)
379  
380 =head1 ATTRIBUTES
381  
382 L<Mojolicious> implements the following attributes.
383  
384 =head2 commands
385  
386 my $commands = $app->commands;
387 $app = $app->commands(Mojolicious::Commands->new);
388  
389 Command line interface for your application, defaults to a L<Mojolicious::Commands> object.
390  
391 # Add another namespace to load commands from
392 push @{$app->commands->namespaces}, 'MyApp::Command';
393  
394 =head2 controller_class
395  
396 my $class = $app->controller_class;
397 $app = $app->controller_class('Mojolicious::Controller');
398  
399 Class to be used for the default controller, defaults to L<Mojolicious::Controller>. Note that this class needs to have
400 already been loaded before the first request arrives.
401  
402 =head2 exception_format
403  
404 my $format = $app->exception_format;
405 $app = $app->exception_format('txt');
406  
407 Format for HTTP exceptions (C<html>, C<json>, or C<txt>), defaults to C<html>.
408  
409 =head2 home
410  
411 my $home = $app->home;
412 $app = $app->home(Mojo::Home->new);
413  
414 The home directory of your application, defaults to a L<Mojo::Home> object which stringifies to the actual path.
415  
416 # Portably generate path relative to home directory
417 my $path = $app->home->child('data', 'important.txt');
418  
419 =head2 log
420  
421 my $log = $app->log;
422 $app = $app->log(Mojo::Log->new);
423  
424 The logging layer of your application, defaults to a L<Mojo::Log> object. The level will default to either the
425 C<MOJO_LOG_LEVEL> environment variable, C<trace> if the L</mode> is C<development>, or C<info> otherwise. All messages
426 will be written to C<STDERR> by default.
427  
428 # Log debug message
429 $app->log->debug('It works');
430  
431 =head2 max_request_size
432  
433 my $max = $app->max_request_size;
434 $app = $app->max_request_size(16777216);
435  
436 Maximum request size in bytes, defaults to the value of L<Mojo::Message/"max_message_size">. Setting the value to C<0>
437 will allow requests of indefinite size. Note that increasing this value can also drastically increase memory usage,
438 should you for example attempt to parse an excessively large request body with the methods L<Mojo::Message/"dom"> or
439 L<Mojo::Message/"json">.
440  
441 =head2 mode
442  
443 my $mode = $app->mode;
444 $app = $app->mode('production');
445  
446 The operating mode for your application, defaults to a value from the C<MOJO_MODE> and C<PLACK_ENV> environment
447 variables or C<development>.
448  
449 =head2 moniker
450  
451 my $moniker = $app->moniker;
452 $app = $app->moniker('foo_bar');
453  
454 Moniker of this application, often used as default filename for configuration files and the like, defaults to
455 decamelizing the application class with L<Mojo::Util/"decamelize">.
456  
457 =head2 plugins
458  
459 my $plugins = $app->plugins;
460 $app = $app->plugins(Mojolicious::Plugins->new);
461  
462 The plugin manager, defaults to a L<Mojolicious::Plugins> object. See the L</"plugin"> method below if you want to load
463 a plugin.
464  
465 # Add another namespace to load plugins from
466 push @{$app->plugins->namespaces}, 'MyApp::Plugin';
467  
468 =head2 preload_namespaces
469  
470 my $namespaces = $app->preload_namespaces;
471 $app = $app->preload_namespaces(['MyApp::Controller']);
472  
473 Namespaces to preload classes from during application startup.
474  
475 =head2 renderer
476  
477 my $renderer = $app->renderer;
478 $app = $app->renderer(Mojolicious::Renderer->new);
479  
480 Used to render content, defaults to a L<Mojolicious::Renderer> object. For more information about how to generate
481 content see L<Mojolicious::Guides::Rendering>.
482  
483 # Enable compression
484 $app->renderer->compress(1);
485  
486 # Add another "templates" directory
487 push @{$app->renderer->paths}, '/home/sri/templates';
488  
489 # Add another "templates" directory with higher precedence
490 unshift @{$app->renderer->paths}, '/home/sri/themes/blue/templates';
491  
492 # Add another class with templates in DATA section
493 push @{$app->renderer->classes}, 'Mojolicious::Plugin::Fun';
494  
495 =head2 routes
496  
497 my $routes = $app->routes;
498 $app = $app->routes(Mojolicious::Routes->new);
499  
500 The router, defaults to a L<Mojolicious::Routes> object. You use this in your startup method to define the url
501 endpoints for your application.
502  
503 # Add routes
504 my $r = $app->routes;
505 $r->get('/foo/bar')->to('test#foo', title => 'Hello Mojo!');
506 $r->post('/baz')->to('test#baz');
507  
508 # Add another namespace to load controllers from
509 push @{$app->routes->namespaces}, 'MyApp::MyController';
510  
511 =head2 secrets
512  
513 my $secrets = $app->secrets;
514 $app = $app->secrets([$bytes]);
515  
516 Secret passphrases used for signed cookies and the like, defaults to the L</"moniker"> of this application, which is
517 not very secure, so you should change it!!! As long as you are using the insecure default there will be debug messages
518 in the log file reminding you to change your passphrase. Only the first passphrase is used to create new signatures,
519 but all of them for verification. So you can increase security without invalidating all your existing signed cookies by
520 rotating passphrases, just add new ones to the front and remove old ones from the back.
521  
522 # Rotate passphrases
523 $app->secrets(['new_passw0rd', 'old_passw0rd', 'very_old_passw0rd']);
524  
525 =head2 sessions
526  
527 my $sessions = $app->sessions;
528 $app = $app->sessions(Mojolicious::Sessions->new);
529  
530 Signed cookie based session manager, defaults to a L<Mojolicious::Sessions> object. You can usually leave this alone,
531 see L<Mojolicious::Controller/"session"> for more information about working with session data.
532  
533 # Enable encrypted sessions
534 $app->sessions->encrypted(1);
535  
536 # Change name of cookie used for all sessions
537 $app->sessions->cookie_name('mysession');
538  
539 # Disable SameSite feature
540 $app->sessions->samesite(undef);
541  
542 =head2 static
543  
544 my $static = $app->static;
545 $app = $app->static(Mojolicious::Static->new);
546  
547 For serving static files from your C<public> directories, defaults to a L<Mojolicious::Static> object.
548  
549 # Serve static files only with a "/static" prefix
550 $app->static->prefix('/static');
551  
552 # Add another "public" directory
553 push @{$app->static->paths}, '/home/sri/public';
554  
555 # Add another "public" directory with higher precedence
556 unshift @{$app->static->paths}, '/home/sri/themes/blue/public';
557  
558 # Add another class with static files in DATA section
559 push @{$app->static->classes}, 'Mojolicious::Plugin::Fun';
560  
561 # Remove built-in favicon
562 delete $app->static->extra->{'favicon.ico'};
563  
564 =head2 types
565  
566 my $types = $app->types;
567 $app = $app->types(Mojolicious::Types->new);
568  
569 Responsible for connecting file extensions with MIME types, defaults to a L<Mojolicious::Types> object.
570  
571 # Add custom MIME type
572 $app->types->type(twt => 'text/tweet');
573  
574 =head2 ua
575  
576 my $ua = $app->ua;
577 $app = $app->ua(Mojo::UserAgent->new);
578  
579 A full featured HTTP user agent for use in your applications, defaults to a L<Mojo::UserAgent> object.
580  
581 # Perform blocking request
582 say $app->ua->get('example.com')->result->body;
583  
584 =head2 validator
585  
586 my $validator = $app->validator;
587 $app = $app->validator(Mojolicious::Validator->new);
588  
589 Validate values, defaults to a L<Mojolicious::Validator> object.
590  
591 # Add validation check
592 $app->validator->add_check(foo => sub ($v, $name, $value) {
593 return $value ne 'foo';
594 });
595  
596 # Add validation filter
597 $app->validator->add_filter(quotemeta => sub ($v, $name, $value) {
598 return quotemeta $value;
599 });
600  
601 =head1 METHODS
602  
603 L<Mojolicious> inherits all methods from L<Mojo::Base> and implements the following new ones.
604  
605 =head2 any
606  
607 my $route = $app->any('/:foo' => sub ($c) {...});
608  
609 Generate route with L<Mojolicious::Routes::Route/"any"> on L</"routes">, takes the same arguments.
610  
611 =head2 build_controller
612  
613 my $c = $app->build_controller;
614 my $c = $app->build_controller(Mojo::Transaction::HTTP->new);
615 my $c = $app->build_controller(Mojolicious::Controller->new);
616  
617 Build default controller object with L</"controller_class">.
618  
619 # Render template from application
620 my $foo = $app->build_controller->render_to_string(template => 'foo');
621  
622 =head2 build_tx
623  
624 my $tx = $app->build_tx;
625  
626 Build L<Mojo::Transaction::HTTP> object and emit L</"after_build_tx"> hook.
627  
628 =head2 config
629  
630 my $hash = $app->config;
631 my $foo = $app->config('foo');
632 $app = $app->config({foo => 'bar', baz => 23});
633 $app = $app->config(foo => 'bar', baz => 23);
634  
635 Application configuration.
636  
637 # Remove value
638 my $foo = delete $app->config->{foo};
639  
640 # Assign multiple values at once
641 $app->config(foo => 'test', bar => 23);
642  
643 =head2 defaults
644  
645 my $hash = $app->defaults;
646 my $foo = $app->defaults('foo');
647 $app = $app->defaults({foo => 'bar', baz => 23});
648 $app = $app->defaults(foo => 'bar', baz => 23);
649  
650 Default values for L<Mojolicious::Controller/"stash">, assigned for every new request.
651  
652 # Remove value
653 my $foo = delete $app->defaults->{foo};
654  
655 # Assign multiple values at once
656 $app->defaults(foo => 'test', bar => 23);
657  
658 =head2 delete
659  
660 my $route = $app->delete('/:foo' => sub ($c) {...});
661  
662 Generate route with L<Mojolicious::Routes::Route/"delete"> on L</"routes">, takes the same arguments.
663  
664 =head2 dispatch
665  
666 $app->dispatch(Mojolicious::Controller->new);
667  
668 The heart of every L<Mojolicious> application, calls the L</"static"> and L</"routes"> dispatchers for every request
669 and passes them a L<Mojolicious::Controller> object.
670  
671 =head2 get
672  
673 my $route = $app->get('/:foo' => sub ($c) {...});
674  
675 Generate route with L<Mojolicious::Routes::Route/"get"> on L</"routes">, takes the same arguments.
676  
677 =head2 handler
678  
679 $app->handler(Mojo::Transaction::HTTP->new);
680 $app->handler(Mojolicious::Controller->new);
681  
682 Sets up the default controller and emits the L</"around_dispatch"> hook for every request.
683  
684 =head2 helper
685  
686 $app->helper(foo => sub {...});
687  
688 Add or replace a helper that will be available as a method of the controller object and the application object, as well
689 as a function in C<ep> templates. For a full list of helpers that are available by default see
690 L<Mojolicious::Plugin::DefaultHelpers> and L<Mojolicious::Plugin::TagHelpers>.
691  
692 # Helper
693 $app->helper(cache => sub { state $cache = {} });
694  
695 # Application
696 $app->cache->{foo} = 'bar';
697 my $result = $app->cache->{foo};
698  
699 # Controller
700 $c->cache->{foo} = 'bar';
701 my $result = $c->cache->{foo};
702  
703 # Template
704 % cache->{foo} = 'bar';
705 %= cache->{foo}
706  
707 =head2 hook
708  
709 $app->hook(after_dispatch => sub {...});
710  
711 Extend L<Mojolicious> with hooks, which allow code to be shared with all requests indiscriminately, for a full list of
712 available hooks see L</"HOOKS">.
713  
714 # Dispatchers will not run if there's already a response code defined
715 $app->hook(before_dispatch => sub ($c) {
716 $c->render(text => 'Skipped static file server and router!')
717 if $c->req->url->path->to_route =~ /do_not_dispatch/;
718 });
719  
720 =head2 new
721  
722 my $app = Mojolicious->new;
723 my $app = Mojolicious->new(moniker => 'foo_bar');
724 my $app = Mojolicious->new({moniker => 'foo_bar'});
725  
726 Construct a new L<Mojolicious> application and call L</"startup">. Will automatically detect your home directory. Also
727 sets up the renderer, static file server, a default set of plugins and an L</"around_dispatch"> hook with the default
728 exception handling.
729  
730 =head2 options
731  
732 my $route = $app->options('/:foo' => sub ($c) {...});
733  
734 Generate route with L<Mojolicious::Routes::Route/"options"> on L</"routes">, takes the same arguments.
735  
736 =head2 patch
737  
738 my $route = $app->patch('/:foo' => sub ($c) {...});
739  
740 Generate route with L<Mojolicious::Routes::Route/"patch"> on L</"routes">, takes the same arguments.
741  
742 =head2 plugin
743  
744 $app->plugin('some_thing');
745 $app->plugin('some_thing', foo => 23);
746 $app->plugin('some_thing', {foo => 23});
747 $app->plugin('SomeThing');
748 $app->plugin('SomeThing', foo => 23);
749 $app->plugin('SomeThing', {foo => 23});
750 $app->plugin('MyApp::Plugin::SomeThing');
751 $app->plugin('MyApp::Plugin::SomeThing', foo => 23);
752 $app->plugin('MyApp::Plugin::SomeThing', {foo => 23});
753  
754 Load a plugin, for a full list of example plugins included in the L<Mojolicious> distribution see
755 L<Mojolicious::Plugins/"PLUGINS">.
756  
757 =head2 post
758  
759 my $route = $app->post('/:foo' => sub ($c) {...});
760  
761 Generate route with L<Mojolicious::Routes::Route/"post"> on L</"routes">, takes the same arguments.
762  
763 =head2 put
764  
765 my $route = $app->put('/:foo' => sub ($c) {...});
766  
767 Generate route with L<Mojolicious::Routes::Route/"put"> on L</"routes">, takes the same arguments.
768  
769 =head2 query
770  
771 my $route = $app->query('/:foo' => sub ($c) {...});
772  
773 Generate route with L<Mojolicious::Routes::Route/"query"> on L</"routes">, takes the same arguments.
774  
775 =head2 server
776  
777 $app->server(Mojo::Server->new);
778  
779 Emits the L</"before_server_start"> hook.
780  
781 =head2 start
782  
783 $app->start;
784 $app->start(@ARGV);
785  
786 Start the command line interface for your application. For a full list of commands that are available by default see
787 L<Mojolicious::Commands/"COMMANDS">. Note that the options C<-h>/C<--help>, C<--home> and C<-m>/C<--mode>, which are
788 shared by all commands, will be parsed from C<@ARGV> during compile time.
789  
790 # Always start daemon
791 $app->start('daemon', '-l', 'http://*:8080');
792  
793 =head2 startup
794  
795 $app->startup;
796  
797 This is your main hook into the application, it will be called at application startup. Meant to be overloaded in a
798 subclass.
799  
800 sub startup ($self) {...}
801  
802 =head2 under
803  
804 my $route = $app->under('/:foo' => sub ($c) {...});
805  
806 Generate route with L<Mojolicious::Routes::Route/"under"> on L</"routes">, takes the same arguments.
807  
808 =head2 warmup
809  
810 $app->warmup;
811  
812 Preload classes from L</"preload_namespaces"> for future use.
813  
814 =head2 websocket
815  
816 my $route = $app->websocket('/:foo' => sub ($c) {...});
817  
818 Generate route with L<Mojolicious::Routes::Route/"websocket"> on L</"routes">, takes the same arguments.
819  
820 =head1 HELPERS
821  
822 In addition to the L</"ATTRIBUTES"> and L</"METHODS"> above you can also call helpers on L<Mojolicious> objects. This
823 includes all helpers from L<Mojolicious::Plugin::DefaultHelpers> and L<Mojolicious::Plugin::TagHelpers>. Note that
824 application helpers are always called with a new default controller object, so they can't depend on or change
825 controller state, which includes request, response and stash.
826  
827 # Call helper
828 say $app->dumper({foo => 'bar'});
829  
830 # Longer version
831 say $app->build_controller->helpers->dumper({foo => 'bar'});
832  
833 =head1 BUNDLED FILES
834  
835 The L<Mojolicious> distribution includes a few files with different licenses that have been bundled for internal use.
836  
837 =head2 Mojolicious Artwork
838  
839 Copyright (C) 2010-2025, Sebastian Riedel.
840  
841 Licensed under the CC-SA License, Version 4.0 L<http://creativecommons.org/licenses/by-sa/4.0>.
842  
843 =head2 highlight.js
844  
845 Copyright (C) 2006, Ivan Sagalaev.
846  
847 Licensed under the BSD License, L<https://github.com/highlightjs/highlight.js/blob/master/LICENSE>.
848  
849 =head2 Bootstrap
850  
851 Copyright 2011-2020 The Bootstrap Authors.
852 Copyright 2011-2020 Twitter, Inc.
853  
854 Licensed under the MIT License, L<http://creativecommons.org/licenses/MIT>.
855  
856 =head2 Font Awesome
857  
858 Licensed under the CC-BY License, Version 4.0 L<https://creativecommons.org/licenses/by/4.0/> and SIL OFL, Version 1.1
859 L<https://opensource.org/licenses/OFL-1.1>.
860  
861 =head1 CODE NAMES
862  
863 Every major release of L<Mojolicious> has a code name, these are the ones that have been used in the past.
864  
865 9.0, C<Waffle> (U+1F9C7)
866  
867 8.0, C<Supervillain> (U+1F9B9)
868  
869 7.0, C<Doughnut> (U+1F369)
870  
871 6.0, C<Clinking Beer Mugs> (U+1F37B)
872  
873 5.0, C<Tiger Face> (U+1F42F)
874  
875 4.0, C<Top Hat> (U+1F3A9)
876  
877 3.0, C<Rainbow> (U+1F308)
878  
879 2.0, C<Leaf Fluttering In Wind> (U+1F343)
880  
881 1.0, C<Snowflake> (U+2744)
882  
883 =head1 SPONSORS
884  
885 =over 2
886  
887 =item
888  
889 L<Stix|https://stix.no> sponsored the creation of the Mojolicious logo (designed by Nicolai Graesdal) and transferred
890 its copyright to Sebastian Riedel.
891  
892 =item
893  
894 Some of the work on this distribution has been sponsored by L<The Perl Foundation|https://www.perlfoundation.org>.
895  
896 =back
897  
898 =head1 AUTHORS
899  
900 L<Mojolicious> is an open source project that relies on the tireless support of its contributors.
901  
902 =head2 Project Founder
903  
904 Sebastian Riedel, C<kraih@mojolicious.org>
905  
906 =head2 Core Developers
907  
908 Current voting members of the core team in alphabetical order:
909  
910 =over 2
911  
912 CandyAngel, C<candyangel@mojolicious.org>
913  
914 Christopher Rasch-Olsen Raa, C<christopher@mojolicious.org>
915  
916 Dan Book, C<grinnz@mojolicious.org>
917  
918 Jan Henning Thorsen, C<batman@mojolicious.org>
919  
920 Joel Berger, C<jberger@mojolicious.org>
921  
922 Marcus Ramberg, C<marcus@mojolicious.org>
923  
924 =back
925  
926 The following members of the core team are currently on hiatus:
927  
928 =over 2
929  
930 Abhijit Menon-Sen, C<ams@cpan.org>
931  
932 Glen Hinkle, C<tempire@cpan.org>
933  
934 =back
935  
936 =head2 Contributors
937  
938 In alphabetical order:
939  
940 =over 2
941  
942 Adam Kennedy
943  
944 Adriano Ferreira
945  
946 Al Newkirk
947  
948 Alex Efros
949  
950 Alex Salimon
951  
952 Alexander Karelas
953  
954 Alexander Kuehne
955  
956 Alexey Likhatskiy
957  
958 Anatoly Sharifulin
959  
960 Andre Parker
961  
962 Andre Vieth
963  
964 Andreas Guldstrand
965  
966 Andreas Jaekel
967  
968 Andreas Koenig
969  
970 Andrew Fresh
971  
972 Andrew Nugged
973  
974 Andrey Khozov
975  
976 Andrey Kuzmin
977  
978 Andy Grundman
979  
980 Andy Lester
981  
982 Aristotle Pagaltzis
983  
984 Ashley Dev
985  
986 Ask Bjoern Hansen
987  
988 Audrey Tang
989  
990 Ben Tyler
991  
992 Ben van Staveren
993  
994 Benjamin Erhart
995  
996 Bernhard Graf
997  
998 Breno G. de Oliveira
999  
1000 Brett Watson
1001  
1002 Brian Duggan
1003  
1004 Brian Medley
1005  
1006 Burak Gursoy
1007  
1008 Ch Lamprecht
1009  
1010 Charlie Brady
1011  
1012 Chas. J. Owens IV
1013  
1014 Chase Whitener
1015  
1016 Chris Scheller
1017  
1018 Christian Hansen
1019  
1020 chromatic
1021  
1022 Curt Tilmes
1023  
1024 Daniel Kimsey
1025  
1026 Daniel Mantovani
1027  
1028 Danijel Tasov
1029  
1030 Dagfinn Ilmari Manns�ker
1031  
1032 Danny Thomas
1033  
1034 David Davis
1035  
1036 David Webb
1037  
1038 Diego Kuperman
1039  
1040 Dmitriy Shalashov
1041  
1042 Dmitry Konstantinov
1043  
1044 Dominik Jarmulowicz
1045  
1046 Dominique Dumont
1047  
1048 Dotan Dimet
1049  
1050 Douglas Christopher Wilson
1051  
1052 Elmar S. Heeb
1053  
1054 Ettore Di Giacinto
1055  
1056 Eugen Konkov
1057  
1058 Eugene Toropov
1059  
1060 Flavio Poletti
1061  
1062 Gisle Aas
1063  
1064 Graham Barr
1065  
1066 Graham Knop
1067  
1068 Heiko Jansen
1069  
1070 Henry Tang
1071  
1072 Hernan Lopes
1073  
1074 Hideki Yamamura
1075  
1076 Hiroki Toyokawa
1077  
1078 Ian Goodacre
1079  
1080 Ilya Chesnokov
1081  
1082 Ilya Rassadin
1083  
1084 James Duncan
1085  
1086 Jan Jona Javorsek
1087  
1088 Jan Schmidt
1089  
1090 Jaroslav Muhin
1091  
1092 Jesse Vincent
1093  
1094 Johannes Plunien
1095  
1096 John Kingsley
1097  
1098 Jonathan Yu
1099  
1100 Josh Leder
1101  
1102 Kamen Naydenov
1103  
1104 Karen Etheridge
1105  
1106 Kazuhiro Shibuya
1107  
1108 Kevin Old
1109  
1110 Kitamura Akatsuki
1111  
1112 Klaus S. Madsen
1113  
1114 Knut Arne Bjorndal
1115  
1116 Lars Balker Rasmussen
1117  
1118 Lee Johnson
1119  
1120 Leon Brocard
1121  
1122 Leon Timmermans
1123  
1124 Lukas Mai
1125  
1126 Magnus Holm
1127  
1128 Maik Fischer
1129  
1130 Mark Fowler
1131  
1132 Mark Grimes
1133  
1134 Mark Stosberg
1135  
1136 Martin McGrath
1137  
1138 Marty Tennison
1139  
1140 Matt S Trout
1141  
1142 Matthew Lineen
1143  
1144 Maksym Komar
1145  
1146 Maxim Vuets
1147  
1148 Michael Gregorowicz
1149  
1150 Michael Harris
1151  
1152 Michael Jemmeson
1153  
1154 Mike Magowan
1155  
1156 Mirko Westermeier
1157  
1158 Mons Anderson
1159  
1160 Moritz Lenz
1161  
1162 Neil Watkiss
1163  
1164 Nic Sandfield
1165  
1166 Niels Peter Roest
1167  
1168 Nils Diewald
1169  
1170 Oleg Zhelo
1171  
1172 Oliver Kurz
1173  
1174 Olivier Mengue
1175  
1176 Pascal Gaudette
1177  
1178 Paul Evans
1179  
1180 Paul Robins
1181  
1182 Paul Tomlin
1183  
1184 Pavel Shaydo
1185  
1186 Pedro Melo
1187  
1188 Peter Edwards
1189  
1190 Pierre-Yves Ritschard
1191  
1192 Piotr Roszatycki
1193  
1194 Quentin Carbonneaux
1195  
1196 Rafal Pocztarski
1197  
1198 Randal Schwartz
1199  
1200 Rawley Fowler
1201  
1202 Richard Elberger
1203  
1204 Rick Delaney
1205  
1206 Robert Hicks
1207  
1208 Robert Rothenberg
1209  
1210 Robin Lee
1211  
1212 Roland Lammel
1213  
1214 Roy Storey
1215  
1216 Ryan Jendoubi
1217  
1218 Salvador Fandino
1219  
1220 Santiago Zarate
1221  
1222 Sascha Kiefer
1223  
1224 Scott Wiersdorf
1225  
1226 Sebastian Paaske Torholm
1227  
1228 Sergey Zasenko
1229  
1230 Simon Bertrang
1231  
1232 Simone Tampieri
1233  
1234 Shoichi Kaji
1235  
1236 Shu Cho
1237  
1238 Skye Shaw
1239  
1240 Stanis Trendelenburg
1241  
1242 Stefan Adams
1243  
1244 Steffen Ullrich
1245  
1246 Stephan Kulow
1247  
1248 Stephane Este-Gracias
1249  
1250 Stevan Little
1251  
1252 Steve Atkins
1253  
1254 Tatsuhiko Miyagawa
1255  
1256 Terrence Brannon
1257  
1258 Tianon Gravi
1259  
1260 Tomas Znamenacek
1261  
1262 Tudor Constantin
1263  
1264 Ulrich Habel
1265  
1266 Ulrich Kautz
1267  
1268 Uwe Voelker
1269  
1270 Veesh Goldman
1271  
1272 Viacheslav Tykhanovskyi
1273  
1274 Victor Engmark
1275  
1276 Viliam Pucik
1277  
1278 Wes Cravens
1279  
1280 William Lindley
1281  
1282 Yaroslav Korshak
1283  
1284 Yuki Kimoto
1285  
1286 Zak B. Elep
1287  
1288 Zoffix Znet
1289  
1290 =back
1291  
1292 =head1 COPYRIGHT AND LICENSE
1293  
1294 Copyright (C) 2008-2025, Sebastian Riedel and others.
1295  
1296 This program is free software, you can redistribute it and/or modify it under the terms of the Artistic License version
1297 2.0.
1298  
1299 =head1 SEE ALSO
1300  
1301 L<https://github.com/mojolicious/mojo>, L<Mojolicious::Guides>, L<https://mojolicious.org>.
1302  
1303 =cut
« Mojolicious/Command/Author/generate/plugin.pm ↑ Summary Mojo/DynamicMethods.pm »