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');
# Simplified Mojolicious::Lite style route generation is also possible
$r->get('/')->to(controller => 'blog', action => 'welcome');
my $blog = $r->under('/blog');
$blog->post('/list')->to('blog#list');
$blog->get(sub { shift->render(text => 'Go away!') });DESCRIPTION
Mojolicious::Routes is a very powerful implementation of the famous routes pattern and the core of the Mojolicious web framework. See Mojolicious::Guide::Routing for more.
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.
any
my $any = $route->any('/:foo' => sub {...});
my $any = $route->any([qw/get post/] => '/:foo' => sub {...});Generate route matching any of the listed HTTP request methods or all. See also the Mojolicious::Lite tutorial for more argument variations. Note that this method is EXPERIMENTAL and might change without warning!
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.
del
my $del = $route->del('/:foo' => sub {...});Generate route matching only DELETE requests. See also the Mojolicious::Lite tutorial for more argument variations. Note that this method is EXPERIMENTAL and might change without warning!
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.
get
my $get = $route->get('/:foo' => sub {...});Generate route matching only GET requests. See also the Mojolicious::Lite tutorial for more argument variations. Note that this method is EXPERIMENTAL and might change without warning!
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.
post
my $post = $route->post('/:foo' => sub {...});Generate route matching only POST requests. See also the Mojolicious::Lite tutorial for more argument variations. Note that this method is EXPERIMENTAL and might change without warning!
put
my $put = $route->put('/:foo' => sub {...});Generate route matching only PUT requests. See also the Mojolicious::Lite tutorial for more argument variations. Note that this method is EXPERIMENTAL and might change without warning!
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.
under
my $under = $route->under(sub {...});
my $under = $route->under('/:foo');Generate bridges. See also the Mojolicious::Lite tutorial for more argument variations. Note that this method is EXPERIMENTAL and might change without warning!
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
my $websocket = $route->websocket('/:foo' => sub {...});Generate route matching only WebSocket handshakes. See also the Mojolicious::Lite tutorial for more argument variations. Note that this method is EXPERIMENTAL and might change without warning!