pub struct Route {
pub name: Option<Cow<'static, str>>,
pub method: Method,
pub handler: Box<dyn Handler>,
pub uri: RouteUri<'static>,
pub rank: isize,
pub format: Option<MediaType>,
/* private fields */
}
Expand description
A request handling route.
A route consists of exactly the information in its fields. While a Route
can be instantiated directly, doing so should be a rare or nonexistent
event. Instead, a Rocket application should use Rocket’s
#[route]
series of attributes to generate a Route
.
#[get("/route/<path..>?query", rank = 2, format = "json")]
fn route_name(path: PathBuf) { /* handler procedure */ }
use rocket::http::{Method, MediaType};
let route = routes![route_name].remove(0);
assert_eq!(route.name.unwrap(), "route_name");
assert_eq!(route.method, Method::Get);
assert_eq!(route.uri, "/route/<path..>?query");
assert_eq!(route.rank, 2);
assert_eq!(route.format.unwrap(), MediaType::JSON);
Note that the rank
and format
attribute parameters are optional. See
#[route]
for details on macro usage. Note also that
a route’s mounted base becomes part of its URI; see RouteUri
for
details.
Routing
A request is routed to a route if it has the highest precedence (lowest
rank) among all routes that match the request. See
Route::matches()
for details on what it means for a request to match.
Note that a single request may be routed to multiple routes if a route
forwards. If a route fails, the request is instead routed to the highest
precedence Catcher
.
Collisions
Two routes are said to collide if there exists a
request that matches both routes. Colliding routes present a routing
ambiguity and are thus disallowed by Rocket. Because routes can be
constructed dynamically, collision checking is done at
ignite
time, after it becomes statically
impossible to add any more routes to an instance of Rocket
.
Note that because query parsing is always lenient – extra and missing query parameters are allowed – queries do not directly impact whether two routes collide.
Resolving Collisions
Collisions are resolved through ranking. Routes with lower ranks have
higher precedence during routing than routes with higher ranks. Thus, routes
are attempted in ascending rank order. If a higher precedence route returns
an Outcome
of Forward
, the next highest precedence route is attempted,
and so on, until a route returns Success
or Failure
, or there are no
more routes to try. When all routes have been attempted, Rocket issues a
404
error, handled by the appropriate Catcher
.
Default Ranking
Most collisions are automatically resolved by Rocket’s default rank. The default rank prefers static components over dynamic components in both paths and queries: the more static a route’s path and query are, the lower its rank and thus the higher its precedence.
There are three “colors” to paths and queries:
static
- all components are staticpartial
- at least one, but not all, components are dynamicwild
- all components are dynamic
Static paths carry more weight than static queries. The same is true for partial and wild paths. This results in the following default ranking table:
path | query | rank |
---|---|---|
static | static | -12 |
static | partial | -11 |
static | wild | -10 |
static | none | -9 |
partial | static | -8 |
partial | partial | -7 |
partial | wild | -6 |
partial | none | -5 |
wild | static | -4 |
wild | partial | -3 |
wild | wild | -2 |
wild | none | -1 |
Recall that lower ranks have higher precedence.
Example
use rocket::Route;
use rocket::http::Method;
macro_rules! assert_rank {
($($uri:expr => $rank:expr,)*) => {$(
let route = Route::new(Method::Get, $uri, rocket::route::dummy_handler);
assert_eq!(route.rank, $rank);
)*}
}
assert_rank! {
"/?foo" => -12, // static path, static query
"/foo/bar?a=b&bob" => -12, // static path, static query
"/?a=b&bob" => -12, // static path, static query
"/?a&<zoo..>" => -11, // static path, partial query
"/foo?a&<zoo..>" => -11, // static path, partial query
"/?a&<zoo>" => -11, // static path, partial query
"/?<zoo..>" => -10, // static path, wild query
"/foo?<zoo..>" => -10, // static path, wild query
"/foo?<a>&<b>" => -10, // static path, wild query
"/" => -9, // static path, no query
"/foo/bar" => -9, // static path, no query
"/a/<b>?foo" => -8, // partial path, static query
"/a/<b..>?foo" => -8, // partial path, static query
"/<a>/b?foo" => -8, // partial path, static query
"/a/<b>?<b>&c" => -7, // partial path, partial query
"/a/<b..>?a&<c..>" => -7, // partial path, partial query
"/a/<b>?<c..>" => -6, // partial path, wild query
"/a/<b..>?<c>&<d>" => -6, // partial path, wild query
"/a/<b..>?<c>" => -6, // partial path, wild query
"/a/<b>" => -5, // partial path, no query
"/<a>/b" => -5, // partial path, no query
"/a/<b..>" => -5, // partial path, no query
"/<b>/<c>?foo&bar" => -4, // wild path, static query
"/<a>/<b..>?foo" => -4, // wild path, static query
"/<b..>?cat" => -4, // wild path, static query
"/<b>/<c>?<foo>&bar" => -3, // wild path, partial query
"/<a>/<b..>?a&<b..>" => -3, // wild path, partial query
"/<b..>?cat&<dog>" => -3, // wild path, partial query
"/<b>/<c>?<foo>" => -2, // wild path, wild query
"/<a>/<b..>?<b..>" => -2, // wild path, wild query
"/<b..>?<c>&<dog>" => -2, // wild path, wild query
"/<b>/<c>" => -1, // wild path, no query
"/<a>/<b..>" => -1, // wild path, no query
"/<b..>" => -1, // wild path, no query
}
Fields§
§name: Option<Cow<'static, str>>
The name of this route, if one was given.
method: Method
The method this route matches against.
handler: Box<dyn Handler>
The function that should be called when the route matches.
uri: RouteUri<'static>
The route URI.
rank: isize
The rank of this route. Lower ranks have higher priorities.
format: Option<MediaType>
The media type this route matches against, if any.
Implementations§
source§impl Route
impl Route
sourcepub fn new<H: Handler>(method: Method, uri: &str, handler: H) -> Route
pub fn new<H: Handler>(method: Method, uri: &str, handler: H) -> Route
Creates a new route with the given method, path, and handler with a base
of /
and a computed default rank.
Panics
Panics if path
is not a valid Rocket route URI.
A valid route URI is any valid Origin
URI that is
normalized, that is, does not contain any empty segments except for an
optional trailing slash. Unlike a strict Origin
, route URIs are also
allowed to contain any UTF-8 characters.
Example
use rocket::Route;
use rocket::http::Method;
// this is a route matching requests to `GET /`
let index = Route::new(Method::Get, "/", handler);
assert_eq!(index.rank, -9);
assert_eq!(index.method, Method::Get);
assert_eq!(index.uri, "/");
sourcepub fn ranked<H, R>(rank: R, method: Method, uri: &str, handler: H) -> Routewhere
H: Handler + 'static,
R: Into<Option<isize>>,
pub fn ranked<H, R>(rank: R, method: Method, uri: &str, handler: H) -> Routewhere H: Handler + 'static, R: Into<Option<isize>>,
Creates a new route with the given rank, method, path, and handler with
a base of /
. If rank
is None
, the computed default
rank is used.
Panics
Panics if path
is not a valid Rocket route URI.
A valid route URI is any valid Origin
URI that is
normalized, that is, does not contain any empty segments except for an
optional trailing slash. Unlike a strict Origin
, route URIs are also
allowed to contain any UTF-8 characters.
Example
use rocket::Route;
use rocket::http::Method;
let foo = Route::ranked(1, Method::Post, "/foo?bar", handler);
assert_eq!(foo.rank, 1);
assert_eq!(foo.method, Method::Post);
assert_eq!(foo.uri, "/foo?bar");
let foo = Route::ranked(None, Method::Post, "/foo?bar", handler);
assert_eq!(foo.rank, -12);
assert_eq!(foo.method, Method::Post);
assert_eq!(foo.uri, "/foo?bar");
sourcepub fn rebase(self, base: Origin<'_>) -> Self
pub fn rebase(self, base: Origin<'_>) -> Self
Prefix base
to any existing mount point base in self
.
If the the current mount point base is /
, then the base is replaced by
base
. Otherwise, base
is prefixed to the existing base
.
use rocket::Route;
use rocket::http::Method;
// The default base is `/`.
let index = Route::new(Method::Get, "/foo/bar", handler);
// Since the base is `/`, rebasing replaces the base.
let rebased = index.rebase(uri!("/boo"));
assert_eq!(rebased.uri.base(), "/boo");
// Now every rebase prefixes.
let rebased = rebased.rebase(uri!("/base"));
assert_eq!(rebased.uri.base(), "/base/boo");
// Rebasing to `/` does nothing.
let rebased = rebased.rebase(uri!("/"));
assert_eq!(rebased.uri.base(), "/base/boo");
// Note that trailing slashes are preserved:
let index = Route::new(Method::Get, "/foo", handler);
let rebased = index.rebase(uri!("/boo/"));
assert_eq!(rebased.uri.base(), "/boo/");
sourcepub fn map_base<'a, F>(self, mapper: F) -> Result<Self, Error<'static>>where
F: FnOnce(Origin<'a>) -> String,
pub fn map_base<'a, F>(self, mapper: F) -> Result<Self, Error<'static>>where F: FnOnce(Origin<'a>) -> String,
Maps the base
of this route using mapper
, returning a new Route
with the returned base.
Note: Prefer to use Route::rebase()
whenever possible!
mapper
is called with the current base. The returned String
is used
as the new base if it is a valid URI. If the returned base URI contains
a query, it is ignored. Returns an error if the base produced by
mapper
is not a valid origin URI.
Example
use rocket::Route;
use rocket::http::Method;
let index = Route::new(Method::Get, "/foo/bar", handler);
assert_eq!(index.uri.base(), "/");
assert_eq!(index.uri.unmounted().path(), "/foo/bar");
assert_eq!(index.uri.path(), "/foo/bar");
let mapped = index.map_base(|base| format!("{}{}", "/boo", base)).unwrap();
assert_eq!(mapped.uri.base(), "/boo/");
assert_eq!(mapped.uri.unmounted().path(), "/foo/bar");
assert_eq!(mapped.uri.path(), "/boo/foo/bar");
// Note that this produces different `base` results than `rebase`!
let rebased = index.rebase(uri!("/boo"));
assert_eq!(rebased.uri.base(), "/boo");
assert_eq!(rebased.uri.unmounted().path(), "/foo/bar");
assert_eq!(rebased.uri.path(), "/boo/foo/bar");
source§impl Route
impl Route
sourcepub fn collides_with(&self, other: &Route) -> bool
pub fn collides_with(&self, other: &Route) -> bool
Returns true
if self
collides with other
.
A collision between two routes occurs when there exists a request that could match either route. That is, a routing ambiguity would ensue if both routes were made available to the router.
Specifically, a collision occurs when two routes a
and b
:
- Have the same method.
- Have the same rank.
- The routes’ methods don’t support a payload or the routes’
methods support a payload and the formats overlap. Formats overlap
when:
- The top-level type of either is
*
or the top-level types are equivalent. - The sub-level type of either is
*
or the sub-level types are equivalent.
- The top-level type of either is
- Have overlapping route URIs. This means that either:
- The URIs have the same number of segments
n
, and fori
in0..n
, eithera.uri[i]
is dynamic orb.uri[i]
is dynamic or they’re both static with the same value. - One URI has fewer segments and ends with a trailing dynamic parameter and the preceeding segments in both routes match the conditions above.
- The URIs have the same number of segments
Collisions are symmetric: for any routes a
and b
,
a.collides_with(b) => b.collides_with(a)
.
Example
use rocket::Route;
use rocket::http::{Method, MediaType};
// Two routes with the same method, rank, URI, and formats collide.
let a = Route::new(Method::Get, "/", handler);
let b = Route::new(Method::Get, "/", handler);
assert!(a.collides_with(&b));
// Two routes with the same method, rank, URI, and overlapping formats.
let mut a = Route::new(Method::Post, "/", handler);
a.format = Some(MediaType::new("*", "custom"));
let mut b = Route::new(Method::Post, "/", handler);
b.format = Some(MediaType::new("text", "*"));
assert!(a.collides_with(&b));
// Two routes with different ranks don't collide.
let a = Route::ranked(1, Method::Get, "/", handler);
let b = Route::ranked(2, Method::Get, "/", handler);
assert!(!a.collides_with(&b));
// Two routes with different methods don't collide.
let a = Route::new(Method::Put, "/", handler);
let b = Route::new(Method::Post, "/", handler);
assert!(!a.collides_with(&b));
// Two routes with non-overlapping URIs do not collide.
let a = Route::new(Method::Get, "/foo", handler);
let b = Route::new(Method::Get, "/bar/<baz>", handler);
assert!(!a.collides_with(&b));
// Two payload-supporting routes with non-overlapping formats.
let mut a = Route::new(Method::Post, "/", handler);
a.format = Some(MediaType::HTML);
let mut b = Route::new(Method::Post, "/", handler);
b.format = Some(MediaType::JSON);
assert!(!a.collides_with(&b));
// Two non payload-supporting routes with non-overlapping formats
// collide. A request with `Accept: */*` matches both.
let mut a = Route::new(Method::Get, "/", handler);
a.format = Some(MediaType::HTML);
let mut b = Route::new(Method::Get, "/", handler);
b.format = Some(MediaType::JSON);
assert!(a.collides_with(&b));
source§impl Route
impl Route
sourcepub fn matches(&self, request: &Request<'_>) -> bool
pub fn matches(&self, request: &Request<'_>) -> bool
Returns true
if self
matches request
.
A match occurs when:
- The route’s method matches that of the incoming request.
- Either the route has no format or:
- If the route’s method supports a payload, the request’s
Content-Type
is fully specified and collides with the route’s format. - If the route’s method does not support a payload, the request
either has no
Accept
header or it collides with with the route’s format.
- If the route’s method supports a payload, the request’s
- All static segments in the route’s URI match the corresponding components in the same position in the incoming request URI.
- The route URI has no query part or all static segments in the route’s query string are in the request query string, though in any position.
For a request to be routed to a particular route, that route must both
match
and have the highest precedence among all matching routes for
that request. In other words, a match
is a necessary but insufficient
condition to determine if a route will handle a particular request.
The precedence of a route is determined by its rank. Routes with lower ranks have higher precedence. By default, more specific routes are assigned a lower ranking.
Example
use rocket::Route;
use rocket::http::Method;
// This route handles GET requests to `/<hello>`.
let a = Route::new(Method::Get, "/<hello>", handler);
// This route handles GET requests to `/здрасти`.
let b = Route::new(Method::Get, "/здрасти", handler);
// Let's say `request` is `GET /hello`. The request matches only `a`:
let request = client.get("/hello");
assert!(a.matches(&request));
assert!(!b.matches(&request));
// Now `request` is `GET /здрасти`. It matches both `a` and `b`:
let request = client.get("/здрасти");
assert!(a.matches(&request));
assert!(b.matches(&request));
// But `b` is more specific, so it has lower rank (higher precedence)
// by default, so Rocket would route the request to `b`, not `a`.
assert!(b.rank < a.rank);
Trait Implementations§
source§impl<'r> FromRequest<'r> for &'r Route
impl<'r> FromRequest<'r> for &'r Route
§type Error = Infallible
type Error = Infallible
Auto Trait Implementations§
impl !RefUnwindSafe for Route
impl Send for Route
impl Sync for Route
impl Unpin for Route
impl !UnwindSafe for Route
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoCollection<T> for T
impl<T> IntoCollection<T> for T
source§impl<T> Paint for Twhere
T: ?Sized,
impl<T> Paint for Twhere T: ?Sized,
source§fn fg(&self, value: Color) -> Painted<&T>
fn fg(&self, value: Color) -> Painted<&T>
Returns a styled value derived from self
with the foreground set to
value
.
This method should be used rarely. Instead, prefer to use color-specific
builder methods like red()
and
green()
, which have the same functionality but are
pithier.
Example
Set foreground color to white using fg()
:
use yansi::{Paint, Color};
painted.fg(Color::White);
Set foreground color to white using white()
.
use yansi::Paint;
painted.white();
source§fn bright_black(&self) -> Painted<&T>
fn bright_black(&self) -> Painted<&T>
source§fn bright_red(&self) -> Painted<&T>
fn bright_red(&self) -> Painted<&T>
source§fn bright_green(&self) -> Painted<&T>
fn bright_green(&self) -> Painted<&T>
source§fn bright_yellow(&self) -> Painted<&T>
fn bright_yellow(&self) -> Painted<&T>
Returns self
with the
fg()
set to
Color::BrightYellow
.
Example
println!("{}", value.bright_yellow());
source§fn bright_blue(&self) -> Painted<&T>
fn bright_blue(&self) -> Painted<&T>
source§fn bright_magenta(&self) -> Painted<&T>
fn bright_magenta(&self) -> Painted<&T>
Returns self
with the
fg()
set to
Color::BrightMagenta
.
Example
println!("{}", value.bright_magenta());
source§fn bright_cyan(&self) -> Painted<&T>
fn bright_cyan(&self) -> Painted<&T>
source§fn bright_white(&self) -> Painted<&T>
fn bright_white(&self) -> Painted<&T>
source§fn bg(&self, value: Color) -> Painted<&T>
fn bg(&self, value: Color) -> Painted<&T>
Returns a styled value derived from self
with the background set to
value
.
This method should be used rarely. Instead, prefer to use color-specific
builder methods like on_red()
and
on_green()
, which have the same functionality but
are pithier.
Example
Set background color to red using fg()
:
use yansi::{Paint, Color};
painted.bg(Color::Red);
Set background color to red using on_red()
.
use yansi::Paint;
painted.on_red();
source§fn on_primary(&self) -> Painted<&T>
fn on_primary(&self) -> Painted<&T>
source§fn on_magenta(&self) -> Painted<&T>
fn on_magenta(&self) -> Painted<&T>
source§fn on_bright_black(&self) -> Painted<&T>
fn on_bright_black(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightBlack
.
Example
println!("{}", value.on_bright_black());
source§fn on_bright_red(&self) -> Painted<&T>
fn on_bright_red(&self) -> Painted<&T>
source§fn on_bright_green(&self) -> Painted<&T>
fn on_bright_green(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightGreen
.
Example
println!("{}", value.on_bright_green());
source§fn on_bright_yellow(&self) -> Painted<&T>
fn on_bright_yellow(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightYellow
.
Example
println!("{}", value.on_bright_yellow());
source§fn on_bright_blue(&self) -> Painted<&T>
fn on_bright_blue(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightBlue
.
Example
println!("{}", value.on_bright_blue());
source§fn on_bright_magenta(&self) -> Painted<&T>
fn on_bright_magenta(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightMagenta
.
Example
println!("{}", value.on_bright_magenta());
source§fn on_bright_cyan(&self) -> Painted<&T>
fn on_bright_cyan(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightCyan
.
Example
println!("{}", value.on_bright_cyan());
source§fn on_bright_white(&self) -> Painted<&T>
fn on_bright_white(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightWhite
.
Example
println!("{}", value.on_bright_white());
source§fn attr(&self, value: Attribute) -> Painted<&T>
fn attr(&self, value: Attribute) -> Painted<&T>
Enables the styling Attribute
value
.
This method should be used rarely. Instead, prefer to use
attribute-specific builder methods like bold()
and
underline()
, which have the same functionality
but are pithier.
Example
Make text bold using attr()
:
use yansi::{Paint, Attribute};
painted.attr(Attribute::Bold);
Make text bold using using bold()
.
use yansi::Paint;
painted.bold();
source§fn underline(&self) -> Painted<&T>
fn underline(&self) -> Painted<&T>
Returns self
with the
attr()
set to
Attribute::Underline
.
Example
println!("{}", value.underline());
source§fn rapid_blink(&self) -> Painted<&T>
fn rapid_blink(&self) -> Painted<&T>
Returns self
with the
attr()
set to
Attribute::RapidBlink
.
Example
println!("{}", value.rapid_blink());
source§fn quirk(&self, value: Quirk) -> Painted<&T>
fn quirk(&self, value: Quirk) -> Painted<&T>
Enables the yansi
Quirk
value
.
This method should be used rarely. Instead, prefer to use quirk-specific
builder methods like mask()
and
wrap()
, which have the same functionality but are
pithier.
Example
Enable wrapping using .quirk()
:
use yansi::{Paint, Quirk};
painted.quirk(Quirk::Wrap);
Enable wrapping using wrap()
.
use yansi::Paint;
painted.wrap();
source§fn whenever(&self, value: Condition) -> Painted<&T>
fn whenever(&self, value: Condition) -> Painted<&T>
Conditionally enable styling based on whether the Condition
value
applies. Replaces any previous condition.
See the crate level docs for more details.
Example
Enable styling painted
only when both stdout
and stderr
are TTYs:
use yansi::{Paint, Condition};
painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);