Dancer(3pm)

the

#!/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";

Dancer(3pm)

💃 Dancer — the Dancer(3pm) manual page, bestie edition 🎀

✨ 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

🎀 before_deserializer

🎀 before_file_render

🎀 before_error_init

🎀 before_error_render

🎀 before

🎀 before_template_render

🎀 before_layout_render

🎀 before_serializer

🦋 after_deserializer

🦋 after_file_render

🦋 after_template_render

🦋 after_layout_render

🦋 after

🦋 after_error_render

🌈 on_handler_exception

🌈 on_reset_state

🌈 on_route_exception

🍓 info

🍓 layout

🍓 logger

🧁 load

🧁 load_app

💜 mime

🌸 params

🌸 param

🌸 param_array

💅 pass

💅 patch

🛤️ path — wait, path

📮 post

🎀 prefix

🗑️ del

🧐 options

📤 put

🔁 redirect

🖼️ render_with_layout

📨 request

🛑 send_error

📁 send_file

💃 Dancer — the `Dancer(3pm)` manual page, bestie edition 🎀

🦋 `:moose` 🦋

🦋 `:syntax` 🦋

🦋 `:tests` 🦋

🦋 `:script` 🦋

🦋 `!keyword` 🦋

`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`

🎀 `before_deserializer`

🎀 `before_file_render`

🎀 `before_error_init`

🎀 `before_error_render`

🎀 `before`

🎀 `before_template_render`

🎀 `before_layout_render`

🎀 `before_serializer`

🦋 `after_deserializer`

🦋 `after_file_render`

🦋 `after_template_render`

🦋 `after_layout_render`

🦋 `after`

🦋 `after_error_render`

🌈 `on_handler_exception`

🌈 `on_reset_state`

🌈 `on_route_exception`

🍓 `info`

🍓 `layout`

🍓 `logger`

🧁 `load`

🧁 `load_app`

💜 `mime`

🌸 `params`

🌸 `param`

🌸 `param_array`

💅 `pass`

💅 `patch`

🛤️ `path` — wait, `path`

📮 `post`

🎀 `prefix`

🗑️ `del`

🧐 `options`

📤 `put`

🔁 `redirect`

🖼️ `render_with_layout`

📨 `request`

🛑 `send_error`

📁 `send_file`

⚙️ `set`

🔍 `setting`

🍪 `set_cookie`