NAME

module:

#!/usr/bin/perl
use Dancer;

get '/hello/:name' => sub {
    return "Why, hello there " . param('name');
};

dance;
# 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);
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);
use MyApp;
use Dancer ':script';
MyApp::schema('DBSchema')->deploy();
use Dancer qw(!session);
any ['get', 'post'] => '/myaction' => sub {
    # code
};
any '/myaction' => sub {
    # code
};
get '/some_action' => sub {
    my $cookie = cookies->{name};
    return $cookie->value;
};
get '/some_action' => sub {
    my $cookie = cookies->{oauth};
    my %values = $cookie->value;
    return ($values{token}, $values{token_secret});
};
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
token=ABC&user=foo
my @values = cookie "name";
get '/appname' => sub {
    return "This is " . config->{appname};
};
get '/cat/:txtfile' => sub {
    content_type 'text/plain';

    # here we can dump the contents of param('txtfile')
};
get '/svg/:id' => sub {
    content_type 'svg';

    # here we can dump the image with id param('id')
};
int(dancer_version);
debug "This is a debug message";
my $dir = dirname($some_path);
my $template_engine = engine 'template';
my $html = $template_engine->apply_renderer(...);
$template_engine->apply_layout($html);
error "This is an error message";
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};
};
get '/foo/:article_id' => sub {
    if ($condition) {
        forward "/articles/" . params->{article_id};
        # The following code is never executed
        do_stuff();
    }

    more_stuff();
};
return forward '/home?authorized=1';
return forward '/home', { authorized => 1 };
return forward '/home', { auth => 1 }, { method => 'POST' };
get '/' => sub {
    return "Hello world";
}
hook before sub {
    if ($some_condition) {
        halt("Unauthorized");
        # This code is not executed :
        do_stuff();
    }
};

get '/' => sub {
    "hello there";
};
get '/send/headers', sub {
    headers 'X-Foo' => 'bar', X-Bar => 'foo';
}
get '/send/header', sub {
    header 'x-my-header' => 'shazam!';
}
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 before_serializer => sub {
  my $response = shift;
  $response->content->{generated_at} = localtime();
};
hook before_deserializer => sub {
  ...
};
hook before_file_render => sub {
  my $path = shift;
  ...
};
hook before_error_init => sub {
  my $error = shift;
  ...
};
hook before_error_render => sub {
  my $error = shift;
};
hook before => sub {
  my $route_handler = shift;
  ...
};
before sub {
  ...
};
hook before_template_render => sub {
  my $tokens = shift;
  delete $tokens->{user};
  $tokens->{time} = localtime;
};
hook before_template => sub {
  my $tokens = shift;
  delete $tokens->{user};
  $tokens->{time} = localtime;
};
hook before_layout_render => sub {
  my ($tokens, $html_ref) = @_;
  ...
};
hook before_serializer => sub {
  my $response = shift;
  $response->content->{start_time} = time();
};
hook after_deserializer => sub {
  ...
};
hook after_file_render => sub {
  my $response = shift;
};
hook after_template_render => sub {
  my $html_ref = shift;
};
hook after_layout_render => sub {
  my $html_ref = shift;
};
hook after => sub {
  my $response = shift;
};
after sub {
  my $response = shift;
};
hook after_error_render => sub {
  my $response = shift;
};
hook on_handler_exception => sub {
  my $exception = shift;
};
hook on_reset_state => sub {
  my $is_forward = shift;
};
hook on_route_exception => sub {
  my $exception = shift;
};
info "This is a info message";
set layout => 'user';
load 'UserActions.pl', 'AdminActions.pl';
# 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'};
load_app 'one';
load_app 'two';
# 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';
post '/login' => sub {
    my $username = param "user";
    my $password = param "pass";
    # ...
}
# 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'
};
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 '/resource' => sub { ... };
my $path = path(dirname($0), 'lib', 'File.pm');
post '/' => sub {
    return "Hello world";
}
prefix '/home';
get '/page1' => sub {}; # will match '/home/page1'
prefix undef;
get '/page1' => sub {}; will match /page1
prefix '/home' => sub {
    ## Prefix is set to '/home' here

    get ...;
    get ...;
};
## prefix reset to the previous version here
prefix '/home' => sub {
    ## some routes
    
   prefix '/private' => sub {
      ## here we are under /home/private...

      ## some more routes
   };
   ## back to /home
};
## back to the root
prefix '/foo';
get qr{^/bar} => sub { ... } # BAD BAD BAD
get qr{/bar}  => sub { ... } # Good!
del '/resource' => sub { ... };
options '/resource' => sub { ... };
put '/resource' => sub { ... };
get '/twitter', sub {
    redirect 'http://twitter.com/me';
};
get '/old/:resource', sub {
    redirect '/new/'.params->{resource}, 301;
};
get '/restricted', sub {
    return redirect '/login' if accessDenied();
    return 'Welcome to the restricted section';
};
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)
};
render_with_layout $content, {}, { layout => 'layoutname' };
request->referer;         # value of the HTTP referer header
request->remote_address;  # user's IP address
request->user_agent;      # User-Agent header value
get '/photo/:id' => sub {
    if (...) {
        send_error("Not allowed", 403);
    } else {
       # return content
    }
}
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();
    }
};
get '/download/:file' => sub {
    send_file(params->{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();
    }
};
get '/download/:file' => sub {
    send_file( params->{file}, streaming => 1 );
}
get '/download/:file' => sub {
    send_file(
        params->{file},
        streaming => 1,
        callbacks => {
            around_content => sub {
                my ( $writer, $chunk ) = @_;
                $writer->write("* $chunk");
            },
        },
    );
}
get '/download/:file' => sub {
    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);
                }
            },
        },
    );
}
get '/download/:file' => sub {
    send_file(
        params->{file},
        streaming => 1,
        callbacks => {
            override => sub {
                my ( $respond, $response ) = @_;

                my $writer = $respond->( [ $newstatus, $newheaders ] );
                $writer->write("some line");
            },
        },
    );
}
get '/download/:file' => sub {
    send_file(
        params->{file},
        streaming => 1,
        bytes     => 524288, # 512K
    );
};
send_file(params->{file}, content_type => 'image/png');
send_file(params->{file}, content_type => 'png');
send_file('/etc/passwd', system_path => 1);
send_file( \$data, content_type => 'image/png' );
send_file( \$data, content_type => 'image/png'
                          filename     => 'onion.png' );
set something => 'value';
set something => 'value', otherthing => 'othervalue';
setting('something'); # 'value'
get '/some_action' => sub {
    set_cookie name => 'value',
               expires => (time + 3600),
               domain  => '.foo.com';
};
get '/some_auth' => sub {
    set_cookie oauth => {
        token        => $twitter->request_token,
        token_secret => $twitter->secret_token,
        ...
    };
};
# 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;
    }
    ...
};
# destroy session
get '/logout' => sub {
    ...
    session->destroy;
    ...
};
my $id = session->id;
session: "YAML"
get '/file/*.*' => sub {
    my ($file, $extension) = splat;
    ...
};
get '/entry/*/tags/**' => sub {
    my ( $entry_id, $tags ) = splat;
    my @tags = @{$tags};
};
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'} );
};
get '/download/:file' => {
    if (! -f params->{file}) {
        status 'not_found';
        return "File does not exist, unable to download";
    }
    # serving the file...
};
get '/' => sub {
    ...
    return template 'some_view', { token => 'value'};
};
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';
    }
};
get '/' => sub {
    template 'index', {}, { layout => undef };
};
get '/user' => sub {
    template 'user', {}, { layout => 'user' };
};
post '/some/route' => sub {
    my $file = upload('file_input_foo');
    # file is a Dancer::Request::Upload object
};
post '/some/route' => sub {
    my ($file1, $file2) = upload('files_input');
    # $file1 and $file2 are Dancer::Request::Upload objects
};
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
};
post '/some/route' => sub {
    # params->{'files_input'} is the filename of the file uploaded
};
get '/' => sub {
    redirect uri_for('/path');
    # can be something like: http://localhost:3000/path
};
uri_for('/path', { foo => 'bar' }, 1);
# would return e.g. http://localhost:3000/path?foo=bar
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} !"
};
hook before sub {
    var foo => 42;
};
get '/path' => sub {
    my $foo = var 'foo';
    ...
};
get '/path' => sub {
    if (vars->{foo} eq 42) {
        ...
    }
};
warning "This is a warning";
cpanm Dancer
perl -MCPAN -e shell
install Dancer

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)

NAME

VERSION

SYNOPSIS

DESCRIPTION

MORE DOCUMENTATION

DANCER 2

EXPORTS

:moose

:syntax

:tests

:script

!keyword

FUNCTIONS

after

any

before

before_template

cookies

cookie

config

content_type

dance

dancer_version

debug

dirname

engine

error

false

forward

from_dumper ($structure)

from_json ($structure, \%options)

from_yaml ($structure)

from_xml ($structure, %options)

get

halt

headers

header

push_header

hook

info

layout

logger

load

load_app

mime

params

param

param_array

pass

patch

path

post

prefix

del

options

put

redirect

render_with_layout

request

send_error

send_file

set

setting

set_cookie

session

splat

start

status

template

to_dumper ($structure)

to_json ($structure, \%options)

to_yaml ($structure)

to_xml ($structure, %options)

true

upload

uri_for

captures

var

vars

warning