Mojolicious::Routes::Route(3)

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.

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

  new
  my $r = Mojolicious::Routes::Route->new;
  my $r = Mojolicious::Routes::Route->new('/:action');
  my $r = Mojolicious::Routes::Route->new('/:action', action => qr/\w+/);
  my $r = Mojolicious::Routes::Route->new(format => 0);

Construct a new Mojolicious::Routes::Route object and "parse" pattern if necessary.

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

SEE ALSO
Mojolicious, Mojolicious::Guides, <http://mojolicious.org>.