File Coverage

blib/lib/Mojolicious.pm
Criterion Covered Total %
statement 127 129 98.4
branch 21 22 95.4
condition 15 21 71.4
subroutine 104 104 100.0
pod 13 14 92.8
total 280 290 96.5


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