NAME

Dancer - lightweight yet powerful web application framework

SYNOPSIS

    #!/usr/bin/perl
    use Dancer;

    get '/hello/:name' => sub {
        return "Why, hello there " . params->{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(before after get post);

    # 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();

FUNCTIONS

after

Add a hook at the after position:

    after sub {
        my $response = shift;
        # do something with request
    };

The anonymous function which is given to after will be executed after having executed a route.

You can define multiple after filters, using the after helper as many times as you wish; each filter will be executed, in the order you added them.

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

Defines a before filter:

    before sub {
        # do something with request, vars or params
    };

The anonymous function given to before will be executed before executing a route handler to handle the request.

If the function modifies the request's path_info or method, a new search for a matching route is performed and the filter is re-executed. Considering that this can lead to an infinite loop, this mechanism is stopped after 10 times with an exception.

The before filter can set a response with a redirection code (either 301 or 302): in this case the matched route (if any) will be ignored and the redirection will be performed immediately.

You can define multiple before filters, using the before helper as many times as you wish; each filter will be executed in the order you added them.

before_template

Defines a before_template filter:

    before_template sub {
        my $tokens = shift;
        # do something with request, vars or params
    };

The anonymous function which is given to before_template will be executed before sending data and tokens to the template. Receives a HashRef of the tokens that will be inserted into the template.

This filter works as the before and after filter.

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 (ot set it). Note that this method will eventually be preferred to 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

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 params->{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 params->{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.

debug

Logs a message of debug level:

    debug "This is a debug message";

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";

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 qr{ /demo/articles/(.+) }x => sub {
        my ($article_id) = splat;

        # you'll have to implement this next sub yourself :)
        change_the_main_database_to_demo();

        forward '/articles/$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.

Broader functionality might be added in the future.

It is important to note that issuing a forward by itself does not exit and forward immediately, forwarding is deferred until after the current route or filter has been processed. To exit and forward immediately, use the return function, e.g.

    get '/some/path => sub {
        if ($condition) {
            return forward '/articles/$article_id';
        }

        more_stuff();
    };

You probably always want 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";
    }

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:

    before sub {
        if ($some_condition) {
            return halt("Unauthorized");
        }
    };

    get '/' => sub {
        "hello there";
    };

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_serialization => sub {
    my $response = shift;
    $response->content->{generated_at} = localtime();
  };

Supported before hooks (in order of execution):

before_deserializer

This hook receives no arguments.

  hook before_deserializer {
    ...
  };

before_file_render

This hook receives as argument the path of the file to render.

  hook before_file_render {
    my $path = shift;
    ...
  };

before_error_render

This hook receives as argument a Dancer::Error object.

  hook before_error_render => sub {
    my $error = shift;
  };

before

This is an alias to before.

This hook receives no arguments.

  before sub {
    ...
  };

is equivalent to

  hook before sub {
    ...
  };

before_template_render

This is an alias to 'before_template'.

This hook receives as argument a HashRef, containing the tokens.

  hook before_template_render sub {
    my $tokens = shift;
    delete $tokens->{user};
  };

is equivalent to

  hook before_template sub {
    my $tokens = shift;
    delete $tokens->{user};
  };

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_serialization

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 receives as argument a Dancer::Response object.

  hook after sub {
    my $response = shift;
  };

This is equivalent to

  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;
  };

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 takes care to set the libdir to the current ./lib directory:

    # if we have lib/Webapp.pm, we can load it like:
    load_app 'Webapp';

Note that a package loaded using load_app must import Dancer with the :syntax option, in order not to change the application directory (which has been previously set for the caller script).

mime_type

Deprecated. See "mime".

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.

pass

This method should be called from a route handler. Tells Dancer to pass the processing of the request to the next matching route.

You should always return after calling pass:

    get '/some/route' => sub {
        if (...) {
            # we want to let the next matching route handler process this one
            return pass();
        }
    };

path

Concatenates multiple paths together, without worrying about the underlying operating system:

    my $path = path(dirname($0), 'lib', 'File.pm');

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

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.

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

This will not cause your route handler to return immediately, so be careful that your route handler doesn't then override the error. You can avoid that by saying return send_error(...) instead.

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 absolute option (see below).

    get '/download/:file' => sub {
        send_file(params->{file});
    }

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:

    send_file(params->{file}, content_type => 'image/png');

Also, you can use your aliases or file extension names on content_type, like this:

    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.

   send_file('/etc/passwd', system_path => 1);

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;
        ...
    };

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

Tells the route handler to build a response with the current template engine:

    get '/' => sub {
        ...
        template 'some_view', { token => 'value'};
    };

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.tt', {}, { layout => undef };
    };

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

Defines a variable shared between filters and route handlers.

    before sub {
        var foo => 42;
    };

Route handlers and other filters will be able to read that variable with the vars keyword.

vars

Returns the HashRef of all shared variables set during the filter/route chain:

    get '/path' => sub {
        if (vars->{foo} eq 42) {
            ...
        }
    };

warning

Logs a warning message through the current logger engine.

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 http://github.com/sukria/Dancer

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.perldancer.org/cgi-bin/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

LICENSE

This module is free software and is published under the same terms as Perl itself.

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.

cpanm Dancer

perl -MCPAN -e shell
install Dancer