CONTENTS

• NAME
• SYNOPSIS
• DESCRIPTION
• ATTRIBUTES
  • children
  • inline
  • parent
  • partial
  • pattern
• METHODS
  • add_child
  • any
  • delete
  • find
  • get
  • has_custom_name
  • has_websocket
  • is_endpoint
  • is_reserved
  • is_websocket
  • methods
  • name
  • options
  • parse
  • patch
  • post
  • put
  • remove
  • render
  • root
  • requires
  • suggested_method
  • to
  • to_string
  • under
  • websocket
• SHORTCUTS
• SEE ALSO

#NAME

Mojolicious::Routes::Route - Route

#SYNOPSIS

use Mojolicious::Routes::Route;

my $r = Mojolicious::Routes::Route->new;

#DESCRIPTION

Mojolicious::Routes::Route is the route container used by Mojolicious::Routes.

#ATTRIBUTES

Mojolicious::Routes::Route implements the following attributes.

#children

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

The children of this route, used for nesting routes.

#inline

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

Allow "under" semantics for this route.

#parent

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

The parent of this route, usually a Mojolicious::Routes::Route object. Note that this attribute is weakened.

#partial

my $bool = $r->partial;
$r       = $r->partial($bool);

Route has no specific end, remaining characters will be captured in path.

#pattern

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

Pattern for this route, defaults to a Mojolicious::Routes::Pattern object.

#METHODS

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

#add_child

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

Add a child to this route, it will be automatically removed from its current parent if necessary.

# Reattach route
$r->add_child($r->find('foo'));

#any

my $route = $r->any;
my $route = $r->any('/:foo');
my $route = $r->any('/:foo' => sub ($c) {...});
my $route = $r->any('/:foo' => sub ($c) {...} => 'name');
my $route = $r->any('/:foo' => {foo => 'bar'} => sub ($c) {...});
my $route = $r->any('/:foo' => [foo => qr/\w+/] => sub ($c) {...});
my $route = $r->any('/:foo' => (agent => qr/Firefox/) => sub ($c) {...});
my $route = $r->any(['GET', 'POST'] => '/:foo' => sub ($c) {...});
my $route = $r->any(['GET', 'POST'] => '/:foo' => [foo => qr/\w+/]);

Generate Mojolicious::Routes::Route object matching any of the listed HTTP request methods or all.

# Route with pattern and destination
$r->any('/user')->to('user#whatever');

All arguments are optional, but some have to appear in a certain order, like the two supported array reference values, which contain the HTTP methods to match and restrictive placeholders.

# Route with HTTP methods, pattern, restrictive placeholders and destination
$r->any(['DELETE', 'PUT'] => '/:foo' => [foo => qr/\w+/])->to('foo#bar');

There are also two supported string values, containing the route pattern and the route name, defaulting to the pattern / and a name based on the pattern.

# Route with pattern, name and destination
$r->any('/:foo' => 'foo_route')->to('foo#bar');

An arbitrary number of key/value pairs in between the route pattern and name can be used to specify route conditions.

# Route with pattern, condition and destination
$r->any('/' => (agent => qr/Firefox/))->to('foo#bar');

A hash reference is used to specify optional placeholders and default values for the stash.

# Route with pattern, optional placeholder and destination
$r->any('/:foo' => {foo => 'bar'})->to('foo#bar');

And a code reference can be used to specify a cb value to be merged into the default values for the stash.

# Route with pattern and a closure as destination
$r->any('/:foo' => sub ($c) {
  $c->render(text => 'Hello World!');
});

See Mojolicious::Guides::Tutorial and Mojolicious::Guides::Routing for more information.

#delete

my $route = $r->delete;
my $route = $r->delete('/:foo');
my $route = $r->delete('/:foo' => sub ($c) {...});
my $route = $r->delete('/:foo' => sub ($c) {...} => 'name');
my $route = $r->delete('/:foo' => {foo => 'bar'} => sub ($c) {...});
my $route = $r->delete('/:foo' => [foo => qr/\w+/] => sub ($c) {...});
my $route = $r->delete('/:foo' => (agent => qr/Firefox/) => sub ($c) {...});

Generate Mojolicious::Routes::Route object matching only DELETE requests, takes the same arguments as "any" (except for the HTTP methods to match, which are implied). See Mojolicious::Guides::Tutorial and Mojolicious::Guides::Routing for more information.

# Route with destination
$r->delete('/user')->to('user#remove');

#find

my $route = $r->find('foo');

Find child route by name, custom names have precedence over automatically generated ones.

# Change default parameters of a named route
$r->find('show_user')->to(foo => 'bar');

#get

my $route = $r->get;
my $route = $r->get('/:foo');
my $route = $r->get('/:foo' => sub ($c) {...});
my $route = $r->get('/:foo' => sub ($c) {...} => 'name');
my $route = $r->get('/:foo' => {foo => 'bar'} => sub ($c) {...});
my $route = $r->get('/:foo' => [foo => qr/\w+/] => sub ($c) {...});
my $route = $r->get('/:foo' => (agent => qr/Firefox/) => sub ($c) {...});

Generate Mojolicious::Routes::Route object matching only GET requests, takes the same arguments as "any" (except for the HTTP methods to match, which are implied). See Mojolicious::Guides::Tutorial and Mojolicious::Guides::Routing for more information.

# Route with destination
$r->get('/user')->to('user#show');

#has_custom_name

my $bool = $r->has_custom_name;

Check if this route has a custom name.

#has_websocket

my $bool = $r->has_websocket;

Check if this route has a WebSocket ancestor and cache the result for future checks.

#is_endpoint

my $bool = $r->is_endpoint;

Check if this route qualifies as an endpoint.

#is_reserved

my $bool = $r->is_reserved('controller');

Check if string is a reserved stash value.

#is_websocket

my $bool = $r->is_websocket;

Check if this route is a WebSocket.

#methods

my $methods = $r->methods;
$r          = $r->methods('GET');
$r          = $r->methods('GET', 'POST');
$r          = $r->methods(['GET', 'POST']);

Restrict HTTP methods this route is allowed to handle, defaults to no restrictions.

# Route with two methods and destination
$r->any('/foo')->methods('GET', 'POST')->to('foo#bar');

#name

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

The name of this route, defaults to an automatically generated name based on the route pattern. Note that the name current is reserved for referring to the current route.

# Route with destination and custom name
$r->get('/user')->to('user#show')->name('show_user');

#options

my $route = $r->options;
my $route = $r->options('/:foo');
my $route = $r->options('/:foo' => sub ($c) {...});
my $route = $r->options('/:foo' => sub ($c) {...} => 'name');
my $route = $r->options('/:foo' => {foo => 'bar'} => sub ($c) {...});
my $route = $r->options('/:foo' => [foo => qr/\w+/] => sub ($c) {...});
my $route = $r->options('/:foo' => (agent => qr/Firefox/) => sub ($c) {...});

Generate Mojolicious::Routes::Route object matching only OPTIONS requests, takes the same arguments as "any" (except for the HTTP methods to match, which are implied). See Mojolicious::Guides::Tutorial and Mojolicious::Guides::Routing for more information.

# Route with destination
$r->options('/user')->to('user#overview');

#parse

$r = $r->parse('/user/:id');
$r = $r->parse('/user/:id', id => qr/\d+/);
$r = $r->parse(format => ['json', 'yaml']);

Parse pattern.

#patch

my $route = $r->patch;
my $route = $r->patch('/:foo');
my $route = $r->patch('/:foo' => sub ($c) {...});
my $route = $r->patch('/:foo' => sub ($c) {...} => 'name');
my $route = $r->patch('/:foo' => {foo => 'bar'} => sub ($c) {...});
my $route = $r->patch('/:foo' => [foo => qr/\w+/] => sub ($c) {...});
my $route = $r->patch('/:foo' => (agent => qr/Firefox/) => sub ($c) {...});

Generate Mojolicious::Routes::Route object matching only PATCH requests, takes the same arguments as "any" (except for the HTTP methods to match, which are implied). See Mojolicious::Guides::Tutorial and Mojolicious::Guides::Routing for more information.

# Route with destination
$r->patch('/user')->to('user#update');

#post

my $route = $r->post;
my $route = $r->post('/:foo');
my $route = $r->post('/:foo' => sub ($c) {...});
my $route = $r->post('/:foo' => sub ($c) {...} => 'name');
my $route = $r->post('/:foo' => {foo => 'bar'} => sub ($c) {...});
my $route = $r->post('/:foo' => [foo => qr/\w+/] => sub ($c) {...});
my $route = $r->post('/:foo' => (agent => qr/Firefox/) => sub ($c) {...});

Generate Mojolicious::Routes::Route object matching only POST requests, takes the same arguments as "any" (except for the HTTP methods to match, which are implied). See Mojolicious::Guides::Tutorial and Mojolicious::Guides::Routing for more information.

# Route with destination
$r->post('/user')->to('user#create');

#put

my $route = $r->put;
my $route = $r->put('/:foo');
my $route = $r->put('/:foo' => sub ($c) {...});
my $route = $r->put('/:foo' => sub ($c) {...} => 'name');
my $route = $r->put('/:foo' => {foo => 'bar'} => sub ($c) {...});
my $route = $r->put('/:foo' => [foo => qr/\w+/] => sub ($c) {...});
my $route = $r->put('/:foo' => (agent => qr/Firefox/) => sub ($c) {...});

Generate Mojolicious::Routes::Route object matching only PUT requests, takes the same arguments as "any" (except for the HTTP methods to match, which are implied). See Mojolicious::Guides::Tutorial and Mojolicious::Guides::Routing for more information.

# Route with destination
$r->put('/user')->to('user#replace');

#remove

$r = $r->remove;

Remove route from parent.

# Remove route completely
$r->find('foo')->remove;

# Reattach route to new parent
$r->any('/foo')->add_child($r->find('bar')->remove);

#render

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

Render route with parameters into a path.

#root

my $root = $r->root;

The Mojolicious::Routes object this route is a descendant of.

#requires

my $requires = $r->requires;
$r           = $r->requires(foo => 1);
$r           = $r->requires(foo => 1, bar => {baz => 'yada'});
$r           = $r->requires([foo => 1, bar => {baz => 'yada'}]);

Activate conditions for this route. Note that this automatically disables the routing cache, since conditions are too complex for caching.

# Route with condition and destination
$r->get('/foo')->requires(host => qr/mojolicious\.org/)->to('foo#bar');

#suggested_method

my $method = $r->suggested_method;

Suggested HTTP method for reaching this route, GET and POST are preferred.

#to

my $defaults = $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(Mojolicious->new);
$r           = $r->to(Mojolicious->new, foo => 'bar');
$r           = $r->to(Mojolicious->new, {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 $str = $r->to_string;

Stringify the whole route.

#under

my $route = $r->under(sub ($c) {...});
my $route = $r->under('/:foo' => sub ($c) {...});
my $route = $r->under('/:foo' => {foo => 'bar'});
my $route = $r->under('/:foo' => [foo => qr/\w+/]);
my $route = $r->under('/:foo' => (agent => qr/Firefox/));
my $route = $r->under([format => ['json', 'yaml']]);

Generate Mojolicious::Routes::Route object for a nested route with its own intermediate destination, takes the same arguments as "any" (except for the HTTP methods to match, which are not available). See Mojolicious::Guides::Tutorial and Mojolicious::Guides::Routing for more information.

# Longer version
$r->any('/:foo' => sub ($c) {...})->inline(1);

# Intermediate destination and prefix shared between two routes
my $auth = $r->under('/user')->to('user#auth');
$auth->get('/show')->to('#show');
$auth->post('/create')->to('#create');

#websocket

my $route = $r->websocket;
my $route = $r->websocket('/:foo');
my $route = $r->websocket('/:foo' => sub ($c) {...});
my $route = $r->websocket('/:foo' => sub ($c) {...} => 'name');
my $route = $r->websocket('/:foo' => {foo => 'bar'} => sub ($c) {...});
my $route = $r->websocket('/:foo' => [foo => qr/\w+/] => sub ($c) {...});
my $route = $r->websocket('/:foo' => (agent => qr/Firefox/) => sub ($c) {...});

Generate Mojolicious::Routes::Route object matching only WebSocket handshakes, takes the same arguments as "any" (except for the HTTP methods to match, which are implied). See Mojolicious::Guides::Tutorial and Mojolicious::Guides::Routing for more information.

# Route with destination
$r->websocket('/echo')->to('example#echo');

#SHORTCUTS

In addition to the "ATTRIBUTES" and "METHODS" above you can also call shortcuts provided by "root" on Mojolicious::Routes::Route objects.

# Add a "firefox" shortcut
$r->root->add_shortcut(firefox => sub ($r, $path) {
  $r->get($path, agent => qr/Firefox/);
});

# Use "firefox" shortcut to generate routes
$r->firefox('/welcome')->to('firefox#welcome');
$r->firefox('/bye')->to('firefox#bye');

#SEE ALSO

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

CPANdoc Browser is maintained by Dan Book (DBOOK). Please contact him via the GitHub issue tracker or email regarding any issues with the site itself, search, or rendering of documentation.

CPAN module documentation is maintained by each author and maintainer individually. Please contact them via the mechanisms listed in their documentation or on the module's MetaCPAN page to report any issues with the contents or format of the documentation.