The Perl Toolchain Summit needs more sponsors. If your company depends on Perl, please support this very important event.
 / 
Mojolicious-0.999938
River stage four • 943 direct dependents • 1041 total dependents
495 ++
/ Mojolicious::Routes

NAME

Mojolicious::Routes - Always Find Your Destination With Routes

SYNOPSIS

    use Mojolicious::Routes;

    # New routes tree
    my $r = Mojolicious::Routes->new;

    # Normal route matching "/articles" with parameters "controller" and
    # "action"
    $r->route('/articles')->to(controller => 'article', action => 'list');

    # Route with a placeholder matching everything but "/" and "."
    $r->route('/:controller')->to(action => 'list');

    # Route with a placeholder and regex constraint
    $r->route('/articles/:id', id => qr/\d+/)
      ->to(controller => 'article', action => 'view');

    # Route with an optional parameter "year"
    $r->route('/archive/:year')
      ->to(controller => 'archive', action => 'list', year => undef);

    # Nested route for two actions sharing the same "controller" parameter
    my $books = $r->route('/books/:id')->to(controller => 'book');
    $books->route('/edit')->to(action => 'edit');
    $books->route('/delete')->to(action => 'delete');

    # Bridges can be used to chain multiple routes
    $r->bridge->to(controller => 'foo', action =>'auth')
      ->route('/blog')->to(action => 'list');

    # Waypoints are similar to bridges and nested routes but can also match
    # if they are not the actual endpoint of the whole route
    my $b = $r->waypoint('/books')->to(controller => 'books', action => 'list');
    $b->route('/:id', id => qr/\d+/)->to(action => 'view');

DESCRIPTION

Mojolicious::Routes is a very powerful implementation of the famous routes pattern and the core of the Mojolicious web framework.

ATTRIBUTES

Mojolicious::Routes implements the following attributes.

block

    my $block = $r->block;
    $r        = $r->block(1);

Allow this route to match even if it's not an endpoint, used for waypoints.

children

    my $children = $r->children;
    $r           = $r->children([Mojolicious::Routes->new]);

The children of this routes object, used for nesting routes.

conditions

    my $conditions  = $r->conditions;
    $r              = $r->conditions([foo => qr/\w+/]);

Contains condition parameters for this route, used for over.

controller_base_class

    my $base = $r->controller_base_class;
    $r       = $r->controller_base_class('Mojolicious::Controller');

Base class used to identify controllers, defaults to Mojolicious::Controller.

dictionary

    my $dictionary = $r->dictionary;
    $r             = $r->dictionary({foo => sub { ... }});

Contains all available conditions for this route. There are currently two conditions built in, method and websocket.

hidden

    my $hidden = $r->hidden;
    $r         = $r->hidden([qw/new attr tx render req res stash/]);

Controller methods and attributes that are hidden from routes.

inline

    my $inline = $r->inline;
    $r         = $r->inline(1);

Allow bridge semantics for this route.

namespace

    my $namespace = $r->namespace;
    $r            = $r->namespace('Foo::Bar::Controller');

Namespace to search for controllers.

parent

    my $parent = $r->parent;
    $r         = $r->parent(Mojolicious::Routes->new);

The parent of this route, used for nesting routes.

partial

    my $partial = $r->partial;
    $r          = $r->partial('path');

Route has no specific end, remaining characters will be captured with the partial name. Note that this attribute is EXPERIMENTAL and might change without warning!

pattern

    my $pattern = $r->pattern;
    $r          = $r->pattern(Mojolicious::Routes::Pattern->new);

Pattern for this route, by default a Mojolicious::Routes::Pattern object and used for matching.

METHODS

Mojolicious::Routes inherits all methods from Mojo::Base and implements the following ones.

new

    my $r = Mojolicious::Routes->new;
    my $r = Mojolicious::Routes->new('/:controller/:action');

Construct a new route object.

add_child

    $r = $r->add_child(Mojolicious::Route->new);

Add a new child to this route.

add_condition

    $r = $r->add_condition(foo => sub { ... });

Add a new condition for this route.

auto_render

    $r->auto_render(Mojolicious::Controller->new);

Automatic rendering.

bridge

    my $bridge = $r->bridge;
    my $bridge = $r->bridge('/:controller/:action');

Add a new bridge to this route as a nested child.

detour

    $r = $r->detour(action => 'foo');
    $r = $r->detour({action => 'foo'});
    $r = $r->detour('controller#action');
    $r = $r->detour('controller#action', foo => 'bar');
    $r = $r->detour('controller#action', {foo => 'bar'});
    $r = $r->detour($app);
    $r = $r->detour($app, foo => 'bar');
    $r = $r->detour($app, {foo => 'bar'});
    $r = $r->detour('MyApp');
    $r = $r->detour('MyApp', foo => 'bar');
    $r = $r->detour('MyApp', {foo => 'bar'});

Set default parameters for this route and allow partial matching to simplify application embedding. Note that this method is EXPERIMENTAL and might change without warning!

dispatch

    my $e = $r->dispatch(Mojolicious::Controller->new);

Match routes and dispatch.

hide

    $r = $r->hide('new');

Hide controller method or attribute from routes.

is_endpoint

    my $is_endpoint = $r->is_endpoint;

Returns true if this route qualifies as an endpoint.

is_websocket

    my $is_websocket = $r->is_websocket;

Returns true if this route leads to a WebSocket.

name

    my $name = $r->name;
    $r       = $r->name('foo');
    $r       = $r->name('*');

The name of this route, the special value * will generate a name based on the route pattern. Note that the name current is reserved for refering to the current route.

over

    $r = $r->over(foo => qr/\w+/);

Apply condition parameters to this route.

parse

    $r = $r->parse('/:controller/:action');

Parse a pattern.

render

    my $path = $r->render($path);
    my $path = $r->render($path, {foo => 'bar'});

Render route with parameters into a path.

route

    my $route = $r->route('/:c/:a', a => qr/\w+/);

Add a new nested child to this route.

to

    my $to  = $r->to;
    $r = $r->to(action => 'foo');
    $r = $r->to({action => 'foo'});
    $r = $r->to('controller#action');
    $r = $r->to('controller#action', foo => 'bar');
    $r = $r->to('controller#action', {foo => 'bar'});
    $r = $r->to($app);
    $r = $r->to($app, foo => 'bar');
    $r = $r->to($app, {foo => 'bar'});
    $r = $r->to('MyApp');
    $r = $r->to('MyApp', foo => 'bar');
    $r = $r->to('MyApp', {foo => 'bar'});

Set default parameters for this route.

to_string

    my $string = $r->to_string;

Stringifies the whole route.

via

    $r = $r->via('get');
    $r = $r->via(qw/get post/);
    $r = $r->via([qw/get post/]);

Apply method constraint to this route.

waypoint

    my $route = $r->waypoint('/:c/:a', a => qr/\w+/);

Add a waypoint to this route as nested child.

websocket

    $route->websocket;

Apply websocket constraint to this route.

SEE ALSO

Mojolicious, Mojolicious::Guides, http://mojolicious.org.