Provided by: libdancer2-perl_0.400000+dfsg-1_all 
NAME
Dancer2::Manual::Keywords - Dancer2 DSL Keywords
VERSION
version 0.400000
DSL KEYWORDS
Dancer2 provides you with a DSL (Domain-Specific Language) which makes implementing your
web application trivial.
For example, take the following example:
use Dancer2;
get '/hello/:name' => sub {
my $name = route_parameters->get('name');
};
true;
"get" and "route_parameters" are keywords provided by Dancer2.
This document lists all keywords provided by Dancer2. It does not cover additional
keywords which may be provided by loaded plugins; see the documentation for plugins you
use to see which additional keywords they make available to you.
any
Defines a route for multiple HTTP methods at once:
any ['get', 'post'] => '/myaction' => sub {
# code
};
Or even, a route handler that would match any HTTP methods:
any '/myaction' => sub {
# code
};
app
Returns an instance of the app. App is a Dancer2::Core::App.
body_parameters
Returns a Hash::MultiValue object from the body parameters.
post '/' => sub {
my $last_name = body_parameters->get('name');
my @all_names = body_parameters->get_all('name');
};
captures
Returns a reference to a copy of "%+", if there are named captures in the route's regular
expression.
get qr{
/ (?<object> user | ticket | comment )
/ (?<action> delete | find )
/ (?<id> \d+ )
/?$
}x
, sub {
my $value_for = captures;
"i don't want to $value_for->{action} " .
"the $value_for->{object} $value_for->{id} !"
};
cookie
Accesses a cookie value (or sets it). Note that this method will eventually be preferred
over "set_cookie".
cookie lang => "fr-FR"; # set a cookie and return its value
cookie lang => "fr-FR", expires => "2 hours"; # extra cookie info
cookie "lang" # return a cookie value
If your cookie value is a key/value URI string, like
token=ABC&user=foo
"cookie" will only return the first part ("token=ABC") if called in scalar context. Use
list context to fetch them all:
my @values = cookie "name";
cookies
Accesses cookies values, it returns a hashref of Dancer2::Core::Cookie objects:
get '/some_action' => sub {
my $cookie = cookies->{name};
return $cookie->value;
};
In case you have stored something other than a scalar in your cookie:
get '/some_action' => sub {
my $cookie = cookies->{oauth};
my %values = $cookie->value;
return ($values{token}, $values{token_secret});
};
config
Accesses the configuration of the application:
get '/appname' => sub {
return "This is " . config->{appname};
};
content
Sets the content for the response. This only works within a delayed response.
This will crash:
get '/' => sub {
# THIS WILL CRASH
content 'Hello, world!';
};
But this will work just fine:
get '/' => sub {
delayed {
content 'Hello, world!';
...
};
};
content_type
Sets the content-type rendered, for the current route handler:
get '/cat/:txtfile' => sub {
content_type 'text/plain';
# here we can dump the contents of route_parameters->get('txtfile')
};
You can use abbreviations for content types. For instance:
get '/svg/:id' => sub {
content_type 'svg';
# here we can dump the image with id route_parameters->get('id')
};
Note that if you want to change the default content-type for every route, it is easier to
change the "content_type" setting instead.
context
Deprecated. Use app instead.
dance
Alias for the "start" keyword. to_app is preferable.
dancer_app
Returns the app object. See app.
dancer_version
Returns the version of Dancer. If you need the major version, do something like:
int(dancer_version);
or (better), call "dancer_major_version".
dancer_major_version
Returns the major version of Dancer.
debug
Logs a message of debug level:
debug "This is a debug message";
See Dancer2::Core::Role::Logger for details on how to configure where log messages go.
decode_json ($string)
Deserializes a JSON structure from an UTF-8 binary string.
del
Defines a route for HTTP DELETE requests to the given URL:
del '/resource' => sub { ... };
delayed
Stream a response asynchronously. For more information, please see "Delayed responses
(Async/Streaming)" in Dancer2::Manual, or this article
<https://advent.perldancer.org/2020/22> in the 2020 Dancer Advent Calendar.
dirname
Returns the dirname of the path given:
my $dir = dirname($some_path);
done
Close the streaming connection. Can only be called within a streaming response callback.
dsl
Allows access to the DSL within your plugin/application. Is an instance of
Dancer2::Core::DSL.
encode_json ($structure)
Serializes a structure to a UTF-8 binary JSON string.
Calling this function will not trigger the serialization's hooks.
engine
Given a namespace, returns the current engine object
my $template_engine = engine 'template';
my $html = $template_engine->apply_renderer(...);
$template_engine->apply_layout($html);
error
Logs a message of error level:
error "This is an error message";
See Dancer2::Core::Role::Logger for details on how to configure where log messages go.
false
Constant that returns a false value (0).
flush
Flush headers when streaming a response. Necessary when content is called multiple times.
forward
Runs an "internal redirect" of the current route to another route. More formally; when
"forward" is executed, the current dispatch of the route is aborted, the request is
modified (altering query params or request method), and the modified request following a
new route is dispatched again. Any remaining code (route and hooks) from the current
dispatch will never be run and the modified route's dispatch will execute hooks for the
new route normally.
It effectively lets you chain routes together in a clean manner.
get '/demo/articles/:article_id' => sub {
# you'll have to implement this next sub yourself :)
change_the_main_database_to_demo();
forward "/articles/" . route_parameters->get('article_id');
};
In the above example, the users that reach /demo/articles/30 will actually reach
/articles/30 but we've changed the database to demo before.
This is pretty cool because it lets us retain our paths and offer a demo database by
merely going to /demo/....
You'll notice that in the example we didn't indicate whether it was GET or POST. That is
because "forward" chains the same type of route the user reached. If it was a GET, it will
remain a GET (but if you do need to change the method, you can do so; read on below for
details.)
Also notice that "forward" only redirects to a new route. It does not redirect the
requests involving static files. This is because static files are handled before Dancer2
tries to match the request to a route - static files take higher precedence.
This means that you will not be able to "forward" to a static file. If you wish to do so,
you have two options: either redirect (asking the browser to make another request, but to
a file path instead) or use "send_file" to provide a file.
WARNING: Any code after a "forward" is ignored, until the end of the route. It's not
necessary to use "return" with "forward" anymore.
get '/foo/:article_id' => sub {
if ($condition) {
forward "/articles/" . route_parameters->get('article_id');
# The following code WILL NOT BE executed
do_stuff();
}
more_stuff();
};
Note that "forward" doesn't parse GET arguments. So, you can't use something like:
forward '/home?authorized=1';
But "forward" supports an optional hashref with parameters to be added to the actual
parameters:
forward '/home', { authorized => 1 };
Finally, you can add some more options to the "forward" method, in a third argument, also
as a hashref. That option is currently only used to change the method of your request. Use
with caution.
forward '/home', { auth => 1 }, { method => 'POST' };
from_dumper ($structure)
Deserializes a Data::Dumper structure.
from_json ($string, \%options)
Deserializes a JSON structure from a string. You should probably use "decode_json" which
expects a UTF-8 encoded binary string and handles decoding it for you.
from_yaml ($structure)
Deserializes a YAML structure.
get
Defines a route for HTTP GET requests to the given path:
get '/' => sub {
return "Hello world";
}
Note that a route to match HEAD requests is automatically created as well.
halt
Sets a response object with the content given.
When used as a return value from a hook, this breaks the execution flow and renders the
response immediately:
hook before => sub {
if ($some_condition) {
halt("Unauthorized");
# this code is not executed
do_stuff();
}
};
get '/' => sub {
"hello there";
};
WARNING: Issuing a halt immediately exits the current route, and performs the halt. Thus,
any code after a halt is ignored, until the end of the route. Hence, it's not necessary
anymore to use "return" with halt.
header
Deprecated. Use response_header instead.
headers
Deprecated. Use response_headers instead.
hook
Adds a hook at some position. For example :
hook before_serializer => sub {
my $content = shift;
...
};
There can be multiple hooks assigned to a given position, and each will be executed in
order.
See the HOOKS section for a list of available hooks.
info
Logs a message of "info" level:
info "This is an info message";
See Dancer2::Core::Role::Logger for details on how to configure where log messages go.
log
Logs messages at the specified level. For example:
log( debug => "This is a debug message." );
mime
Shortcut to access the instance object of Dancer2::Core::MIME. You should read the
Dancer2::Core::MIME documentation for full details, but the most commonly-used methods are
summarized below:
# set a new mime type
mime->add_type( foo => 'text/foo' );
# set a mime type alias
mime->add_alias( f => 'foo' );
# get mime type for an alias
my $m = mime->for_name( 'f' );
# get mime type for a file (based on extension)
my $m = mime->for_file( "foo.bar" );
# get current defined default mime type
my $d = mime->default;
# set the default mime type using config.yml
# or using the set keyword
set default_mime_type => 'text/plain';
options
Defines a route for HTTP OPTIONS requests to the given URL:
options '/resource' => sub { ... };
param
This method should be called from a route handler. This method is an accessor to the
parameters hash table.
post '/login' => sub {
my $username = param "user";
my $password = param "pass";
# ...
};
We now recommend using one of the specific keywords for parameters ("route_parameters",
"query_parameters", and "body_parameters") instead of "params" or "param".
params
This method should be called from a route handler. It's an alias for the
Dancer2::Core::Request params accessor. It returns a hash (in list context) or a hash
reference (in scalar context) to all defined parameters. Check "param" below to access
quickly to a single parameter value.
post '/login' => sub {
# get all parameters as a single hash
my %all_parameters = params;
// request all parmameters from a specific source: body, query, route
my %body_parameters = params('body');
my %route_parameters = params('route');
my %query_parameters = params('query');
# any $source that is not body, query, or route generates an exception
params('fake_source'); // Unknown source params "fake_source"
};
We now recommend using one of the specific keywords for parameters ("route_parameters",
"query_parameters", and "body_parameters") instead of "params" or "param".
pass
This method should be called from a route handler. Tells Dancer2 to pass the processing
of the request to the next matching route.
WARNING: Issuing a pass immediately exits the current route, and performs the pass. Thus,
any code after a pass is ignored, until the end of the route. Hence, it's not necessary
anymore to use "return" with pass.
get '/some/route' => sub {
if (...) {
# we want to let the next matching route handler process this one
pass(...);
# this code will be ignored
do_stuff();
}
};
WARNING: You cannot set the content before passing and have it remain, even if you use the
"content" keyword or set it directly in the response object.
patch
Defines a route for HTTP PATCH requests to the given URL:
patch '/resource' => sub { ... };
("PATCH" is a relatively new and not-yet-common HTTP verb, which is intended to work as a
"partial-PUT", transferring just the changes; please see RFC5789
<http://tools.ietf.org/html/rfc5789> for further details.)
path
Concatenates multiple paths together, without worrying about the underlying operating
system:
my $path = path(dirname($0), 'lib', 'File.pm');
It also normalizes (cleans) the path aesthetically. It does not verify whether the path
exists, though.
post
Defines a route for HTTP POST requests to the given URL:
post '/' => sub {
return "Hello world";
}
prefix
Defines a prefix for each route handler, like this:
prefix '/home';
From here, any route handler is defined to /home/*:
get '/page1' => sub {}; # will match '/home/page1'
You can unset the prefix value:
prefix undef;
get '/page1' => sub {}; # will match /page1
For a safer alternative you can use lexical prefix like this:
prefix '/home' => sub {
## Prefix is set to '/home' here
get ...;
get ...;
};
## prefix reset to the previous version here
This makes it possible to nest prefixes:
prefix '/home' => sub {
## some routes
prefix '/private' => sub {
## here we are under /home/private...
## some more routes
};
## back to /home
};
## back to the root
Notice: Once you have a prefix set, do not add a caret to the regex:
prefix '/foo';
get qr{^/bar} => sub { ... } # BAD BAD BAD
get qr{/bar} => sub { ... } # Good!
prepare_app
You can introduce code you want to run when your app is loaded, similar to the
"prepare_app" in Plack::Middleware.
prepare_app {
my $app = shift;
... # do your thing
};
You should not close over the App instance, since you receive it as a first argument. If
you close over it, you will have a memory leak.
my $app = app();
prepare_app {
do_something_with_app($app); # MEMORY LEAK
};
psgi_app
Provides the same functionality as to_app but uses the deprecated Dispatcher engine. You
should use to_app instead.
push_header
Deprecated. Use "push_response_header" instead.
push_response_header
Do the same as "response_header", but allow for multiple headers with the same name.
get '/send/header', sub {
push_response_header 'x-my-header' => '1';
push_response_header 'x-my-header' => '2';
# will result in two headers "x-my-header" in the response
}
put
Defines a route for HTTP PUT requests to the given URL:
put '/resource' => sub { ... };
query_parameters
Returns a Hash::MultiValue object from the request parameters.
/?foo=hello
get '/' => sub {
my $name = query_parameters->get('foo');
};
/?name=Alice&name=Bob
get '/' => sub {
my @names = query_parameters->get_all('name');
};
redirect
Generates a HTTP redirect (302). You can either redirect to a complete different site or
within the application:
get '/twitter', sub {
redirect 'http://twitter.com/me';
# Any code after the redirect will not be executed.
};
WARNING: Issuing a "redirect" immediately exits the current route. Thus, any code after a
"redirect" is ignored, until the end of the route. Hence, it's not necessary anymore to
use "return" with "redirect".
You can also force Dancer to return a specific 300-ish HTTP response code:
get '/old/:resource', sub {
redirect '/new/' . route_parameters->get('resource'), 301;
};
request
Returns a Dancer2::Core::Request object representing the current request.
See the Dancer2::Core::Request documentation for the methods you can call, for example:
request->referer; # value of the HTTP referer header
request->remote_address; # user's IP address
request->user_agent; # User-Agent header value
request_data
Returns the request's body in data form (in case a serializer is set, it will be in
deserialized).
This allows us to distinguish between "body_parameters", a representation of request
parameters (Hash::MultiValue) and other forms of content.
request_header
Returns request header(s).
get '/get/headers' => sub {
my $xfoo = request_header 'X-Foo';
...
};
response
Returns the current response object, which is of type Dancer2::Core::Route::REQUEST.
response_header
Adds a custom header to response:
get '/send/header', sub {
response_header 'x-my-header' => 'shazam!';
}
Note that it will overwrite the old value of the header, if any. To avoid that, see
"push_response_header".
response_headers
Adds custom headers to response:
get '/send/headers', sub {
response_headers 'X-Foo' => 'bar', 'X-Bar' => 'foo';
}
route_parameters
Returns a Hash::MultiValue object from the route parameters.
# /hello
get '/:foo' => sub {
my $foo = route_parameters->get('foo');
};
runner
Returns the runner singleton. Type is Dancer2::Core::Runner.
send_as
Allows the current route handler to return specific content types to the client using
either a specified serializer or as html.
Any Dancer2 serializer may be used. The specified serializer class will be loaded if
required, or an error generated if the class can not be found. Serializer configuration
may be added to your apps "engines" configuration.
If "html" is specified, the content will be returned assuming it is HTML with appropriate
"Content-Type" headers and encoded using the apps configured "charset" (or UTF-8).
set serializer => 'YAML';
set template => 'TemplateToolkit';
# returns html (not YAML)
get '/' => sub { send_as html => template 'welcome.tt' };
# return json (not YAML)
get '/json' => sub {
send_as JSON => [ some => { data => 'structure' } ];
};
"send_as" uses "send_file" to return the content immediately. You may pass any option
"send_file" supports as an extra option. For example:
# return json with a custom content_type header
get '/json' => sub {
send_as JSON => [ some => { data => 'structure' } ],
{ content_type => 'application/json; charset=UTF-8' },
};
WARNING: Issuing a send_as immediately exits the current route, and performs the
"send_as". Thus, any code after a "send_as" is ignored, until the end of the route. Hence,
it's not necessary to use "return" with "send_as".
get '/some/route' => sub {
if (...) {
send_as JSON => $some_data;
# this code will be ignored
do_stuff();
}
};
send_error
Returns a HTTP error. By default the HTTP code returned is 500:
get '/photo/:id' => sub {
if (...) {
send_error("Not allowed", 403);
} else {
# return content
}
}
WARNING: Issuing a send_error immediately exits the current route, and performs the
"send_error". Thus, any code after a "send_error" is ignored, until the end of the route.
Hence, it's not necessary anymore to use "return" with "send_error".
get '/some/route' => sub {
if (...) {
# Something bad happened, stop immediately!
send_error(..);
# this code will be ignored
do_stuff();
}
};
send_file
Lets the current route handler send a file to the client. Note that the path of the file
must be relative to the public directory unless you use the "system_path" option (see
below).
get '/download/:file' => sub {
return send_file(route_parameters->get('file'));
}
WARNING: Issuing a "send_file" immediately exits the current route, and performs the
"send_file". Thus, any code after a "send_file" is ignored, until the end of the route.
Hence, it's not necessary anymore to use "return" with "send_file".
get '/some/route' => sub {
if (...) {
# OK, send her what she wants...
send_file(...);
# this code will be ignored
do_stuff();
}
};
"send_file" will use PSGI streaming if the server supports it (most, if not all, do). You
can explicitly disable streaming by passing "streaming => 0" as an option to "send_file".
get '/download/:file' => sub {
send_file( route_parameters->get('file'), streaming => 0 );
}
The content-type will be set depending on the current MIME types definition (see "mime" if
you want to define your own).
If your filename does not have an extension, you are passing in a filehandle, or you need
to force a specific mime type, you can pass it to "send_file" as follows:
send_file(route_parameters->get('file'), content_type => 'image/png');
send_file($fh, content_type => 'image/png');
Also, you can use your aliases or file extension names on "content_type", like this:
send_file(route_parameters->get('file'), content_type => 'png');
The encoding of the file or filehandle may be specified by passing both the "content_type"
and "charset" options. For example:
send_file($fh, content_type => 'text/csv', charset => 'utf-8' );
For files outside your public folder, you can use the "system_path" switch. Just bear in
mind that its use needs caution as it can be dangerous.
send_file('/etc/passwd', system_path => 1);
If you have your data in a scalar variable, "send_file" can be useful as well. Pass a
reference to that scalar, and "send_file" will behave as if there was a file with that
contents:
send_file( \$data, content_type => 'image/png' );
Note that Dancer is unable to guess the content type from the data contents. Therefore
you might need to set the "content_type" properly. For this kind of usage an attribute
named "filename" can be useful. It is used as the Content-Disposition header, to hint the
browser about the filename it should use.
send_file( \$data, content_type => 'image/png'
filename => 'onion.png' );
By default the Content-Disposition header uses the "attachment" type, which triggers a
"Save" dialog in some browsers. Supply a "content_disposition" attribute of "inline" to
have the file displayed inline by the browser.
session
Provides access to all data stored in the user's session (if any).
It can also be used as a setter to store data in the session:
# getter example
get '/user' => sub {
if (session('user')) {
return "Hello, ".session('user')->name;
}
};
# setter example
post '/user/login' => sub {
...
if ($logged_in) {
session user => $user;
}
...
};
You may also need to clear a session:
# destroy session
get '/logout' => sub {
...
app->destroy_session;
...
};
If you need to fetch the session ID being used for any reason:
my $id = session->id;
set
Defines a setting:
set something => 'value';
You can set more than one value at once:
set something => 'value', otherthing => 'othervalue';
setting
Returns the value of a given setting:
setting('something'); # 'value'
splat
Returns the list of captures made from a route handler with a route pattern which includes
wildcards:
get '/file/*.*' => sub {
my ($file, $extension) = splat;
...
};
There is also the extensive splat (A.K.A. "megasplat"), which allows extensive greedier
matching, available using two asterisks. The additional path is broken down and returned
as an arrayref:
get '/entry/*/tags/**' => sub {
my ( $entry_id, $tags ) = splat;
my @tags = @{$tags};
};
The "splat" keyword in the above example for the route /entry/1/tags/one/two would set
$entry_id to 1 and $tags to "['one', 'two']".
start
Starts the application or the standalone server (depending on the deployment choices).
This keyword should be called at the very end of the script, once all routes are defined.
At this point, Dancer2 takes over.
to_app is preferable to dancer or "start".
status
Changes the status code provided by an action. By default, an action will produce an "HTTP
200 OK" status code, meaning everything is OK:
get '/download/:file' => {
if (! -f route_parameters->get('file')) {
status 'not_found';
return "File does not exist, unable to download";
}
# serving the file...
};
In that example, Dancer will notice that the status has changed, and will render the
response accordingly.
The "status" keyword receives either a numeric status code or its name in lower case, with
underscores as a separator for blanks - see the list in "HTTP CODES" in
Dancer2::Core::HTTP. As an example, The above call translates to setting the code to 404.
template
Returns the response of processing the given template with the given parameters (and
optional settings), wrapping it in the default or specified layout too, if layouts are in
use.
An example of a route handler which returns the result of using template to build a
response with the current template engine:
get '/' => sub {
...
return template 'some_view', { token => 'value'};
};
Note that "template" simply returns the content, so when you use it in a route handler, if
execution of the route handler should stop at that point, make sure you use "return" to
ensure your route handler returns the content.
Since "template" just returns the result of rendering the template, you can also use it to
perform other templating tasks, e.g. generating emails:
post '/some/route' => sub {
if (...) {
email {
to => 'someone@example.com',
from => 'foo@example.com',
subject => 'Hello there',
msg => template('emails/foo', { name => body_parameters->get('name') }),
};
return template 'message_sent';
} else {
return template 'error';
}
};
Compatibility notice: "template" was changed in version 1.3090 to immediately interrupt
execution of a route handler and return the content, as it's typically used at the end of
a route handler to return content. However, this caused issues for some people who were
using "template" to generate emails etc, rather than accessing the template engine
directly, so this change has been reverted in 1.3091.
The first parameter should be a template available in the views directory, the second one
(optional) is a hashref of tokens to interpolate, and the third (again optional) is a
hashref of options.
For example, to disable the layout for a specific request:
get '/' => sub {
template 'index', {}, { layout => undef };
};
Or to request a specific layout, of course:
get '/user' => sub {
template 'user', {}, { layout => 'user' };
};
Some tokens are automatically added to your template ("perl_version", "dancer_version",
"settings", "request", "vars" and, if you have sessions enabled, "session"). Check Default
Template Variables for further details.
to_app
Returns the PSGI coderef for the current (and only the current) application.
You can call it as a method on the class or as a DSL:
my $app = MyApp->to_app;
# or
my $app = to_app;
There is a Dancer Advent Calendar article <http://advent.perldancer.org/2014/9> covering
this keyword and its usage further.
to_dumper ($structure)
Serializes a structure with Data::Dumper.
Calling this function will not trigger the serialization's hooks.
to_json ($structure, \%options)
Serializes a structure to JSON. You should probably use "encode_json" instead which
handles encoding the result for you.
to_yaml ($structure)
Serializes a structure to YAML.
Calling this function will not trigger the serialization's hooks.
true
Constant that returns a true value (1).
upload
Provides access to file uploads. Any uploaded file is accessible as a
Dancer2::Core::Request::Upload object. You can access all parsed uploads via:
post '/some/route' => sub {
my $file = upload('file_input_foo');
# $file is a Dancer2::Core::Request::Upload object
};
If you named multiple inputs of type "file" with the same name, the "upload" keyword would
return an Array of Dancer2::Core::Request::Upload objects:
post '/some/route' => sub {
my ($file1, $file2) = upload('files_input');
# $file1 and $file2 are Dancer2::Core::Request::Upload objects
};
You can also access the raw hashref of parsed uploads via the current "request" object:
post '/some/route' => sub {
my $all_uploads = request->uploads;
# $all_uploads->{'file_input_foo'} is a Dancer2::Core::Request::Upload object
# $all_uploads->{'files_input'} is an arrayref of Dancer2::Core::Request::Upload objects
};
Note that you can also access the filename of the upload received via the
"body_parameters" keyword:
post '/some/route' => sub {
# body_parameters->get('files_input') is the filename of the file uploaded
};
See Dancer2::Core::Request::Upload for details about the interface provided.
uri_for
Returns a fully-qualified URI for the given path:
get '/' => sub {
redirect uri_for('/path');
# can be something like: http://localhost:5000/path
};
Query string parameters can be provided by passing a hashref as a second param:
uri_for('/path', { foo => 'bar' });
# would return e.g. http://localhost:5000/path?foo=bar
By default, the parameters will be URL encoded:
uri_for('/path', { foo => 'hope;faith' });
# would return http://localhost:5000/path?foo=hope%3Bfaith
If desired (for example, if you've already encoded your query parameters and you want to
prevent double encoding) you can disable URL encoding via a third parameter:
uri_for('/path', { foo => 'qux%3Dquo' }, 1);
# would return http://localhost:5000/path?foo=qux%3Dquo
var
Provides an accessor for variables shared between hooks and route handlers. Given a
key/value pair, it sets a variable:
hook before => sub {
var foo => 42;
};
Later, route handlers and other hooks will be able to read that variable:
get '/path' => sub {
my $foo = var 'foo';
...
};
vars
Returns the hashref of all shared variables set during the hook/route chain with the "var"
keyword:
get '/path' => sub {
if (vars->{foo} eq 42) {
...
}
};
warning
Logs a warning message through the current logger engine:
warning "This is a warning";
See Dancer2::Core::Role::Logger for details on how to configure where log messages go.
AUTHOR
Dancer Core Developers
COPYRIGHT AND LICENSE
This software is copyright (c) 2022 by Alexis Sukrieh.
This is free software; you can redistribute it and/or modify it under the same terms as
the Perl 5 programming language system itself.