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.
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('/:foo');
my $route = $r->any('/:foo' => sub {...});
my $route = $r->any('/:foo' => {foo => 'bar'} => sub {...});
my $route = $r->any('/:foo' => [foo => qr/\w+/] => sub {...});
my $route = $r->any(['GET', 'POST'] => '/:foo' => sub {...});
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. See also Mojolicious::Guides::Tutorial for many more argument variations.
# Route with destination
$r->any('/user')->to('user#whatever');
delete
my $route = $r->delete('/:foo');
my $route = $r->delete('/:foo' => sub {...});
my $route = $r->delete('/:foo' => {foo => 'bar'} => sub {...});
my $route = $r->delete('/:foo' => [foo => qr/\w+/] => sub {...});
Generate Mojolicious::Routes::Route object matching only "DELETE" requests. See also Mojolicious::Guides::Tutorial for many more argument variations.
# Route with destination
$r->delete('/user')->to('user#remove');
detour
$r = $r->detour(action => 'foo');
$r = $r->detour('controller#action');
$r = $r->detour(Mojolicious->new, foo => 'bar');
$r = $r->detour('MyApp', {foo => 'bar'});
Set default parameters for this route and allow partial matching to simplify application embedding, takes the same arguments as ``to''.
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('/:foo');
my $route = $r->get('/:foo' => sub {...});
my $route = $r->get('/:foo' => {foo => 'bar'} => sub {...});
my $route = $r->get('/:foo' => [foo => qr/\w+/] => sub {...});
Generate Mojolicious::Routes::Route object matching only "GET" requests. See also Mojolicious::Guides::Tutorial for many more argument variations.
# 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_websocket
my $bool = $r->is_websocket;
Check if this route is a WebSocket.
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('/:foo');
my $route = $r->options('/:foo' => sub {...});
my $route = $r->options('/:foo' => {foo => 'bar'} => sub {...});
my $route = $r->options('/:foo' => [foo => qr/\w+/] => sub {...});
Generate Mojolicious::Routes::Route object matching only "OPTIONS" requests. See also Mojolicious::Guides::Tutorial for many more argument variations.
# Route with destination
$r->options('/user')->to('user#overview');
over
my $over = $r->over;
$r = $r->over(foo => 1);
$r = $r->over(foo => 1, bar => {baz => 'yada'});
$r = $r->over([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')->over(host => qr/mojolicious\.org/)->to('foo#bar');
parse
$r = $r->parse('/:action');
$r = $r->parse('/:action', action => qr/\w+/);
$r = $r->parse(format => 0);
Parse pattern.
patch
my $route = $r->patch('/:foo');
my $route = $r->patch('/:foo' => sub {...});
my $route = $r->patch('/:foo' => {foo => 'bar'} => sub {...});
my $route = $r->patch('/:foo' => [foo => qr/\w+/] => sub {...});
Generate Mojolicious::Routes::Route object matching only "PATCH" requests. See also Mojolicious::Guides::Tutorial for many more argument variations.
# Route with destination
$r->patch('/user')->to('user#update');
post
my $route = $r->post('/:foo');
my $route = $r->post('/:foo' => sub {...});
my $route = $r->post('/:foo' => {foo => 'bar'} => sub {...});
my $route = $r->post('/:foo' => [foo => qr/\w+/] => sub {...});
Generate Mojolicious::Routes::Route object matching only "POST" requests. See also Mojolicious::Guides::Tutorial for many more argument variations.
# Route with destination
$r->post('/user')->to('user#create');
put
my $route = $r->put('/:foo');
my $route = $r->put('/:foo' => sub {...});
my $route = $r->put('/:foo' => {foo => 'bar'} => sub {...});
my $route = $r->put('/:foo' => [foo => qr/\w+/] => sub {...});
Generate Mojolicious::Routes::Route object matching only "PUT" requests. See also Mojolicious::Guides::Tutorial for many more argument variations.
# 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->route('/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.
route
my $route = $r->route;
my $route = $r->route('/:action');
my $route = $r->route('/:action', action => qr/\w+/);
my $route = $r->route(format => 0);
Low-level generator for routes matching all HTTP request methods, returns a Mojolicious::Routes::Route object.
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 {...});
my $route = $r->under('/:foo' => sub {...});
my $route = $r->under('/:foo' => {foo => 'bar'});
my $route = $r->under('/:foo' => [foo => qr/\w+/]);
my $route = $r->under([format => 0]);
Generate Mojolicious::Routes::Route object for a nested route with its own intermediate destination. See also Mojolicious::Guides::Tutorial for many more argument variations.
# 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');
via
my $methods = $r->via;
$r = $r->via('GET');
$r = $r->via('GET', 'POST');
$r = $r->via(['GET', 'POST']);
Restrict HTTP methods this route is allowed to handle, defaults to no restrictions.
# Route with two methods and destination
$r->route('/foo')->via('GET', 'POST')->to('foo#bar');
websocket
my $route = $r->websocket('/:foo');
my $route = $r->websocket('/:foo' => sub {...});
my $route = $r->websocket('/:foo' => {foo => 'bar'} => sub {...});
my $route = $r->websocket('/:foo' => [foo => qr/\w+/] => sub {...});
Generate Mojolicious::Routes::Route object matching only WebSocket handshakes. See also Mojolicious::Guides::Tutorial for many more argument variations.
# Route with destination
$r->websocket('/echo')->to('example#echo');
AUTOLOAD
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 {
my ($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');