1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389
|
NAME
Dancer - lightweight yet powerful web application framework
VERSION
version 1.3132
SYNOPSIS
#!/usr/bin/perl
use Dancer;
get '/hello/:name' => sub {
return "Why, hello there " . param('name');
};
dance;
The above is a basic but functional web app created with Dancer. If you
want to see more examples and get up and running quickly, check out the
Dancer::Introduction and the Dancer::Cookbook. For examples on deploying
your Dancer applications, see Dancer::Deployment.
DESCRIPTION
Dancer is a web application framework designed to be as effortless as
possible for the developer, taking care of the boring bits as easily as
possible, yet staying out of your way and letting you get on with
writing your code.
Dancer aims to provide the simplest way for writing web applications,
and offers the flexibility to scale between a very simple lightweight
web service consisting of a few lines of code in a single file, all the
way up to a more complex fully-fledged web application with session
support, templates for views and layouts, etc.
If you don't want to write CGI scripts by hand, and find Catalyst too
big or cumbersome for your project, Dancer is what you need.
Dancer has few pre-requisites, so your Dancer webapps will be easy to
deploy.
Dancer apps can be used with a an embedded web server (great for easy
testing), and can run under PSGI/Plack for easy deployment in a variety
of webserver environments.
MORE DOCUMENTATION
This documentation describes all the exported symbols of Dancer. If you
want a quick start guide to discover the framework, you should look at
Dancer::Introduction, or Dancer::Tutorial to learn by example.
If you want to have specific examples of code for real-life problems,
see the Dancer::Cookbook.
If you want to see configuration examples of different deployment
solutions involving Dancer and Plack, see Dancer::Deployment.
You can find out more about the many useful plugins available for Dancer
in Dancer::Plugins.
EXPORTS
By default, "use Dancer" exports all the functions below plus sets up
your app. You can control the exporting through the normal Exporter
mechanism. For example:
# Just export the route controllers
use Dancer qw(get post put patch del);
# Export everything but pass to avoid clashing with Test::More
use Test::More;
use Dancer qw(!pass);
There are also some special tags to control exports and behaviour.
:moose
This will export everything except functions which clash with Moose.
Currently these are "after" and "before".
:syntax
This tells Dancer to just export symbols and not set up your app. This
is most useful for writing Dancer code outside of your main route
handler.
:tests
This will export everything except functions which clash with commonly
used testing modules. Currently these are "pass".
It can be combined with other export pragmas. For example, while
testing...
use Test::More;
use Dancer qw(:syntax :tests);
# Test::Most also exports "set" and "any"
use Test::Most;
use Dancer qw(:syntax :tests !set !any);
# Alternatively, if you want to use Dancer's set and any...
use Test::Most qw(!set !any);
use Dancer qw(:syntax :tests);
:script
This will export all the keywords, and will also load the configuration.
This is useful when you want to use your Dancer application from a
script.
use MyApp;
use Dancer ':script';
MyApp::schema('DBSchema')->deploy();
By default, the warnings pragma will also be exported, meaning your
app/script will be running under "use warnings". If you do not want
this, set the import_warnings setting to a false value.
!keyword
If you want to simply prevent Dancer from exporting specific keywords
(perhaps you plan to implement them yourself in a different way, or you
don't plan to use them and they clash with another module you're
loading), you can simply exclude them:
use Dancer qw(!session);
The above would import all keywords as normal, with the exception of
"session".
FUNCTIONS
after
Deprecated - see the "after" hook.
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
};
before
Deprecated - see the "before" hook.
before_template
Deprecated - see the "before_template" hook.
cookies
Accesses cookies values, it returns a HashRef of Dancer::Cookie objects:
get '/some_action' => sub {
my $cookie = cookies->{name};
return $cookie->value;
};
In the case you have stored something else than a Scalar in your cookie:
get '/some_action' => sub {
my $cookie = cookies->{oauth};
my %values = $cookie->value;
return ($values{token}, $values{token_secret});
};
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";
config
Accesses the configuration of the application:
get '/appname' => sub {
return "This is " . config->{appname};
};
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 param('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 param('id')
};
Note that if you want to change the default content-type for every
route, you have to change the "content_type" setting instead.
dance
Alias for the "start" keyword.
dancer_version
Returns the version of Dancer. If you need the major version, do
something like:
int(dancer_version);
debug
Logs a message of debug level:
debug "This is a debug message";
See Dancer::Logger for details on how to configure where log messages
go.
dirname
Returns the dirname of the path given:
my $dir = dirname($some_path);
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 Dancer::Logger for details on how to configure where log messages
go.
false
Constant that returns a false value (0).
forward
Runs an internal redirect of the current request to another request.
This helps you avoid having to redirect the user using HTTP and set
another request to your application.
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/" . params->{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.)
WARNING : using forward will not preserve session data set on the
forwarding rule.
WARNING : Issuing a forward immediately exits the current route, and
perform the forward. Thus, any code after a forward is ignored, until
the end of the route. e.g.
get '/foo/:article_id' => sub {
if ($condition) {
forward "/articles/" . params->{article_id};
# The following code is never executed
do_stuff();
}
more_stuff();
};
So it's not necessary anymore to use "return" with forward.
Note that forward doesn't parse GET arguments. So, you can't use
something like:
return forward '/home?authorized=1';
But "forward" supports an optional HashRef with parameters to be added
to the actual parameters:
return 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.
return forward '/home', { auth => 1 }, { method => 'POST' };
from_dumper ($structure)
Deserializes a Data::Dumper structure.
from_json ($structure, %options)
Deserializes a JSON structure. Can receive optional arguments. Those
arguments are valid JSON arguments to change the behaviour of the
default "JSON::from_json" function.
from_yaml ($structure)
Deserializes a YAML structure.
from_xml ($structure, %options)
Deserializes a XML structure. Can receive optional arguments. These
arguments are valid XML::Simple arguments to change the behaviour of the
default "XML::Simple::XMLin" function.
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 filter, 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
perform the halt. Thus, any code after a halt is ignored, until the end
of the route. So it's not necessary anymore to use "return" with halt.
headers
Adds custom headers to responses:
get '/send/headers', sub {
headers 'X-Foo' => 'bar', X-Bar => 'foo';
}
header
adds a custom header to response:
get '/send/header', sub {
header 'x-my-header' => 'shazam!';
}
Note that it will overwrite the old value of the header, if any. To
avoid that, see "push_header".
push_header
Do the same as "header", but allow for multiple headers with the same
name.
get '/send/header', sub {
push_header 'x-my-header' => '1';
push_header 'x-my-header' => '2';
will result in two headers "x-my-header" in the response
}
hook
Adds a hook at some position. For example :
hook before_serializer => sub {
my $response = shift;
$response->content->{generated_at} = localtime();
};
There can be multiple hooks assigned to a given position, and each will
be executed in order. Note that all hooks are always called, even if
they are defined in a different package loaded via "load_app".
(For details on how to register new hooks from within plugins, see
Dancer::Hook.) Supported before hooks (in order of execution):
before_deserializer
This hook receives no arguments.
hook before_deserializer => sub {
...
};
before_file_render
This hook receives as argument the path of the file to render.
hook before_file_render => sub {
my $path = shift;
...
};
before_error_init
This hook receives as argument a Dancer::Error object.
hook before_error_init => sub {
my $error = shift;
...
};
before_error_render
This hook receives as argument a Dancer::Error object.
hook before_error_render => sub {
my $error = shift;
};
before
This hook receives one argument, the route being executed (a
Dancer::Route object).
hook before => sub {
my $route_handler = shift;
...
};
it is equivalent to the deprecated
before sub {
...
};
before_template_render
This is an alias to 'before_template'.
This hook receives as argument a HashRef, containing the tokens that
will be passed to the template. You can use it to add more tokens,
or delete some specific token.
hook before_template_render => sub {
my $tokens = shift;
delete $tokens->{user};
$tokens->{time} = localtime;
};
is equivalent to
hook before_template => sub {
my $tokens = shift;
delete $tokens->{user};
$tokens->{time} = localtime;
};
before_layout_render
This hook receives two arguments. The first one is a HashRef
containing the tokens. The second is a ScalarRef representing the
content of the template.
hook before_layout_render => sub {
my ($tokens, $html_ref) = @_;
...
};
before_serializer
This hook receives as argument a Dancer::Response object.
hook before_serializer => sub {
my $response = shift;
$response->content->{start_time} = time();
};
Supported after hooks (in order of execution):
after_deserializer
This hook receives no arguments.
hook after_deserializer => sub {
...
};
after_file_render
This hook receives as argument a Dancer::Response object.
hook after_file_render => sub {
my $response = shift;
};
after_template_render
This hook receives as argument a ScalarRef representing the content
generated by the template.
hook after_template_render => sub {
my $html_ref = shift;
};
after_layout_render
This hook receives as argument a ScalarRef representing the content
generated by the layout
hook after_layout_render => sub {
my $html_ref = shift;
};
after
This is an alias for "after".
This hook runs after a request has been processed, but before the
response is sent.
It receives a Dancer::Response object, which it can modify if it
needs to make changes to the response which is about to be sent.
hook after => sub {
my $response = shift;
};
This is equivalent to the deprecated
after sub {
my $response = shift;
};
after_error_render
This hook receives as argument a Dancer::Response object.
hook after_error_render => sub {
my $response = shift;
};
on_handler_exception
This hook is called when an exception has been caught, at the
handler level, just before creating and rendering Dancer::Error.
This hook receives as argument a Dancer::Exception object.
hook on_handler_exception => sub {
my $exception = shift;
};
on_reset_state
This hook is called when global state is reset to process a new
request. It receives a boolean value that indicates whether the
reset was called as part of a forwarded request.
hook on_reset_state => sub {
my $is_forward = shift;
};
on_route_exception
This hook is called when an exception has been caught, at the route
level, just before rethrowing it higher. This hook receives the
exception as argument. It can be a Dancer::Exception, or a string,
or whatever was used to "die".
hook on_route_exception => sub {
my $exception = shift;
};
info
Logs a message of info level:
info "This is a info message";
See Dancer::Logger for details on how to configure where log messages
go.
layout
This method is deprecated. Use "set":
set layout => 'user';
logger
Deprecated. Use "<set logger => 'console'"> to change current logger
engine.
load
Loads one or more perl scripts in the current application's namespace.
Syntactic sugar around Perl's "require":
load 'UserActions.pl', 'AdminActions.pl';
load_app
Loads a Dancer package. This method sets the libdir to the current
"./lib" directory:
# if we have lib/Webapp.pm, we can load it like:
load_app 'Webapp';
# or with options
load_app 'Forum', prefix => '/forum', settings => {foo => 'bar'};
Note that the package loaded using load_app must import Dancer with the
":syntax" option.
To load multiple apps repeat load_app:
load_app 'one';
load_app 'two';
The old way of loading multiple apps in one go (load_app 'one', 'two';)
is deprecated.
mime
Shortcut to access the instance object of Dancer::MIME. You should read
the Dancer::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';
params
*This method should be called from a route handler*. It's an alias for
the Dancer::Request params accessor. In list context it returns a list
of key/value pair of all defined parameters. In scalar context, it
returns a hash reference instead. Check "param" below to access quickly
to a single parameter value.
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";
# ...
}
param_array
*This method should be called from a route handler*. Like *param*, but
always returns the parameter value or values as a list. Returns the
number of values in scalar context.
# if request is '/tickets?tag=open&tag=closed&order=desc'...
get '/tickets' => sub {
my @tags = param_array 'tag'; # ( 'open', 'closed' )
my $tags = param 'tag'; # array ref
my @order = param_array 'order'; # ( 'desc' )
my $order = param 'order'; # 'desc'
};
pass
*This method should be called from a route handler*. Tells Dancer to
pass the processing of the request to the next matching route.
WARNING : Issuing a pass immediately exits the current route, and
perform the pass. Thus, any code after a pass is ignored, until the end
of the route. So 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();
}
};
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 <http://tools.ietf.org/html/rfc5789|RFC5789> for further
details.)
Please be aware that, if you run your app in standalone mode, "PATCH"
requests will not reach your app unless you have a new version of
HTTP::Server::Simple which accepts "PATCH" as a valid verb. The current
version at time of writing, 0.44, does not. A pull request has been
submitted to add this support, which you can find at:
<https://github.com/bestpractical/http-server-simple/pull/1>
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
the path exists.
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!
del
Defines a route for HTTP DELETE requests to the given URL:
del '/resource' => sub { ... };
options
Defines a route for HTTP OPTIONS requests to the given URL:
options '/resource' => sub { ... };
put
Defines a route for HTTP PUT requests to the given URL:
put '/resource' => sub { ... };
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';
};
You can also force Dancer to return a specific 300-ish HTTP response
code:
get '/old/:resource', sub {
redirect '/new/'.params->{resource}, 301;
};
It is important to note that issuing a redirect by itself does not exit
and redirect immediately, redirection is deferred until after the
current route or filter has been processed. To exit and redirect
immediately, use the return function, e.g.
get '/restricted', sub {
return redirect '/login' if accessDenied();
return 'Welcome to the restricted section';
};
render_with_layout
Allows a handler to provide plain HTML (or other content), but have it
rendered within the layout still.
This method is DEPRECATED, and will be removed soon. Instead, you should
be using the "engine" keyword:
get '/foo' => sub {
# Do something which generates HTML directly (maybe using
# HTML::Table::FromDatabase or something)
my $content = ...;
# get the template engine
my $template_engine = engine 'template';
# apply the layout (not the renderer), and return the result
$template_engine->apply_layout($content)
};
It works very similarly to "template" in that you can pass tokens to be
used in the layout, and/or options to control the way the layout is
rendered. For instance, to use a custom layout:
render_with_layout $content, {}, { layout => 'layoutname' };
request
Returns a Dancer::Request object representing the current request.
See the Dancer::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
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
perform the send_error. Thus, any code after a send_error is ignored,
until the end of the route. So it's not necessary anymore to use
"return" with send_error.
get '/some/route' => sub {
if (...) {
# we want to let the next matching route handler process this one
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(params->{file});
}
WARNING : Issuing a send_file immediately exits the current route, and
perform the send_file. Thus, any code after a send_file is ignored,
until the end of the route. So it's not necessary anymore to use
"return" with send_file.
get '/some/route' => sub {
if (...) {
# we want to let the next matching route handler process this one
send_file(...);
# This code will be ignored
do_stuff();
}
};
Send file supports streaming possibility using PSGI streaming. The
server should support it but normal streaming is supported on most, if
not all.
get '/download/:file' => sub {
return send_file( params->{file}, streaming => 1 );
}
You can control what happens using callbacks.
First, "around_content" allows you to get the writer object and the
chunk of content read, and then decide what to do with each chunk:
get '/download/:file' => sub {
return send_file(
params->{file},
streaming => 1,
callbacks => {
around_content => sub {
my ( $writer, $chunk ) = @_;
$writer->write("* $chunk");
},
},
);
}
You can use "around" to all get all the content (whether a filehandle if
it's a regular file or a full string if it's a scalar ref) and decide
what to do with it:
get '/download/:file' => sub {
return send_file(
params->{file},
streaming => 1,
callbacks => {
around => sub {
my ( $writer, $content ) = @_;
# we know it's a text file, so we'll just stream
# line by line
while ( my $line = <$content> ) {
$writer->write($line);
}
},
},
);
}
Or you could use "override" to control the entire streaming callback
request:
get '/download/:file' => sub {
return send_file(
params->{file},
streaming => 1,
callbacks => {
override => sub {
my ( $respond, $response ) = @_;
my $writer = $respond->( [ $newstatus, $newheaders ] );
$writer->write("some line");
},
},
);
}
You can also set the number of bytes that will be read at a time
(default being 42K bytes) using "bytes":
get '/download/:file' => sub {
return send_file(
params->{file},
streaming => 1,
bytes => 524288, # 512K
);
};
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, or you need to force a
specific mime type, you can pass it to "send_file" as follows:
return send_file(params->{file}, content_type => 'image/png');
Also, you can use your aliases or file extension names on
"content_type", like this:
return send_file(params->{file}, content_type => 'png');
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.
return 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:
return 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.
return send_file( \$data, content_type => 'image/png'
filename => 'onion.png' );
Note that you should always use "return send_file ..." to stop execution
of your route handler at that point.
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'
set_cookie
Creates or updates cookie values:
get '/some_action' => sub {
set_cookie name => 'value',
expires => (time + 3600),
domain => '.foo.com';
};
In the example above, only 'name' and 'value' are mandatory.
You can also store more complex structure in your cookies:
get '/some_auth' => sub {
set_cookie oauth => {
token => $twitter->request_token,
token_secret => $twitter->secret_token,
...
};
};
You can't store more complex structure than this. All keys in the
HashRef should be Scalars; storing references will not work.
See Dancer::Cookie for further options when creating your cookie.
Note that this method will be eventually deprecated in favor of the new
"cookie" method.
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 {
...
session->destroy;
...
};
If you need to fetch the session ID being used for any reason:
my $id = session->id;
In order to be able to use sessions, first you need to enable session
support in one of the configuration files. A quick way to do it is to
add
session: "YAML"
to config.yml.
For more details, see Dancer::Session.
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};
};
This helps with chained actions:
get '/team/*/**' => sub {
my ($team) = splat;
var team => $team;
pass;
};
prefix '/team/*';
get '/player/*' => sub {
my ($player) = splat;
# etc...
};
get '/score' => sub {
return score_for( vars->{'team'} );
};
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, Dancer takes over control.
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 params->{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 Dancer::HTTP.
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 => params->{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", "params", "vars" and, if you
have sessions enabled, "session"). Check Dancer::Template::Abstract for
further details.
to_dumper ($structure)
Serializes a structure with Data::Dumper.
to_json ($structure, %options)
Serializes a structure to JSON. Can receive optional arguments. Thoses
arguments are valid JSON arguments to change the behaviour of the
default "JSON::to_json" function.
to_yaml ($structure)
Serializes a structure to YAML.
to_xml ($structure, %options)
Serializes a structure to XML. Can receive optional arguments. Thoses
arguments are valid XML::Simple arguments to change the behaviour of the
default "XML::Simple::XMLout" function.
true
Constant that returns a true value (1).
upload
Provides access to file uploads. Any uploaded file is accessible as a
Dancer::Request::Upload object. You can access all parsed uploads via:
post '/some/route' => sub {
my $file = upload('file_input_foo');
# file is a Dancer::Request::Upload object
};
If you named multiple input of type "file" with the same name, the
upload keyword will return an Array of Dancer::Request::Upload objects:
post '/some/route' => sub {
my ($file1, $file2) = upload('files_input');
# $file1 and $file2 are Dancer::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 Dancer::Request::Upload object
# $all_uploads->{'files_input'} is an ArrayRef of Dancer::Request::Upload objects
};
Note that you can also access the filename of the upload received via
the params keyword:
post '/some/route' => sub {
# params->{'files_input'} is the filename of the file uploaded
};
See Dancer::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:3000/path
};
captures
Returns a reference to a copy of "%+", if there are named captures in
the route Regexp.
Named captures are a feature of Perl 5.10, and are not supported in
earlier versions:
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} !"
};
var
Provides an accessor for variables shared between filters and route
handlers. Given a key/value pair, it sets a variable:
hook before sub {
var foo => 42;
};
Later, route handlers and other filters 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 filter/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 Dancer::Logger for details on how to configure where log messages
go.
AUTHOR
This module has been written by Alexis Sukrieh <sukria@cpan.org> and
others, see the AUTHORS file that comes with this distribution for
details.
SOURCE CODE
The source code for this module is hosted on GitHub
<https://github.com/PerlDancer/Dancer>. Feel free to fork the repository
and submit pull requests! (See Dancer::Development for details on how to
contribute).
Also, why not watch the repo
<https://github.com/PerlDancer/Dancer/toggle_watch> to keep up to date
with the latest upcoming changes?
GETTING HELP / CONTRIBUTING
The Dancer development team can be found on #dancer on irc.perl.org:
<irc://irc.perl.org/dancer>
If you don't have an IRC client installed/configured, there is a simple
web chat client at <http://www.perldancer.org/irc> for you.
There is also a Dancer users mailing list available - subscribe at:
<http://lists.preshweb.co.uk/mailman/listinfo/dancer-users>
If you'd like to contribute to the Dancer project, please see
<http://www.perldancer.org/contribute> for all the ways you can help!
DEPENDENCIES
The following modules are mandatory (Dancer cannot run without them):
HTTP::Server::Simple::PSGI
HTTP::Body
LWP
MIME::Types
URI
The following modules are optional:
JSON : needed to use JSON serializer
Plack : in order to use PSGI
Template : in order to use TT for rendering views
XML::Simple and <XML:SAX> or <XML:Parser> for XML serialization
YAML : needed for configuration file support
SEE ALSO
Main Dancer web site: <http://perldancer.org/>.
The concept behind this module comes from the Sinatra ruby project, see
<http://www.sinatrarb.com/> for details.
AUTHOR
Dancer Core Developers
COPYRIGHT AND LICENSE
This software is copyright (c) 2010 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.
|