Linux Certif

Toute la documentation sur la certification Linux LPI

MojoX::Routes.3pm

NAME

MojoX::Routes - Always Find Your Destination With Routes

SYNOPSIS

     use MojoX::Routes;
 
     # New routes tree
     my $r = MojoX::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');
 
 

DESCRIPTION

MojoX::Routes is a very powerful implementation of the famous routes pattern and the core of the Mojolicious web framework.

ATTRIBUTES

MojoX::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([MojoX::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".

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

inline

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

Allow "bridge" semantics for this route.

parent

     my $parent = $r->parent;
     $r         = $r->parent(MojoX::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(MojoX::Routes::Pattern->new);
 
 

Pattern for this route, by default a MojoX::Routes::Pattern object and used for matching.

METHODS

MojoX::Routes inherits all methods from Mojo::Base and implements the following ones.

new

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

Construct a new route object.

add_child

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

Add a new child to this route.

add_condition

     $r = $r->add_condition(foo => sub { ... });
 
 

Add a new condition for this route.

bridge

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

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

is_endpoint

     my $is_endpoint = $r->is_endpoint;
 
 

Returns true if this route qualifies as an endpoint.

name

     my $name = $r->name;
     $r       = $r->name('foo');
     $r       = $r->name('*');
 
 

The name of this route.

over

     $r = $r->over(foo => qr/\w+/);
     $r = $r->over({foo => qr/\w+/});
 
 

Apply condition parameters to this route.

parse

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

Parse a pattern.

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.

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

     $route->websocket;
 
 

Apply "websocket" constraint to this route.

SEE ALSO

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