---
name: "MojoX::Routes"
section: "3pm"
platform: "linux"
package: "libmojolicious-perl"
version: "0.999926-1+squeeze2"
release: "Debian 6.0 (Squeeze)"
platforms: ["linux"]
url: "https://new.carta.tech/MojoX::Routes"
---

# MojoX::Routes(3pm)

Always Find Your Destination With Routes

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

### "name"

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

The name of this route.

### "parent"

```
    my $parent = $r->parent;
    $r         = $r->parent(MojoX::Routes->new);
```

The parent of this route, used for nesting routes.

### "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\_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.

### "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'});
```

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