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

Rename 'UUID' to 'Uuid' in 'rocket_contrib'.

This commit is contained in:
Kyle Clemens 2018-04-13 21:39:34 -04:00 committed by Sergio Benitez
parent 4157c573e8
commit 105137a46d
3 changed files with 39 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
contrib/src/lib.rs
View File

@ -20,7 +20,7 @@
//! * [msgpack](struct.MsgPack.html)
//! * [handlebars_templates](struct.Template.html)
//! * [tera_templates](struct.Template.html)
//! * [uuid](struct.UUID.html)
//! * [uuid](struct.Uuid.html)
//!
//! The recommend way to include features from this crate via Cargo in your
//! project is by adding a `[dependencies.rocket_contrib]` section to your
@ -78,4 +78,4 @@ pub use templates::{Template, Engines};
mod uuid;
#[cfg(feature = "uuid")]
pub use uuid::{UUID, UuidParseError};
pub use uuid::{Uuid, UuidParseError};

58
contrib/src/uuid.rs
View File

@ -9,7 +9,7 @@ use rocket::http::RawStr;
pub use self::uuid_ext::ParseError as UuidParseError;
/// Implements `FromParam` and `FormFormValue` for accepting UUID values from
/// Implements `FromParam` and `FormFormValue` for accepting Uuid values from
/// the [uuid](https://github.com/rust-lang-nursery/uuid) crate.
///
/// # Usage
@ -24,21 +24,21 @@ pub use self::uuid_ext::ParseError as UuidParseError;
/// features = ["uuid"]
/// ```
///
/// You can use the `UUID` type directly as a target of a dynamic parameter:
/// You can use the `Uuid` type directly as a target of a dynamic parameter:
///
/// ```rust,ignore
/// #[get("/users/<id>")]
/// fn user(id: UUID) -> String {
/// fn user(id: Uuid) -> String {
/// format!("We found: {}", id)
/// }
/// ```
///
/// You can also use the `UUID` as a form value, including in query strings:
/// You can also use the `Uuid` as a form value, including in query strings:
///
/// ```rust,ignore
/// #[derive(FromForm)]
/// struct UserQuery {
/// id: UUID
/// id: Uuid
/// }
///
/// #[post("/user?<user_query>")]
@ -46,22 +46,20 @@ pub use self::uuid_ext::ParseError as UuidParseError;
/// format!("User ID: {}", user_query.id)
/// }
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]
pub struct UUID(uuid_ext::Uuid);
pub struct Uuid(uuid_ext::Uuid);
impl UUID {
/// Consumes the UUID wrapper returning the underlying `Uuid` type.
impl Uuid {
/// Consumes the Uuid wrapper returning the underlying `Uuid` type.
///
/// # Example
/// ```rust
/// # extern crate rocket_contrib;
/// # extern crate uuid;
/// # use rocket_contrib::UUID;
/// # use std::str::FromStr;
/// # use uuid::Uuid;
/// # fn main() {
/// let uuid_str = "c1aa1e3b-9614-4895-9ebd-705255fa5bc2";
/// let real_uuid = Uuid::from_str(uuid_str).unwrap();
/// let my_inner_uuid = UUID::from_str(uuid_str).unwrap().into_inner();
/// let real_uuid = uuid::Uuid::from_str(uuid_str).unwrap();
/// let my_inner_uuid = rocket_contrib::Uuid::from_str(uuid_str).unwrap().into_inner();
/// assert_eq!(real_uuid, my_inner_uuid);
/// # }
/// ```
@ -71,45 +69,45 @@ impl UUID {
}
}
impl fmt::Display for UUID {
impl fmt::Display for Uuid {
#[inline(always)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.0.fmt(f)
}
}
impl<'a> FromParam<'a> for UUID {
impl<'a> FromParam<'a> for Uuid {
type Error = UuidParseError;
/// A value is successfully parsed if `param` is a properly formatted UUID.
/// A value is successfully parsed if `param` is a properly formatted Uuid.
/// Otherwise, a `UuidParseError` is returned.
#[inline(always)]
fn from_param(param: &'a RawStr) -> Result<UUID, Self::Error> {
fn from_param(param: &'a RawStr) -> Result<Uuid, Self::Error> {
param.parse()
}
}
impl<'v> FromFormValue<'v> for UUID {
impl<'v> FromFormValue<'v> for Uuid {
type Error = &'v RawStr;
/// A value is successfully parsed if `form_value` is a properly formatted
/// UUID. Otherwise, the raw form value is returned.
/// Uuid. Otherwise, the raw form value is returned.
#[inline(always)]
fn from_form_value(form_value: &'v RawStr) -> Result<UUID, &'v RawStr> {
fn from_form_value(form_value: &'v RawStr) -> Result<Uuid, &'v RawStr> {
form_value.parse().map_err(|_| form_value)
}
}
impl FromStr for UUID {
impl FromStr for Uuid {
type Err = UuidParseError;
#[inline]
fn from_str(s: &str) -> Result<UUID, Self::Err> {
Ok(UUID(try!(s.parse())))
fn from_str(s: &str) -> Result<Uuid, Self::Err> {
Ok(Uuid(try!(s.parse())))
}
}
impl Deref for UUID {
impl Deref for Uuid {
type Target = uuid_ext::Uuid;
fn deref<'a>(&'a self) -> &'a Self::Target {
@ -117,7 +115,7 @@ impl Deref for UUID {
}
}
impl PartialEq<uuid_ext::Uuid> for UUID {
impl PartialEq<uuid_ext::Uuid> for Uuid {
#[inline(always)]
fn eq(&self, other: &uuid_ext::Uuid) -> bool {
self.0.eq(other)
@ -127,28 +125,28 @@ impl PartialEq<uuid_ext::Uuid> for UUID {
#[cfg(test)]
mod test {
use super::uuid_ext;
use super::{UUID, UuidParseError};
use super::{Uuid, UuidParseError};
use super::FromParam;
use super::FromStr;
#[test]
fn test_from_str() {
let uuid_str = "c1aa1e3b-9614-4895-9ebd-705255fa5bc2";
let uuid_wrapper = UUID::from_str(uuid_str).unwrap();
let uuid_wrapper = Uuid::from_str(uuid_str).unwrap();
assert_eq!(uuid_str, uuid_wrapper.to_string())
}
#[test]
fn test_from_param() {
let uuid_str = "c1aa1e3b-9614-4895-9ebd-705255fa5bc2";
let uuid_wrapper = UUID::from_param(uuid_str.into()).unwrap();
let uuid_wrapper = Uuid::from_param(uuid_str.into()).unwrap();
assert_eq!(uuid_str, uuid_wrapper.to_string())
}
#[test]
fn test_into_inner() {
let uuid_str = "c1aa1e3b-9614-4895-9ebd-705255fa5bc2";
let uuid_wrapper = UUID::from_param(uuid_str.into()).unwrap();
let uuid_wrapper = Uuid::from_param(uuid_str.into()).unwrap();
let real_uuid: uuid_ext::Uuid = uuid_str.parse().unwrap();
let inner_uuid: uuid_ext::Uuid = uuid_wrapper.into_inner();
assert_eq!(real_uuid, inner_uuid)
@ -157,7 +155,7 @@ mod test {
#[test]
fn test_partial_eq() {
let uuid_str = "c1aa1e3b-9614-4895-9ebd-705255fa5bc2";
let uuid_wrapper = UUID::from_param(uuid_str.into()).unwrap();
let uuid_wrapper = Uuid::from_param(uuid_str.into()).unwrap();
let real_uuid: uuid_ext::Uuid = uuid_str.parse().unwrap();
assert_eq!(uuid_wrapper, real_uuid)
}
@ -165,7 +163,7 @@ mod test {
#[test]
fn test_from_param_invalid() {
let uuid_str = "c1aa1e3b-9614-4895-9ebd-705255fa5bc2p";
let uuid_result = UUID::from_param(uuid_str.into());
let uuid_result = Uuid::from_param(uuid_str.into());
assert_eq!(uuid_result, Err(UuidParseError::InvalidLength(37)));
}
}

19
examples/uuid/src/main.rs
View File

@ -8,8 +8,7 @@ extern crate rocket;
extern crate rocket_contrib;
use std::collections::HashMap;
use uuid::Uuid;
use rocket_contrib::UUID;
use rocket_contrib::Uuid;
#[cfg(test)]
mod tests;
@ -17,12 +16,12 @@ mod tests;
lazy_static! {
// A small people lookup table for the sake of this example. In a real
// application this could be a database lookup. Notice that we use the
// uuid::Uuid type here and not the rocket_contrib::UUID type.
static ref PEOPLE: HashMap<Uuid, &'static str> = {
// uuid::Uuid type here and not the rocket_contrib::Uuid type.
static ref PEOPLE: HashMap<uuid::Uuid, &'static str> = {
let mut m = HashMap::new();
let lacy_id = Uuid::parse_str("7f205202-7ba1-4c39-b2fc-3e630722bf9f").unwrap();
let bob_id = Uuid::parse_str("4da34121-bc7d-4fc1-aee6-bf8de0795333").unwrap();
let george_id = Uuid::parse_str("ad962969-4e3d-4de7-ac4a-2d86d6d10839").unwrap();
let lacy_id = uuid::Uuid::parse_str("7f205202-7ba1-4c39-b2fc-3e630722bf9f").unwrap();
let bob_id = uuid::Uuid::parse_str("4da34121-bc7d-4fc1-aee6-bf8de0795333").unwrap();
let george_id = uuid::Uuid::parse_str("ad962969-4e3d-4de7-ac4a-2d86d6d10839").unwrap();
m.insert(lacy_id, "Lacy");
m.insert(bob_id, "Bob");
m.insert(george_id, "George");
@ -31,9 +30,9 @@ lazy_static! {
}
#[get("/people/<id>")]
fn people(id: UUID) -> Result<String, String> {
// Because UUID implements the Deref trait, we use Deref coercion to convert
// rocket_contrib::UUID to uuid::Uuid.
fn people(id: Uuid) -> Result<String, String> {
// Because Uuid implements the Deref trait, we use Deref coercion to convert
// rocket_contrib::Uuid to uuid::Uuid.
Ok(PEOPLE.get(&id)
.map(|person| format!("We found: {}", person))
.ok_or(format!("Person not found for UUID: {}", id))?)