GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages


Manual Reference Pages  -  MOJOLICIOUS::ROUTES::ROUTE (3)

.ds Aq ’

NAME

Mojolicious::Routes::Route - Route

CONTENTS

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



SEE ALSO

Mojolicious, Mojolicious::Guides, <http://mojolicious.org>.
Search for    or go to Top of page |  Section 3 |  Main Index


perl v5.20.3 MOJOLICIOUS::ROUTES::ROUTE (3) 2016-03-15

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.