From 105137a46d2ee3c366fb8ac4b000d329fe7e8c8e Mon Sep 17 00:00:00 2001 From: Kyle Clemens Date: Fri, 13 Apr 2018 21:39:34 -0400 Subject: [PATCH] Rename 'UUID' to 'Uuid' in 'rocket_contrib'. --- contrib/src/lib.rs | 4 +-- contrib/src/uuid.rs | 58 +++++++++++++++++++-------------------- examples/uuid/src/main.rs | 19 ++++++------- 3 files changed, 39 insertions(+), 42 deletions(-) diff --git a/contrib/src/lib.rs b/contrib/src/lib.rs index 296eaa87..2cb4135d 100644 --- a/contrib/src/lib.rs +++ b/contrib/src/lib.rs @@ -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}; diff --git a/contrib/src/uuid.rs b/contrib/src/uuid.rs index 6b9de682..993ffc11 100644 --- a/contrib/src/uuid.rs +++ b/contrib/src/uuid.rs @@ -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/")] -/// 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?")] @@ -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 { + fn from_param(param: &'a RawStr) -> Result { 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 { + fn from_form_value(form_value: &'v RawStr) -> Result { 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 { - Ok(UUID(try!(s.parse()))) + fn from_str(s: &str) -> Result { + 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 for UUID { +impl PartialEq for Uuid { #[inline(always)] fn eq(&self, other: &uuid_ext::Uuid) -> bool { self.0.eq(other) @@ -127,28 +125,28 @@ impl PartialEq 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))); } } diff --git a/examples/uuid/src/main.rs b/examples/uuid/src/main.rs index 1b4386e6..d6967a09 100644 --- a/examples/uuid/src/main.rs +++ b/examples/uuid/src/main.rs @@ -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::Uuid type here and not the rocket_contrib::Uuid type. + static ref PEOPLE: HashMap = { 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/")] -fn people(id: UUID) -> Result { - // Because UUID implements the Deref trait, we use Deref coercion to convert - // rocket_contrib::UUID to uuid::Uuid. +fn people(id: Uuid) -> Result { + // 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))?)