Mojolicious::Routes::Route(3p)

NAME
Mojolicious::Routes::Route - Route container

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.

  "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::Route->new]);

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

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

Allow "bridge" semantics for this route.

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

The parent of this route, used for nesting routes.

  "partial"
  my $partial = $r->partial;
  $r          = $r->partial(1);

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 ones.

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

Construct a new Mojolicious::Routes::Route object.

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

Add a new child to this route.

  "any"
  my $route = $r->any('/:foo' => sub {...});
  my $route = $r->any(['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.

  $r->any('/user')->to('user#whatever');

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

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

  my $auth = $r->bridge('/user')->to('user#auth');
  $auth->route('/show')->to('#show');
  $auth->route('/create')->to('#create');

  "delete"
  my $route = $r->delete('/:foo' => sub {...});

Generate route matching only "DELETE" requests. See also the Mojolicious::Lite tutorial for more argument variations.

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

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

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

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

  $r->find('show_user')->to(foo => 'bar');

  "get"
  my $route = $r->get('/:foo' => sub {...});

Generate route matching only "GET" requests. See also the Mojolicious::Lite tutorial for more argument variations.

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

  "has_conditions"
  my $success = $r->has_conditions;

Check if this route has active conditions.

  "has_custom_name"
  my $success = $r->has_custom_name;

Check if this route has a custom name.

  "has_websocket"
  my $success = $r->has_websocket;

Check if this route has a WebSocket ancestor.

  "is_endpoint"
  my $success = $r->is_endpoint;

Check if this route qualifies as an endpoint.

  "is_websocket"
  my $success = $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 refering to the current route.

  $r->get('/user')->to('user#show')->name('show_user');

  "options"
  my $route = $r->options('/:foo' => sub {...});

Generate route matching only "OPTIONS" requests. See also the Mojolicious::Lite tutorial for more argument variations.

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

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

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

  $r->route('/foo')->over(host => qr/mojolicio\.us/)->to('foo#bar');

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

Parse a pattern.

  "patch"
  my $route = $r->patch('/:foo' => sub {...});

Generate route matching only "PATCH" requests. See also the Mojolicious::Lite tutorial for more argument variations.

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

  "post"
  my $route = $r->post('/:foo' => sub {...});

Generate route matching only "POST" requests. See also the Mojolicious::Lite tutorial for more argument variations.

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

  "put"
  my $route = $r->put('/:foo' => sub {...});

Generate route matching only "PUT" requests. See also the Mojolicious::Lite tutorial for more argument variations.

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

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

Render route with parameters into a path.

  "root"
  my $root = $r->root;

The Mojolicious::Routes object this route is an ancestor of.

  #r->root->caching(0);

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

Add a new nested child to this route.

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

Stringify the whole route.

  "under"
  my $route = $r->under(sub {...});
  my $route = $r->under('/:foo');

Generate bridge. See also the Mojolicious::Lite tutorial for more argument variations.

  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(qw/GET POST/);
  $r          = $r->via([qw/GET POST/]);

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

  $r->route('/foo')->via(qw/GET POST/)->to('foo#bar');

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

Add a waypoint to this route as nested child.

  my $foo = $r->waypoint('/foo')->to('example#foo');
  $foo->route('/bar')->to('#bar');

  "websocket"
  my $websocket = $r->websocket('/:foo' => sub {...});

Generate route matching only "WebSocket" handshakes. See also the Mojolicious::Lite tutorial for more argument variations.

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

SHORTCUTS
In addition to the attributes and methods above you can also call shortcuts on Mojolicious::Routes::Route objects.

  $r->add_shortcut(firefox => sub {
    my ($r, $path) = @_;
    $r->get($path, agent => qr/Firefox/);
  });

  $r->firefox('/welcome')->to('firefox#welcome');
  $r->firefox('/bye')->to('firefox#bye);

SEE ALSO
Mojolicious, Mojolicious::Guides, <http://mojolicio.us>.