Routing
=======
@todo Note that this documentation is for the new routing interface
not available in master at this point.
Purpose
-------
Cowboy does nothing by default.
To make Cowboy useful, you need to map URLs to Erlang modules that will
handle the requests. This is called routing.
When Cowboy receives a request, it tries to match the requested host and
path to the resources given in the dispatch rules. If it matches, then
the associated Erlang code will be executed.
Routing rules are given per host. Cowboy will first match on the host,
and then try to find a matching path.
Routes need to be compiled before they can be used by Cowboy.
Structure
---------
The general structure for the routes is defined as follow.
``` erlang
Routes = [Host1, Host2, ... HostN].
```
Each host contains matching rules for the host along with optional
constraints, and a list of routes for the path component.
``` erlang
Host1 = {HostMatch, PathsList}.
Host2 = {HostMatch, Constraints, PathsList}.
```
The list of routes for the path component is defined similar to the
list of hosts.
``` erlang
PathsList = [Path1, Path2, ... PathN].
```
Finally, each path contains matching rules for the path along with
optional constraints, and gives us the handler module to be used
along with options that will be given to it on initialization.
```
Path1 = {PathMatch, Handler, Module}.
Path2 = {PathMatch, Constraints, Handler, Module}.
```
Continue reading to learn more about the match syntax and the optional
constraints.
Match syntax
------------
The match syntax is used to associate host names and paths with their
respective handlers.
The match syntax is the same for host and path with a few subtleties.
Indeed, the segments separator is different, and the host is matched
starting from the last segment going to the first. All examples will
feature both host and path match rules and explain the differences
when encountered.
Excluding special values that we will explain at the end of this section,
the simplest match value is a host or a path. It can be given as either
a `string()` or a `binary()`.
``` erlang
PathMatch1 = "/".
PathMatch2 = "/path/to/resource".
HostMatch1 = "cowboy.example.org".
```
As you can see, all paths defined this way must start with a slash
character. Note that these two paths are identical as far as routing
is concerned.
``` erlang
PathMatch2 = "/path/to/resource".
PathMatch3 = "/path/to/resource/".
```
Hosts with and without a trailing dot are equivalent for routing.
``` erlang
HostMatch1 = "cowboy.example.org".
HostMatch2 = "cowboy.example.org.".
```
It is possible to extract segments of the host and path and to store
the values in the `Req` object for later use. We call these kind of
values bindings.
The syntax for bindings is very simple. A segment that begins with
the `:` character means that what follows until the end of the segment
is the name of the binding in which the segment value will be stored.
``` erlang
PathMatch = "/hats/:name/prices".
HostMatch = ":subdomain.example.org".
```
If these two end up matching when routing, you will end up with two
bindings defined, `subdomain` and `hat_name`, each containing the
segment value where they were defined. For example, the URL
`http://test.example.org/hats/wild_cowboy_legendary/prices` will
result in having the value `test` bound to the name `subdomain`
and the value `wild_cowboy_legendary` bound to the name `hat_name`.
They can later be retrieved using `cowboy_req:binding/{2,3}`.
@todo special binding `'_'`
@todo optional path or segments
@todo same binding twice (+ optional + host/path)
Constraints
-----------
@todo Describe constraints.
Compilation
-----------
The structure defined in this chapter needs to be compiled before it is
passed to Cowboy. This allows Cowboy to efficiently lookup the correct
handler to run instead of having to parse the routes repeatedly.
This can be done with a simple call to `cowboy_routing:compile/1`.
@todo Note that the `routes` option will be specified slightly differently
when middleware support gets in.
``` erlang
{ok, Routes} = cowboy_routing:compile([
%% {URIHost, list({URIPath, Handler, Opts})}
{'_', [{'_', my_handler, []}]}
]),
%% Name, NbAcceptors, TransOpts, ProtoOpts
cowboy:start_http(my_http_listener, 100,
[{port, 8080}],
[{routes, Routes}]
).
```
Note that this function will return `{error, badarg}` if the structure
given is incorrect.
