1Dancer::Cookbook(3) User Contributed Perl Documentation Dancer::Cookbook(3)
2
6 Dancer::Cookbook - a quick-start guide to the Dancer web framework
7
9 version 1.3521
10
12 A quick-start guide with examples to get you up and running with the
13 Dancer web framework.
14
16 Your first Dancer web app
17 Dancer has been designed to be easy to work with. It's trivial to write
18 a simple web app, but still has the power to work with larger projects.
19 To start with, let's make an incredibly simple "Hello World" example:
20 #!/usr/bin/perl
22 use Dancer;
24 get '/hello/:name' => sub {
26 return "Why, hello there " . params->{name};
27 };
28 dance;
30 Yes, the above is a fully-functioning web app; running that script will
32 launch a webserver listening on the default port (3000). Now you can
33 make a request
34 $ curl http://localhost:3000/hello/Bob
36 Why, hello there Bob
37 (or the name of the machine you ran it on, if it's not your local
39 system), and it will say hello. The ":name" part is a named parameter
40 within the route specification whose value is made available through
41 "params" - more on that later.
42 Note that you don't need to use the "strict" and "warnings" pragma,
44 they are already loaded by Dancer. (If you don't want the "warnings"
45 pragma (which can lead to undesired warnings about use of undef values,
46 for example), then set the import_warnings setting to a false value.
47 Starting a Dancer project
49 The first simple example is fine for trivial projects, but for anything
50 more complex you'll want a more maintainable solution - enter the
51 "dancer" helper script, which will build the framework of your
52 application with a single command:
53 $ dancer -a mywebapp
55 + mywebapp
56 + mywebapp/bin
57 + mywebapp/bin/app.pl
58 + mywebapp/config.yml
59 + mywebapp/environments
60 + mywebapp/environments/development.yml
61 + mywebapp/environments/production.yml
62 + mywebapp/views
63 + mywebapp/views/index.tt
64 + mywebapp/views/layouts
65 + mywebapp/views/layouts/main.tt
66 + mywebapp/MANIFEST.SKIP
67 + mywebapp/lib
68 + mywebapp/lib/mywebapp.pm
69 + mywebapp/public
70 + mywebapp/public/css
71 + mywebapp/public/css/style.css
72 + mywebapp/public/css/error.css
73 + mywebapp/public/images
74 + mywebapp/public/500.html
75 + mywebapp/public/404.html
76 + mywebapp/public/dispatch.fcgi
77 + mywebapp/public/dispatch.cgi
78 + mywebapp/public/javascripts
79 + mywebapp/public/javascripts/jquery.min.js
80 + mywebapp/t
81 + mywebapp/t/002_index_route.t
82 + mywebapp/t/001_base.t
83 + mywebapp/Makefile.PL
84 As you can see, it creates a directory named after the name of the app,
86 along with a configuration file, a views directory (where your
87 templates and layouts will live), an environments directory (where
88 environment-specific settings live), a module containing the actual
89 guts of your application, a script to start it - or to run your web app
90 via Plack/PSGI - more on that later.
91
93 Declaring routes
94 To control what happens when a web request is received by your webapp,
95 you'll need to declare "routes". A route declaration indicates for
96 which HTTP method(s) it is valid, the path it matches (e.g. /foo/bar),
97 and a coderef to execute, which returns the response.
98 get '/hello/:name' => sub {
100 return "Hi there " . params->{name};
101 };
102 The above route specifies that, for GET requests to '/hello/...', the
104 code block provided should be executed.
105 Handling multiple HTTP request methods
107 Routes can use "any" to match all, or a specified list of HTTP methods.
108 The following will match any HTTP request to the path /myaction:
110 any '/myaction' => sub {
112 # code
113 }
114 The following will match GET or POST requests to /myaction:
116 any ['get', 'post'] => '/myaction' => sub {
118 # code
119 };
120 For convenience, any route which matches GET requests will also match
122 HEAD requests.
123 Retrieving request parameters
125 The params keyword returns a hashref of request parameters; these will
126 be parameters supplied on the query string, within the path itself
127 (with named placeholders), and, for HTTP POST requests, the content of
128 the POST body.
129 Named parameters in route path declarations
131 As seen above, you can use ":somename" in a route's path to capture
132 part of the path; this will become available by calling params.
133 So, for a web app where you want to display information on a company,
135 you might use something like:
136 get '/company/view/:companyid' => sub {
138 my $company_id = params->{companyid};
139 # Look up the company and return appropriate page
140 };
141 Wildcard path matching and splat
143 You can also declare wildcards in a path, and retrieve the values they
144 matched with the splat keyword:
145 get '/*/*' => sub {
147 my ($action, $id) = splat;
148 if (my $action eq 'view') {
149 return display_item($id);
150 } elsif ($action eq 'delete') {
151 return delete_item($id);
152 } else {
153 status 'not_found';
154 return "What?";
155 }
156 };
157 Before hooks - processed before a request
159 A before hook declares code which should be handled before a request is
160 passed to the appropriate route.
161 hook 'before' => sub {
163 var note => 'Hi there';
164 request->path_info('/foo/oversee')
165 };
166 get '/foo/*' => sub {
168 my ($match) = splat; # 'oversee';
169 vars->{note}; # 'Hi there'
170 };
171 The above declares a before hook which uses "var" to set a variable
173 which will later be available within the route handler, then amends the
174 path of the request to "/foo/oversee"; this means that, whatever path
175 was requested, it will be treated as though the path requested was
176 "/foo/oversee".
177 Default route
179 In case you want to avoid a 404 error, or handle multiple routes in the
180 same way and you don't feel like configuring all of them, you can set
181 up a default route handler.
182 The default route handler will handle any request that doesn't get
184 served by any other route.
185 All you need to do is set up the following route as the last route:
187 any qr{.*} => sub {
189 status 'not_found';
190 template 'special_404', { path => request->path };
191 };
192 Then you can set up the template as such:
194 You tried to reach <% path %>, but it is unavailable at the moment.
196 Please try again or contact us at our email at <...>.
198 Using the auto_page feature for automatic route creation
200 For simple "static" pages, you can simply enable the "auto_page" config
201 setting; this means that you need not declare a route handler for those
202 pages; if a request is for "/foo/bar", Dancer will check for a matching
203 view (e.g. "/foo/bar.tt" and render it with the default layout etc if
204 found. For full details, see the documentation for the auto_page
205 setting.
206 Why should I use the Ajax plugin
208 As an Ajax query is just an HTTP query, it's similar to a GET or POST
209 route. You may ask yourself why you may want to use the "ajax" keyword
210 (from the Dancer::Plugin::Ajax plugin) instead of a simple "get".
211 Let's say you have a path like '/user/:user' in your application. You
213 may want to be able to serve this page, with a layout and HTML content.
214 But you may also want to be able to call this same url from a
215 javascript query using Ajax.
216 So, instead of having the following code:
218 get '/user/:user' => sub {
220 if (request->is_ajax) {
221 # create xml, set headers to text/xml, blablabla
222 header('Content-Type' => 'text/xml');
223 header('Cache-Control' => 'no-store, no-cache, must-revalidate');
224 to_xml({...})
225 }else{
226 template users, {....}
227 }
228 };
229 you can have
231 get '/user/:user' => sub {
233 template users, {...}
234 }
235 and
237 ajax '/user/:user' => sub {
239 to_xml({...}, RootName => undef);
240 }
241 Because it's an Ajax query you know you need to return XML content, so
243 the content type of the response is set for you.
244 Using the prefix feature to split your application
246 For better maintainability you may want to separate some of your
247 application components to different packages. Let's say we have a
248 simple web app with an admin section, and want to maintain this in a
249 different package:
250 package myapp;
252 use Dancer ':syntax';
253 use myapp::admin;
254 prefix undef;
256 get '/' => sub {...};
258 1;
260 package myapp::admin;
262 use Dancer ':syntax';
263 prefix '/admin';
265 get '/' => sub {...};
267 1;
269 The following routes will be generated for us:
271 - get /
273 - get /admin/
274 - head /
275 - head /admin/
276
278 Handling sessions
279 It's common to want to use sessions to give your web applications
280 state; for instance, allowing a user to log in, creating a session, and
281 checking that session on subsequent requests.
282 To make use of sessions you must first enable the session engine. Pick
284 the session engine you want to use, then declare it in your config
285 file:
286 session: Simple
288 The Dancer::Session::Simple backend implements very simple in-memory
290 session storage. This will be fast and useful for testing, but
291 sessions do not persist between restarts of your app.
292 You can also use the Dancer::Session::YAML backend included with
294 Dancer, which stores session data on disc in YAML files (since YAML is
295 a nice human-readable format, it makes inspecting the contents of
296 sessions a breeze):
297 session: YAML
299 Or, to enable session support from within your code,
301 set session => 'YAML';
303 (Controlling settings is best done from your config file, though).
305 'YAML' in the example is the session backend to use; this is shorthand
306 for Dancer::Session::YAML. There are other session backends you may
307 wish to use, for instance Dancer::Session::Memcache, but the YAML
308 backend is a simple and easy to use example which stores session data
309 in a YAML file in sessions).
310 You can then use the session keyword to manipulate the session:
312 Storing data in the session
314 Storing data in the session is as easy as:
316 session varname => 'value';
318 Retrieving data from the session
320 Retrieving data from the session is as easy as:
322 session('varname')
324 Or, alternatively,
326 session->{varname}
328 Controlling where sessions are stored
330 For disc-based session back ends like Dancer::Session::YAML,
332 Dancer::Session::Storable etc, session files are written to the session
333 dir specified by the "session_dir" setting, which defaults to
334 "appdir/sessions".
335 If you need to control where session files are created, you can do so
337 quickly and easily within your config file. For example:
338 session_dir: /tmp/dancer-sessions
340 If the directory you specify does not exist, Dancer will attempt to
342 create it for you.
343 Destroying a session
345 When you're done with your session, you can destroy it:
347 session->destroy
349 Sessions and logging in
351 A common requirement is to check the user is logged in, and, if not,
352 require them to log in before continuing.
353 This can easily be handled with a before hook to check their session:
355 hook 'before' => sub {
357 if (! session('user') && request->path_info !~ m{^/login}) {
358 var requested_path => request->path_info;
359 request->path_info('/login');
360 }
361 };
362 get '/login' => sub {
364 # Display a login page; the original URL they requested is available as
365 # vars->{requested_path}, so could be put in a hidden field in the form
366 template 'login', { path => vars->{requested_path} };
367 };
368 post '/login' => sub {
370 # Validate the username and password they supplied
371 if (params->{user} eq 'bob' && params->{pass} eq 'letmein') {
372 session user => params->{user};
373 redirect params->{path} || '/';
374 } else {
375 redirect '/login?failed=1';
376 }
377 };
378 In your login page template, you'll want a text field named user, a
380 password field named pass, and a hidden field named path, which will be
381 populated with the path originally requested, so that it's sent back in
382 the POST submission, and can be used by the post route to redirect
383 onwards to the page originally requested once you're logged in.
384 Of course you'll probably want to validate your users against a
386 database table, or maybe via IMAP/LDAP/SSH/POP3/local system accounts
387 via PAM etc. Authen::Simple is probably a good starting point here!
388 A simple working example of handling authentication against a database
390 table yourself (using Dancer::Plugin::Database which provides the
391 "database" keyword, and Crypt::SaltedHash to handle salted hashed
392 passwords (well, you wouldn't store your users' passwords in the clear,
393 would you?)) follows:
394 post '/login' => sub {
396 my $user = database->quick_select('users',
397 { username => params->{user} }
398 );
399 if (!$user) {
400 warning "Failed login for unrecognised user " . params->{user};
401 redirect '/login?failed=1';
402 } else {
403 if (Crypt::SaltedHash->validate($user->{password}, params->{pass}))
404 {
405 debug "Password correct";
406 # Logged in successfully
407 session user => $user;
408 redirect params->{path} || '/';
409 } else {
410 debug("Login failed - password incorrect for " . params->{user});
411 redirect '/login?failed=1';
412 }
413 }
414 };
415 Retrieve complete hash stored in session
417 Get complete hash stored in session:
419 my $hash = session;
421
423 Using templates - views and layouts
424 Returning plain content is all well and good for examples or trivial
425 apps, but soon you'll want to use templates to maintain separation
426 between your code and your content. Dancer makes this easy.
427 Your route handlers can use the template keyword to render templates.
429 Views
431 It's possible to render the action's content with a template, this is
433 called a view. The `appdir/views' directory is the place where views
434 are located.
435 You can change this location by changing the setting 'views'.
437 By default, the internal template engine Dancer::Template::Simple is
439 used, but you may want to upgrade to Template::Toolkit. If you do so,
440 you have to enable this engine in your settings as explained in
441 Dancer::Template::TemplateToolkit. If you do so, you'll also have to
442 import the Template module in your application code.
443 Note that, by default, Dancer configures the Template::Toolkit engine
445 to use "<% %"> brackets instead of its default "[% %]" brackets. You
446 can change this by using the following in your config file:
447 template: template_toolkit
449 engines:
451 template_toolkit:
452 start_tag: '[%'
453 stop_tag: '%]'
454 All views must have a '.tt' extension. This may change in the future.
456 To render a view just call the "template|Dancer/template" keyword at
458 the end of the action by giving the view name and the HASHREF of tokens
459 to interpolate in the view (note that for convenience, the request,
460 session, params and vars are automatically accessible in the view,
461 named "request", "session", "params" and "vars"). For example:
462 hook 'before' => sub { var time => scalar(localtime) };
464 get '/hello/:name' => sub {
466 my $name = params->{name};
467 template 'hello.tt', { name => $name };
468 };
469 The template 'hello.tt' could contain, for example:
471 <p>Hi there, <% name %>!</p>
473 <p>You're using <% request.user_agent %></p>
474 <% IF session.username %>
475 <p>You're logged in as <% session.username %>
476 <% END %>
477 It's currently <% vars.time %>
478 For a full list of the tokens automatically added to your template
480 (like "session", "request" and "vars", refer to
481 Dancer::Template::Abstract).
482 Layouts
484 A layout is a special view, located in the 'layouts' directory (inside
486 the views directory) which must have a token named 'content'. That
487 token marks the place to render the action view. This lets you define a
488 global layout for your actions, and have each individual view contain
489 only the specific content. This is a good thing to avoid lots of
490 needless duplication of HTML :)
491 Here is an example of a layout: "views/layouts/main.tt" :
493 <html>
495 <head>...</head>
496 <body>
497 <div id="header">
498 ...
499 </div>
500 <div id="content">
502 <% content %>
503 </div>
504 </body>
506 </html>
507 You can tell your app which layout to use with "layout: name" in the
509 config file, or within your code:
510 set layout => 'main';
512 You can control which layout to use (or whether to use a layout at all)
514 for a specific request without altering the layout setting by passing
515 an options hashref as the third param to the template keyword:
516 template 'index.tt', {}, { layout => undef };
518 If your application is not mounted under root (/), you can use a
520 before_template_render hook instead of hardcoding the path to your
521 application for your css, images and javascript:
522 hook 'before_template_render' => sub {
524 my $tokens = shift;
525 $tokens->{uri_base} = request->base->path;
526 };
527 Then in your layout, modify your css inclusion as follows:
529 <link rel="stylesheet" href="<% uri_base %>/css/style.css" />
531 From now on, you can mount your application wherever you want, without
533 any further modification of the css inclusion
534 template and unicode
536 If you use Plack and have some unicode problem with your Dancer
538 application, don't forget to check if you have set your template engine
539 to use unicode, and set the default charset to UTF-8. So, if you are
540 using template toolkit, your config.yml will look like this:
541 charset: UTF-8
543 engines:
544 template_toolkit:
545 ENCODING: utf8
546 TT's WRAPPER directive in Dancer (META variables, SETs)
548 Dancer already provides a WRAPPER-like ability, which we call a
550 "layout". The reason we do not use TT's WRAPPER (which also makes it
551 incompatible with Dancer) is because not all template systems support
552 it. Actually, most don't.
553 However, you might want to use it, and be able to define META variables
555 and regular Template::Toolkit variables.
556 These few steps will get you there:
558 • Disable the layout in Dancer
560 You can do this by simply commenting (or removing) the "layout"
562 configuration in the config.yml file.
563 • Use Template Toolkit template engine
565 Change the configuration of the template to Template Toolkit:
567 # in config.yml
569 template: "template_toolkit"
570 • Tell the Template Toolkit engine who's your wrapper
572 # in config.yml
574 # ...
575 engines:
576 template_toolkit:
577 WRAPPER: layouts/main.tt
578 Done! Everything will work fine out of the box, including variables and
580 META variables.
581
583 Configuration and environments
584 Configuring a Dancer application can be done in many ways. The easiest
585 one (and maybe the dirtiest) is to put all your settings statements at
586 the top of your script, before calling the dance() method.
587 Other ways are possible. You can define all your settings in the file
589 `appdir/config.yml'. For this, you must have installed the YAML module,
590 and of course, write the config file in YAML.
591 That's better than the first option, but it's still not perfect as you
593 can't switch easily from one environment to another without rewriting
594 the config.yml file.
595 The better way is to have one config.yml file with default global
597 settings, like the following:
598 # appdir/config.yml
600 logger: 'file'
601 layout: 'main'
602 And then write as many environment files as you like in
604 "appdir/environments". That way the appropriate environment config
605 file will be loaded according to the running environment (if none is
606 specified, it will be 'development').
607 Note that you can change the running environment using the
609 "--environment" command line switch.
610 Typically, you'll want to set the following values in a development
612 config file:
613 # appdir/environments/development.yml
615 log: 'debug'
616 startup_info: 1
617 show_errors: 1
618 And in a production one:
620 # appdir/environments/production.yml
622 log: 'warning'
623 startup_info: 0
624 show_errors: 0
625 Accessing configuration information from your app
627 A Dancer application can use the 'config' keyword to easily access the
628 settings within its config file, for instance:
629 get '/appname' => sub {
631 return "This is " . config->{appname};
632 };
633 This makes keeping your application's settings all in one place simple
635 and easy. You shouldn't need to worry about implementing all that
636 yourself :)
637 Accessing configuration information from a separate script
639 You may well want to access your webapp's configuration from outside
640 your webapp. You could, of course, use the YAML module of your choice
641 and load your webapps's config.yml, but chances are that this is not
642 convenient.
643 Use Dancer instead. Without any ado, magic or too big jumps, you can
645 use the values from config.yml and some additional default values:
646 # bin/script1.pl
648 use Dancer ':script';
649 print "template:".config->{template}."\n"; #simple
650 print "log:".config->{log}."\n"; #undef
651 Note that config->{log} should result in an undef error on a default
653 scaffold since you did not load the environment and in the default
654 scaffold log is defined in the environment and not in config.yml. Hence
655 undef.
656 If you want to load an environment you need to tell Dancer where to
658 look for it. One way to do so, is to tell Dancer where the webapp
659 lives. From there Dancer deduces where the config.yml file is
660 (typically $webapp/config.yml).
661 # bin/script2.pl
663 use FindBin;
664 use Cwd qw/realpath/;
665 use Dancer ':script';
666 #tell the Dancer where the app lives
668 my $appdir=realpath( "$FindBin::Bin/..");
669 Dancer::Config::setting('appdir',$appdir);
671 Dancer::Config::load();
672 #getter
674 print "environment:".config->{environment}."\n"; #development
675 print "log:".config->{log}."\n"; #value from development environment
676 By default Dancer loads development environment (typically
678 $webapp/environment/development.yml). In contrast to the example
679 before, you do have a value from the development environment
680 (environment/development.yml) now. Also note that in the above example
681 Cwd and FindBin are used. They are likely to be already loaded by
682 Dancer anyways, so it's not a big overhead. You could just as well hand
683 over a simple path for the app if you like that better, e.g.:
684 Dancer::Config::setting('appdir','/path/to/app/dir');
686 If you want to load an environment other than the default, try this:
688 # bin/script2.pl
690 use Dancer ':script';
691 #tell the Dancer where the app lives
693 Dancer::Config::setting('appdir','/path/to/app/dir');
694 #which environment to load
696 config->{environment}='production';
697 Dancer::Config::load();
699 #getter
701 print "log:".config->{log}."\n"; #has value from production environment
702 By the way, you not only get values, you can also set values
704 straightforward like we do above with
705 config->{environment}='production'. Of course, this value does not get
706 written in any file; it only lives in memory and your webapp doesn't
707 have access to it, but you can use it inside your script.
708 If you don't want to make your script environment-specific, or add
710 extra arguments to it, you can also set the environment using a shell
711 variable, DANCER_ENVIRONMENT. See also
712 "DANCER_CONFDIR-and-DANCER_ENVDIR" in Dancer::Config
713 Logging
715 Configuring logging
716 It's possible to log messages generated by the application and by
718 Dancer itself.
719 To start logging, select the logging engine you wish to use with the
721 "logger" setting; Dancer includes built-in log engines named "file" and
722 "console", which log to a logfile and to the console respectively.
723 To enable logging to a file, add the following to your config.yml:
725 logger: 'file'
727 Then you can choose which kind of messages you want to actually log:
729 log: 'core' # will log all messages, including messages from
731 # Dancer itself
732 log: 'debug' # will log debug, info, warning and error messages
733 log: 'info' # will log info, warning and error messages
734 log: 'warning' # will log warning and error messages
735 log: 'error' # will log error messages
736 If you're using the "file" logging engine, a directory "appdir/logs"
738 will be created and will host one logfile per environment. The log
739 message contains the time it was written, the PID of the current
740 process, the message and the caller information (file and line).
741 Logging your own messages
743 Just call debug, warning, error or info with your message:
745 debug "This is a debug message from my app.";
747
749 Writing a REST application
750 With Dancer, it's easy to write REST applications. Dancer provides
751 helpers to serialize and deserialize for the following data formats:
752 JSON
754 YAML
755 XML
756 Data::Dumper
757 To activate this feature, you only have to set the "serializer" setting
759 to the format you require, for instance in your config.yml:
760 serializer: JSON
762 Or right in your code:
764 set serializer => 'JSON';
766 From now, all HashRefs or ArrayRefs returned by a route will be
768 serialized to the format you chose, and all data received from POST or
769 PUT requests will be automatically deserialized.
770 get '/hello/:name' => sub {
772 # this structure will be returned to the client as
773 # {"name":"$name"}
774 return {name => params->{name}};
775 };
776 It's possible to let the client choose which serializer he wants to
778 use. For this, use the mutable serializer, and an appropriate
779 serializer will be chosen from the Content-Type header.
780 It's also possible to return a custom error, using the send_error
782 keyword.. When you don't use a serializer, the "send_error" function
783 will take a string as the first parameter (the message), and an
784 optional HTTP code. When using a serializer, the message can be a
785 string, an ArrayRef or a HashRef:
786 get '/hello/:name' => sub {
788 if (...) {
789 send_error("you can't do that");
790 # or
791 send_error({reason => 'access denied', message => "no"});
792 }
793 };
794 The content of the error will be serialized using the appropriate
796 serializer.
797 Deploying your Dancer applications
799 For examples on deploying your Dancer applications including
800 standalone, behind proxy/load-balancing software, and using common web
801 servers including Apache to run via CGI/FastCGI etc, see
802 Dancer::Deployment.
803
805 Plack middlewares
806 If you deploy with Plack and use some Plack middlewares, you can enable
807 them directly from Dancer's configuration files.
808 Generic middlewares
810 To enable middlewares in Dancer, you just have to set the
812 plack_middlewares setting like the following:
813 set plack_middlewares => [
815 [ 'SomeMiddleware' => qw(some options for somemiddleware) ],
816 ];
817 For instance, if you want to enable Plack::Middleware::Debug in your
819 Dancer application, all you have to do is to set "plack_middlewares"
820 like that:
821 set plack_middlewares => [
823 [ 'Debug' => ( 'panels' => [qw(DBITrace Memory Timer)] ) ],
824 ];
825 Of course, you can also put this configuration into your config.yml
827 file, or even in your environment configuration files:
828 # environments/development.yml
830 ...
831 plack_middlewares:
832 -
833 - Debug # first element of the array is the name of the middleware
834 - panels # following elements are the configuration of the middleware
835 -
836 - DBITrace
837 - Memory
838 - Timer
839 Path-based middlewares
841 If you want to set up a middleware for a specific path, you can do that
843 using "plack_middlewares_map". You'll need Plack::App::URLMap to do
844 that.
845 plack_middlewares_map:
847 '/': ['Debug']
848 '/timer': ['Timer'],
849
851 Auto-reloading code
852 When you are furiously hacking on your Dancer app, it might come in
853 handy to have the application auto-detect changes in the code and
854 reload itself.
855 To do that, you can use Plack::Loader::Shotgun,
857 Plack::Middleware::Refresh, or plackup with the "-r" switch:
858 plackup -r bin/appl.pl (will restart the app whenever a file in ./bin or ./lib is modified
860
862 Dancer Core Developers
863
865 This software is copyright (c) 2010 by Alexis Sukrieh.
866 This is free software; you can redistribute it and/or modify it under
868 the same terms as the Perl 5 programming language system itself.
869perl v5.38.0 2023-07-20 Dancer::Cookbook(3)