rwf2
/
Rocket
mirror of https://github.com/rwf2/Rocket.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rename 'URI' to 'Uri'.

This commit is contained in:
Sergio Benitez 2017-09-13 02:12:48 -07:00
parent b033a2e2a9
commit 5efc4b1096
13 changed files with 121 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
codegen/src/macros/uri.rs
View File

@ -137,6 +137,6 @@ pub fn uri_internal(
MacEager::expr(quote_expr!(ecx, {
$argument_stmts
::rocket::http::uri::URI::from(format!($fmt_string, $format_assign_tokens))
::rocket::http::uri::Uri::from(format!($fmt_string, $format_assign_tokens))
}))
}

8
codegen/src/parser/route.rs
View File

@ -10,7 +10,7 @@ use super::Function;
use super::keyvalue::KVSpanned;
use super::uri::validate_uri;
use rocket::http::{Method, MediaType};
use rocket::http::uri::URI;
use rocket::http::uri::Uri;
/// This structure represents the parsed `route` attribute.
///
@ -22,7 +22,7 @@ use rocket::http::uri::URI;
pub struct RouteParams {
pub annotated_fn: Function,
pub method: Spanned<Method>,
pub uri: Spanned<URI<'static>>,
pub uri: Spanned<Uri<'static>>,
pub data_param: Option<KVSpanned<Ident>>,
pub query_param: Option<Spanned<Ident>>,
pub format: Option<KVSpanned<MediaType>>,
@ -185,7 +185,7 @@ fn parse_method(ecx: &ExtCtxt, meta_item: &NestedMetaItem) -> Spanned<Method> {
fn parse_path(ecx: &ExtCtxt,
meta_item: &NestedMetaItem)
-> (Spanned<URI<'static>>, Option<Spanned<Ident>>) {
-> (Spanned<Uri<'static>>, Option<Spanned<Ident>>) {
let sp = meta_item.span();
if let Some((name, lit)) = meta_item.name_value() {
if name != &"path" {
@ -205,7 +205,7 @@ fn parse_path(ecx: &ExtCtxt,
.emit();
}
(dummy_spanned(URI::new("")), None)
(dummy_spanned(Uri::new("")), None)
}
fn parse_opt<O, T, F>(ecx: &ExtCtxt, kv: &KVSpanned<T>, f: F) -> Option<KVSpanned<O>>

14
codegen/src/parser/uri.rs
View File

@ -2,7 +2,7 @@ use syntax::ast::*;
use syntax::codemap::{Span, Spanned, dummy_spanned};
use syntax::ext::base::ExtCtxt;
use rocket::http::uri::URI;
use rocket::http::uri::Uri;
use super::route::param_to_ident;
use utils::{span, SpanExt, is_valid_ident};
@ -11,7 +11,7 @@ use utils::{span, SpanExt, is_valid_ident};
// stripped out at runtime. So, to avoid any confusion, we issue an error at
// compile-time for empty segments. At the moment, this disallows trailing
// slashes as well, since then the last segment is empty.
fn valid_path(ecx: &ExtCtxt, uri: &URI, sp: Span) -> bool {
fn valid_path(ecx: &ExtCtxt, uri: &Uri, sp: Span) -> bool {
let cleaned = uri.to_string();
if !uri.as_str().starts_with('/') {
ecx.struct_span_err(sp, "route paths must be absolute")
@ -28,7 +28,7 @@ fn valid_path(ecx: &ExtCtxt, uri: &URI, sp: Span) -> bool {
false
}
fn valid_segments(ecx: &ExtCtxt, uri: &URI, sp: Span) -> bool {
fn valid_segments(ecx: &ExtCtxt, uri: &Uri, sp: Span) -> bool {
let mut validated = true;
let mut segments_span = None;
for segment in uri.segments() {
@ -81,7 +81,7 @@ fn valid_segments(ecx: &ExtCtxt, uri: &URI, sp: Span) -> bool {
}
validated = false;
} else if URI::percent_encode(segment) != segment {
} else if Uri::percent_encode(segment) != segment {
if segment.contains("<") || segment.contains(">") {
ecx.struct_span_err(span, "malformed parameter")
.help("parameters must be of the form '<param>'")
@ -100,8 +100,8 @@ fn valid_segments(ecx: &ExtCtxt, uri: &URI, sp: Span) -> bool {
pub fn validate_uri(ecx: &ExtCtxt,
string: &str,
sp: Span)
-> (Spanned<URI<'static>>, Option<Spanned<Ident>>) {
let uri = URI::from(string.to_string());
-> (Spanned<Uri<'static>>, Option<Spanned<Ident>>) {
let uri = Uri::from(string.to_string());
let query_param = string.find('?')
.map(|i| span(&string[(i + 1)..], sp.trim_left(i + 1)))
.and_then(|spanned_q_param| param_to_ident(ecx, spanned_q_param));
@ -109,6 +109,6 @@ pub fn validate_uri(ecx: &ExtCtxt,
if valid_segments(ecx, &uri, sp) && valid_path(ecx, &uri, sp) {
(span(uri, sp), query_param)
} else {
(dummy_spanned(URI::new("")), query_param)
(dummy_spanned(Uri::new("")), query_param)
}
}

4
codegen/tests/typed-uris.rs
View File

@ -7,7 +7,7 @@ extern crate rocket;
use std::fmt;
use rocket::http::{RawStr, Cookies};
use rocket::http::uri::{URI, UriDisplay};
use rocket::http::uri::{Uri, UriDisplay};
use rocket::request::Form;
#[derive(FromForm)]
@ -71,7 +71,7 @@ fn complex<'r>(
) -> &'static str { "" }
macro assert_uri_eq($($uri:expr => $expected:expr,)+) {
$(assert_eq!($uri, URI::from($expected));)+
$(assert_eq!($uri, Uri::from($expected));)+
}
#[test]

126
lib/src/http/uri.rs
View File

@ -19,7 +19,7 @@ const EMPTY: isize = -1;
// TODO: Reconsider deriving PartialEq and Eq to make "//a/b" == "/a/b".
/// Borrowed string type for absolute URIs.
#[derive(Debug)]
pub struct URI<'a> {
pub struct Uri<'a> {
uri: Cow<'a, str>,
path: Index,
query: Option<Index>,
@ -28,10 +28,10 @@ pub struct URI<'a> {
segment_count: AtomicIsize,
}
impl<'a> URI<'a> {
impl<'a> Uri<'a> {
/// Constructs a new URI from a given string. The URI is assumed to be an
/// absolute, well formed URI.
pub fn new<T: Into<Cow<'a, str>>>(uri: T) -> URI<'a> {
pub fn new<T: Into<Cow<'a, str>>>(uri: T) -> Uri<'a> {
let uri = uri.into();
let qmark = uri.find('?');
let hmark = uri.find('#');
@ -44,7 +44,7 @@ impl<'a> URI<'a> {
(None, None) => ((0, end), None, None),
};
URI {
Uri {
uri: uri,
path: path,
query: query,
@ -64,18 +64,18 @@ impl<'a> URI<'a> {
/// A valid URI with only non-empty segments:
///
/// ```rust
/// use rocket::http::uri::URI;
/// use rocket::http::uri::Uri;
///
/// let uri = URI::new("/a/b/c");
/// let uri = Uri::new("/a/b/c");
/// assert_eq!(uri.segment_count(), 3);
/// ```
///
/// A URI with empty segments:
///
/// ```rust
/// use rocket::http::uri::URI;
/// use rocket::http::uri::Uri;
///
/// let uri = URI::new("/a/b//c/d///e");
/// let uri = Uri::new("/a/b//c/d///e");
/// assert_eq!(uri.segment_count(), 5);
/// ```
#[inline(always)]
@ -101,9 +101,9 @@ impl<'a> URI<'a> {
/// A valid URI with only non-empty segments:
///
/// ```rust
/// use rocket::http::uri::URI;
/// use rocket::http::uri::Uri;
///
/// let uri = URI::new("/a/b/c?a=true#done");
/// let uri = Uri::new("/a/b/c?a=true#done");
/// for (i, segment) in uri.segments().enumerate() {
/// match i {
/// 0 => assert_eq!(segment, "a"),
@ -117,9 +117,9 @@ impl<'a> URI<'a> {
/// A URI with empty segments:
///
/// ```rust
/// use rocket::http::uri::URI;
/// use rocket::http::uri::Uri;
///
/// let uri = URI::new("///a//b///c////d?#");
/// let uri = Uri::new("///a//b///c////d?#");
/// for (i, segment) in uri.segments().enumerate() {
/// match i {
/// 0 => assert_eq!(segment, "a"),
@ -142,18 +142,18 @@ impl<'a> URI<'a> {
/// A URI with only a path:
///
/// ```rust
/// use rocket::http::uri::URI;
/// use rocket::http::uri::Uri;
///
/// let uri = URI::new("/a/b/c");
/// let uri = Uri::new("/a/b/c");
/// assert_eq!(uri.path(), "/a/b/c");
/// ```
///
/// A URI with other components:
///
/// ```rust
/// use rocket::http::uri::URI;
/// use rocket::http::uri::Uri;
///
/// let uri = URI::new("/a/b/c?name=bob#done");
/// let uri = Uri::new("/a/b/c?name=bob#done");
/// assert_eq!(uri.path(), "/a/b/c");
/// ```
#[inline(always)]
@ -170,18 +170,18 @@ impl<'a> URI<'a> {
/// A URI with a query part:
///
/// ```rust
/// use rocket::http::uri::URI;
/// use rocket::http::uri::Uri;
///
/// let uri = URI::new("/a/b/c?alphabet=true");
/// let uri = Uri::new("/a/b/c?alphabet=true");
/// assert_eq!(uri.query(), Some("alphabet=true"));
/// ```
///
/// A URI without the query part:
///
/// ```rust
/// use rocket::http::uri::URI;
/// use rocket::http::uri::Uri;
///
/// let uri = URI::new("/a/b/c");
/// let uri = Uri::new("/a/b/c");
/// assert_eq!(uri.query(), None);
/// ```
#[inline(always)]
@ -197,18 +197,18 @@ impl<'a> URI<'a> {
/// A URI with a fragment part:
///
/// ```rust
/// use rocket::http::uri::URI;
/// use rocket::http::uri::Uri;
///
/// let uri = URI::new("/a?alphabet=true#end");
/// let uri = Uri::new("/a?alphabet=true#end");
/// assert_eq!(uri.fragment(), Some("end"));
/// ```
///
/// A URI without the fragment part:
///
/// ```rust
/// use rocket::http::uri::URI;
/// use rocket::http::uri::Uri;
///
/// let uri = URI::new("/a?query=true");
/// let uri = Uri::new("/a?query=true");
/// assert_eq!(uri.fragment(), None);
/// ```
#[inline(always)]
@ -222,10 +222,10 @@ impl<'a> URI<'a> {
/// # Examples
///
/// ```rust
/// use rocket::http::uri::URI;
/// use rocket::http::uri::Uri;
///
/// let uri = URI::new("/Hello%2C%20world%21");
/// let decoded_path = URI::percent_decode(uri.path().as_bytes()).expect("decoded");
/// let uri = Uri::new("/Hello%2C%20world%21");
/// let decoded_path = Uri::percent_decode(uri.path().as_bytes()).expect("decoded");
/// assert_eq!(decoded_path, "/Hello, world!");
/// ```
pub fn percent_decode(string: &[u8]) -> Result<Cow<str>, Utf8Error> {
@ -240,10 +240,10 @@ impl<'a> URI<'a> {
/// # Examples
///
/// ```rust
/// use rocket::http::uri::URI;
/// use rocket::http::uri::Uri;
///
/// let uri = URI::new("/Hello%2C%20world%21");
/// let decoded_path = URI::percent_decode_lossy(uri.path().as_bytes());
/// let uri = Uri::new("/Hello%2C%20world%21");
/// let decoded_path = Uri::percent_decode_lossy(uri.path().as_bytes());
/// assert_eq!(decoded_path, "/Hello, world!");
/// ```
pub fn percent_decode_lossy(string: &[u8]) -> Cow<str> {
@ -258,9 +258,9 @@ impl<'a> URI<'a> {
/// # Examples
///
/// ```rust
/// use rocket::http::uri::URI;
/// use rocket::http::uri::Uri;
///
/// let encoded = URI::percent_encode("hello?a=<b>hi</b>");
/// let encoded = Uri::percent_encode("hello?a=<b>hi</b>");
/// assert_eq!(encoded, "hello%3Fa=%3Cb%3Ehi%3C%2Fb%3E");
/// ```
pub fn percent_encode(string: &str) -> Cow<str> {
@ -276,9 +276,9 @@ impl<'a> URI<'a> {
/// ### Example
///
/// ```rust
/// use rocket::http::uri::URI;
/// use rocket::http::uri::Uri;
///
/// let uri = URI::new("/a/b///c/d/e//f?name=Mike#end");
/// let uri = Uri::new("/a/b///c/d/e//f?name=Mike#end");
/// assert_eq!(uri.as_str(), "/a/b///c/d/e//f?name=Mike#end");
/// ```
#[inline(always)]
@ -287,10 +287,10 @@ impl<'a> URI<'a> {
}
}
impl<'a> Clone for URI<'a> {
impl<'a> Clone for Uri<'a> {
#[inline(always)]
fn clone(&self) -> URI<'a> {
URI {
fn clone(&self) -> Uri<'a> {
Uri {
uri: self.uri.clone(),
path: self.path,
query: self.query,
@ -300,32 +300,32 @@ impl<'a> Clone for URI<'a> {
}
}
impl<'a, 'b> PartialEq<URI<'b>> for URI<'a> {
impl<'a, 'b> PartialEq<Uri<'b>> for Uri<'a> {
#[inline]
fn eq(&self, other: &URI<'b>) -> bool {
fn eq(&self, other: &Uri<'b>) -> bool {
self.path() == other.path() &&
self.query() == other.query() &&
self.fragment() == other.fragment()
}
}
impl<'a> Eq for URI<'a> {}
impl<'a> Eq for Uri<'a> {}
impl<'a> From<&'a str> for URI<'a> {
impl<'a> From<&'a str> for Uri<'a> {
#[inline(always)]
fn from(uri: &'a str) -> URI<'a> {
URI::new(uri)
fn from(uri: &'a str) -> Uri<'a> {
Uri::new(uri)
}
}
impl From<String> for URI<'static> {
impl From<String> for Uri<'static> {
#[inline(always)]
fn from(uri: String) -> URI<'static> {
URI::new(uri)
fn from(uri: String) -> Uri<'static> {
Uri::new(uri)
}
}
impl<'a> fmt::Display for URI<'a> {
impl<'a> fmt::Display for Uri<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// If this is the root path, then there are "zero" segments.
if self.segment_count() == 0 {
@ -427,9 +427,9 @@ impl<'a> fmt::Display for URI<'a> {
/// When manually implementing `UriDisplay` for your types, you should defer to
/// existing implementations of `UriDisplay` as much as possible. In the example
/// below, for instance, `Name`'s implementation defers to `String`'s
/// implementation. To percent-encode a string, use [`URI::percent_encode()`].
/// implementation. To percent-encode a string, use [`Uri::percent_encode()`].
///
/// [`URI::percent_encode()`]: https://api.rocket.rs/rocket/http/uri/struct.URI.html#method.percent_encode
/// [`Uri::percent_encode()`]: https://api.rocket.rs/rocket/http/uri/struct.Uri.html#method.percent_encode
///
/// ## Example
///
@ -586,7 +586,7 @@ impl<'a> fmt::Display for &'a UriDisplay {
impl<'a> UriDisplay for &'a RawStr {
#[inline(always)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", URI::percent_encode((*self).as_str()))
write!(f, "{}", Uri::percent_encode((*self).as_str()))
}
}
@ -594,7 +594,7 @@ impl<'a> UriDisplay for &'a RawStr {
impl<'a> UriDisplay for &'a str {
#[inline(always)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", URI::percent_encode(self))
write!(f, "{}", Uri::percent_encode(self))
}
}
@ -602,7 +602,7 @@ impl<'a> UriDisplay for &'a str {
impl<'a> UriDisplay for Cow<'a, str> {
#[inline(always)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", URI::percent_encode(self))
write!(f, "{}", Uri::percent_encode(self))
}
}
@ -610,7 +610,7 @@ impl<'a> UriDisplay for Cow<'a, str> {
impl UriDisplay for String {
#[inline(always)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", URI::percent_encode(self.as_str()))
write!(f, "{}", Uri::percent_encode(self.as_str()))
}
}
@ -652,9 +652,9 @@ impl_for_ref!(&'a mut T, &'a T);
/// ### Examples
///
/// ```rust
/// use rocket::http::uri::URI;
/// use rocket::http::uri::Uri;
///
/// let uri = URI::new("/a/////b/c////////d");
/// let uri = Uri::new("/a/////b/c////////d");
/// let segments = uri.segments();
/// for (i, segment) in segments.enumerate() {
/// match i {
@ -716,15 +716,15 @@ pub enum SegmentError {
#[cfg(test)]
mod tests {
use super::URI;
use super::Uri;
fn seg_count(path: &str, expected: usize) -> bool {
let actual = URI::new(path).segment_count();
let actual = Uri::new(path).segment_count();
if actual != expected {
trace_!("Count mismatch: expected {}, got {}.", expected, actual);
trace_!("{}", if actual != expected { "lifetime" } else { "buf" });
trace_!("Segments (for {}):", path);
for (i, segment) in URI::new(path).segments().enumerate() {
for (i, segment) in Uri::new(path).segments().enumerate() {
trace_!("{}: {}", i, segment);
}
}
@ -733,7 +733,7 @@ mod tests {
}
fn eq_segments(path: &str, expected: &[&str]) -> bool {
let uri = URI::new(path);
let uri = Uri::new(path);
let actual: Vec<&str> = uri.segments().collect();
actual == expected
}
@ -741,7 +741,7 @@ mod tests {
#[test]
fn send_and_sync() {
fn assert<T: Send + Sync>() {};
assert::<URI>();
assert::<Uri>();
}
#[test]
@ -830,12 +830,12 @@ mod tests {
}
fn test_query(uri: &str, query: Option<&str>) {
let uri = URI::new(uri);
let uri = Uri::new(uri);
assert_eq!(uri.query(), query);
}
fn test_fragment(uri: &str, fragment: Option<&str>) {
let uri = URI::new(uri);
let uri = Uri::new(uri);
assert_eq!(uri.fragment(), fragment);
}
@ -877,7 +877,7 @@ mod tests {
#[test]
fn to_string() {
let uri_to_string = |string| URI::new(string).to_string();
let uri_to_string = |string| Uri::new(string).to_string();
assert_eq!(uri_to_string("/"), "/".to_string());
assert_eq!(uri_to_string("//"), "/".to_string());

18
lib/src/local/client.rs
View File

@ -1,7 +1,7 @@
use {Rocket, Request};
use local::LocalRequest;
use http::Method;
use http::uri::URI;
use http::uri::Uri;
use error::LaunchError;
/// A structure to construct requests for local dispatching.
@ -99,7 +99,7 @@ impl Client {
/// let req = client.get("/hello");
/// ```
#[inline(always)]
pub fn get<'c, 'u: 'c, U: Into<URI<'u>>>(&'c self, uri: U) -> LocalRequest<'c> {
pub fn get<'c, 'u: 'c, U: Into<Uri<'u>>>(&'c self, uri: U) -> LocalRequest<'c> {
self.req(Method::Get, uri)
}
@ -120,7 +120,7 @@ impl Client {
/// let req = client.put("/hello");
/// ```
#[inline(always)]
pub fn put<'c, 'u: 'c, U: Into<URI<'u>>>(&'c self, uri: U) -> LocalRequest<'c> {
pub fn put<'c, 'u: 'c, U: Into<Uri<'u>>>(&'c self, uri: U) -> LocalRequest<'c> {
self.req(Method::Put, uri)
}
@ -145,7 +145,7 @@ impl Client {
/// .header(ContentType::Form);
/// ```
#[inline(always)]
pub fn post<'c, 'u: 'c, U: Into<URI<'u>>>(&'c self, uri: U) -> LocalRequest<'c> {
pub fn post<'c, 'u: 'c, U: Into<Uri<'u>>>(&'c self, uri: U) -> LocalRequest<'c> {
self.req(Method::Post, uri)
}
@ -167,7 +167,7 @@ impl Client {
/// ```
#[inline(always)]
pub fn delete<'c, 'u: 'c, U>(&'c self, uri: U) -> LocalRequest<'c>
where U: Into<URI<'u>>
where U: Into<Uri<'u>>
{
self.req(Method::Delete, uri)
}
@ -190,7 +190,7 @@ impl Client {
/// ```
#[inline(always)]
pub fn options<'c, 'u: 'c, U>(&'c self, uri: U) -> LocalRequest<'c>
where U: Into<URI<'u>>
where U: Into<Uri<'u>>
{
self.req(Method::Options, uri)
}
@ -213,7 +213,7 @@ impl Client {
/// ```
#[inline(always)]
pub fn head<'c, 'u: 'c, U>(&'c self, uri: U) -> LocalRequest<'c>
where U: Into<URI<'u>>
where U: Into<Uri<'u>>
{
self.req(Method::Head, uri)
}
@ -236,7 +236,7 @@ impl Client {
/// ```
#[inline(always)]
pub fn patch<'c, 'u: 'c, U>(&'c self, uri: U) -> LocalRequest<'c>
where U: Into<URI<'u>>
where U: Into<Uri<'u>>
{
self.req(Method::Patch, uri)
}
@ -260,7 +260,7 @@ impl Client {
/// ```
#[inline(always)]
pub fn req<'c, 'u: 'c, U>(&'c self, method: Method, uri: U) -> LocalRequest<'c>
where U: Into<URI<'u>>
where U: Into<Uri<'u>>
{
let request = Request::new(&self.rocket, method, uri);
LocalRequest::new(&self.rocket, request)

6
lib/src/request/from_request.rs
View File

@ -7,7 +7,7 @@ use outcome::{self, IntoOutcome};
use outcome::Outcome::*;
use http::{Status, ContentType, Accept, Method, Cookies};
use http::uri::URI;
use http::uri::Uri;
/// Type alias for the `Outcome` of a `FromRequest` conversion.
pub type Outcome<S, E> = outcome::Outcome<S, (Status, E), ()>;
@ -104,7 +104,7 @@ impl<S, E> IntoOutcome<S, (Status, E), ()> for Result<S, E> {
///
/// * **&URI**
///
/// Extracts the [URI](/rocket/http/uri/struct.URI.html) from the incoming
/// Extracts the [`Uri`](/rocket/http/uri/struct.Uri.html) from the incoming
/// request.
///
/// _This implementation always returns successfully._
@ -229,7 +229,7 @@ impl<'a, 'r> FromRequest<'a, 'r> for Method {
}
}
impl<'a, 'r> FromRequest<'a, 'r> for &'a URI<'a> {
impl<'a, 'r> FromRequest<'a, 'r> for &'a Uri<'a> {
type Error = ();
fn from_request(request: &'a Request<'r>) -> Outcome<Self, Self::Error> {

4
lib/src/request/param.rs
View File

@ -3,7 +3,7 @@ use std::path::PathBuf;
use std::fmt::Debug;
use std::borrow::Cow;
use http::uri::{URI, Segments, SegmentError};
use http::uri::{Uri, Segments, SegmentError};
use http::RawStr;
/// Trait to convert a dynamic path segment string to a concrete value.
@ -325,7 +325,7 @@ impl<'a> FromSegments<'a> for PathBuf {
fn from_segments(segments: Segments<'a>) -> Result<PathBuf, SegmentError> {
let mut buf = PathBuf::new();
for segment in segments {
let decoded = URI::percent_decode(segment.as_bytes())
let decoded = Uri::percent_decode(segment.as_bytes())
.map_err(|e| SegmentError::Utf8(e))?;
if decoded == ".." {

14
lib/src/request/request.rs
View File

@ -11,7 +11,7 @@ use super::{FromParam, FromSegments, FromRequest, Outcome};
use rocket::Rocket;
use router::Route;
use config::{Config, Limits};
use http::uri::{URI, Segments};
use http::uri::{Uri, Segments};
use error::Error;
use http::{Method, Header, HeaderMap, Cookies, CookieJar};
use http::{RawStr, ContentType, Accept, MediaType};
@ -38,7 +38,7 @@ struct RequestState<'r> {
#[derive(Clone)]
pub struct Request<'r> {
method: Method,
uri: URI<'r>,
uri: Uri<'r>,
headers: HeaderMap<'r>,
remote: Option<SocketAddr>,
state: RequestState<'r>
@ -46,10 +46,10 @@ pub struct Request<'r> {
impl<'r> Request<'r> {
/// Create a new `Request` with the given `method` and `uri`. The `uri`
/// parameter can be of any type that implements `Into<URI>` including
/// parameter can be of any type that implements `Into<Uri>` including
/// `&str` and `String`; it must be a valid absolute URI.
#[inline(always)]
pub(crate) fn new<'s: 'r, U: Into<URI<'s>>>(rocket: &'r Rocket,
pub(crate) fn new<'s: 'r, U: Into<Uri<'s>>>(rocket: &'r Rocket,
method: Method,
uri: U) -> Request<'r> {
Request {
@ -126,12 +126,12 @@ impl<'r> Request<'r> {
/// # });
/// ```
#[inline(always)]
pub fn uri(&self) -> &URI {
pub fn uri(&self) -> &Uri {
&self.uri
}
/// Set the URI in `self`. The `uri` parameter can be of any type that
/// implements `Into<URI>` including `&str` and `String`; it _must_ be a
/// implements `Into<Uri>` including `&str` and `String`; it _must_ be a
/// valid, absolute URI.
///
/// # Example
@ -145,7 +145,7 @@ impl<'r> Request<'r> {
/// # });
/// ```
#[inline(always)]
pub fn set_uri<'u: 'r, U: Into<URI<'u>>>(&mut self, uri: U) {
pub fn set_uri<'u: 'r, U: Into<Uri<'u>>>(&mut self, uri: U) {
self.uri = uri.into();
*self.state.params.borrow_mut() = Vec::new();
}

6
lib/src/rocket.rs
View File

@ -23,7 +23,7 @@ use fairing::{Fairing, Fairings};
use http::{Method, Status, Header};
use http::hyper::{self, header};
use http::uri::URI;
use http::uri::Uri;
/// The main `Rocket` type: used to mount routes and catchers and launch the
/// application.
@ -57,7 +57,7 @@ impl hyper::Handler for Rocket {
Ok(req) => req,
Err(e) => {
error!("Bad incoming request: {}", e);
let dummy = Request::new(self, Method::Get, URI::new("<unknown>"));
let dummy = Request::new(self, Method::Get, Uri::new("<unknown>"));
let r = self.handle_error(Status::InternalServerError, &dummy);
return self.issue_response(r, res);
}
@ -497,7 +497,7 @@ impl Rocket {
}
for mut route in routes {
let uri = URI::new(format!("{}/{}", base, route.uri));
let uri = Uri::new(format!("{}/{}", base, route.uri));
route.set_base(base);
route.set_uri(uri.to_string());

10
lib/src/router/collider.rs
View File

@ -1,6 +1,6 @@
use super::Route;
use http::uri::URI;
use http::uri::Uri;
use http::MediaType;
use request::Request;
@ -53,8 +53,8 @@ impl<'a> Collider<str> for &'a str {
}
// This _only_ checks the `path` component of the URI.
impl<'a, 'b> Collider<URI<'b>> for URI<'a> {
fn collides_with(&self, other: &URI<'b>) -> bool {
impl<'a, 'b> Collider<Uri<'b>> for Uri<'a> {
fn collides_with(&self, other: &Uri<'b>) -> bool {
for (seg_a, seg_b) in self.segments().zip(other.segments()) {
if seg_a.ends_with("..>") || seg_b.ends_with("..>") {
return true;
@ -138,7 +138,7 @@ mod tests {
use handler::Outcome;
use router::route::Route;
use http::{Method, MediaType, ContentType, Accept};
use http::uri::URI;
use http::uri::Uri;
use http::Method::*;
type SimpleRoute = (Method, &'static str);
@ -158,7 +158,7 @@ mod tests {
}
fn s_s_collide(a: &'static str, b: &'static str) -> bool {
URI::new(a).collides_with(&URI::new(b))
Uri::new(a).collides_with(&Uri::new(b))
}
#[test]

8
lib/src/router/mod.rs
View File

@ -78,7 +78,7 @@ mod test {
use config::Config;
use http::Method;
use http::Method::*;
use http::uri::URI;
use http::uri::Uri;
use request::Request;
use data::Data;
use handler::Outcome;
@ -166,7 +166,7 @@ mod test {
fn route<'a>(router: &'a Router, method: Method, uri: &str) -> Option<&'a Route> {
let rocket = Rocket::custom(Config::development().unwrap(), true);
let request = Request::new(&rocket, method, URI::new(uri));
let request = Request::new(&rocket, method, Uri::new(uri));
let matches = router.route(&request);
if matches.len() > 0 {
Some(matches[0])
@ -177,7 +177,7 @@ mod test {
fn matches<'a>(router: &'a Router, method: Method, uri: &str) -> Vec<&'a Route> {
let rocket = Rocket::custom(Config::development().unwrap(), true);
let request = Request::new(&rocket, method, URI::new(uri));
let request = Request::new(&rocket, method, Uri::new(uri));
router.route(&request)
}
@ -404,7 +404,7 @@ mod test {
fn match_params(router: &Router, path: &str, expected: &[&str]) -> bool {
println!("Testing: {} (expect: {:?})", path, expected);
route(router, Get, path).map_or(false, |route| {
let params = route.get_param_indexes(&URI::new(path));
let params = route.get_param_indexes(&Uri::new(path));
if params.len() != expected.len() {
return false;
}

22
lib/src/router/route.rs
View File

@ -6,7 +6,7 @@ use yansi::Color::*;
use codegen::StaticRouteInfo;
use handler::Handler;
use http::{Method, MediaType};
use http::uri::URI;
use http::uri::Uri;
/// A route: a method, its handler, path, rank, and format/media type.
pub struct Route {
@ -17,10 +17,10 @@ pub struct Route {
/// The function that should be called when the route matches.
pub handler: Handler,
/// The base mount point of this `Route`.
pub base: URI<'static>,
pub base: Uri<'static>,
/// The uri (in Rocket format) that should be matched against. This uri
/// already includes the base mount point.
pub uri: URI<'static>,
pub uri: Uri<'static>,
/// The rank of this route. Lower ranks have higher priorities.
pub rank: isize,
/// The media type this route matches against, if any.
@ -28,7 +28,7 @@ pub struct Route {
}
#[inline(always)]
fn default_rank(uri: &URI) -> isize {
fn default_rank(uri: &Uri) -> isize {
// static path, query = -4; static path, no query = -3
// dynamic path, query = -2; dynamic path, no query = -1
match (!uri.path().contains('<'), uri.query().is_some()) {
@ -80,13 +80,13 @@ impl Route {
pub fn new<S>(m: Method, path: S, handler: Handler) -> Route
where S: AsRef<str>
{
let uri = URI::from(path.as_ref().to_string());
let uri = Uri::from(path.as_ref().to_string());
Route {
name: None,
method: m,
handler: handler,
rank: default_rank(&uri),
base: URI::from("/"),
base: Uri::from("/"),
uri: uri,
format: None,
}
@ -116,8 +116,8 @@ impl Route {
name: None,
method: m,
handler: handler,
base: URI::from("/"),
uri: URI::from(uri.as_ref().to_string()),
base: Uri::from("/"),
uri: Uri::from(uri.as_ref().to_string()),
rank: rank,
format: None,
}
@ -168,7 +168,7 @@ impl Route {
/// assert_eq!(index.base.path(), "/hi");
/// ```
pub fn set_base<S>(&mut self, path: S) where S: AsRef<str> {
self.base = URI::from(path.as_ref().to_string());
self.base = Uri::from(path.as_ref().to_string());
}
/// Sets the path of the route. Does not update the rank or any other
@ -192,7 +192,7 @@ impl Route {
/// assert_eq!(index.uri.path(), "/hello");
/// ```
pub fn set_uri<S>(&mut self, uri: S) where S: AsRef<str> {
self.uri = URI::from(uri.as_ref().to_string());
self.uri = Uri::from(uri.as_ref().to_string());
}
// FIXME: Decide whether a component has to be fully variable or not. That
@ -200,7 +200,7 @@ impl Route {
// TODO: Don't return a Vec...take in an &mut [&'a str] (no alloc!)
/// Given a URI, returns a vector of slices of that URI corresponding to the
/// dynamic segments in this route.
pub(crate) fn get_param_indexes(&self, uri: &URI) -> Vec<(usize, usize)> {
pub(crate) fn get_param_indexes(&self, uri: &Uri) -> Vec<(usize, usize)> {
let route_segs = self.uri.segments();
let uri_segs = uri.segments();
let start_addr = uri.path().as_ptr() as usize;