Rename external 'uuid' to 'extern_uuid'.

Use '_uuid' to refer to the crate internally.

contrib/lib/src/uuid.rs

@@ -14,7 +14,7 @@
 //! features = ["uuid"]
 //! ```
 
-pub extern crate _uuid as uuid_crate;
+pub extern crate _uuid as extern_uuid;
 
 use std::fmt;
 use std::str::FromStr;
@@ -25,9 +25,10 @@ use serde::{Deserialize, Serialize};
 use rocket::request::FromParam;
 use rocket::form::{self, FromFormField, ValueField};
 
-type ParseError = <self::uuid_crate::Uuid as FromStr>::Err;
-
-/// Implements [`FromParam`] and [`FromFormValue`] for accepting UUID values.
+/// UUID data and form guard: consume UUID values.
+///
+/// `Uuuid` implements [`FromParam`] and [`FromForm`] for accepting UUID values
+/// in paths, queries, and forms.
 ///
 /// # Usage
 ///
@@ -67,7 +68,7 @@ type ParseError = <self::uuid_crate::Uuid as FromStr>::Err;
 /// }
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Serialize, Deserialize)]
 #[serde(transparent)]
-pub struct Uuid(uuid_crate::Uuid);
+pub struct Uuid(_uuid::Uuid);
 
 impl Uuid {
     /// Consumes the Uuid wrapper, returning the underlying `Uuid` type.
@@ -77,10 +78,10 @@ impl Uuid {
     /// # extern crate rocket_contrib;
     /// # use std::str::FromStr;
     /// # fn main() {
-    /// use rocket_contrib::uuid::{uuid_crate, Uuid};
+    /// use rocket_contrib::uuid::{extern_uuid, Uuid};
     ///
     /// let uuid_str = "c1aa1e3b-9614-4895-9ebd-705255fa5bc2";
-    /// let real_uuid = uuid_crate::Uuid::from_str(uuid_str).unwrap();
+    /// let real_uuid = extern_uuid::Uuid::from_str(uuid_str).unwrap();
     /// let my_inner_uuid = Uuid::from_str(uuid_str)
     ///     .expect("valid UUID string")
     ///     .into_inner();
@@ -89,7 +90,7 @@ impl Uuid {
     /// # }
     /// ```
     #[inline(always)]
-    pub fn into_inner(self) -> uuid_crate::Uuid {
+    pub fn into_inner(self) -> _uuid::Uuid {
         self.0
     }
 }
@@ -101,11 +102,12 @@ impl fmt::Display for Uuid {
     }
 }
 
+
 impl<'a> FromParam<'a> for Uuid {
-    type Error = ParseError;
+    type Error = _uuid::Error;
 
     /// A value is successfully parsed if `param` is a properly formatted Uuid.
-    /// Otherwise, a `ParseError` is returned.
+    /// Otherwise, an error is returned.
     #[inline(always)]
     fn from_param(param: &'a str) -> Result<Uuid, Self::Error> {
         param.parse()
@@ -119,7 +121,7 @@ impl<'v> FromFormField<'v> for Uuid {
 }
 
 impl FromStr for Uuid {
-    type Err = ParseError;
+    type Err = _uuid::Error;
 
     #[inline]
     fn from_str(s: &str) -> Result<Uuid, Self::Err> {
@@ -128,23 +130,22 @@ impl FromStr for Uuid {
 }
 
 impl Deref for Uuid {
-    type Target = uuid_crate::Uuid;
+    type Target = _uuid::Uuid;
 
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
-impl PartialEq<uuid_crate::Uuid> for Uuid {
+impl PartialEq<_uuid::Uuid> for Uuid {
     #[inline(always)]
-    fn eq(&self, other: &uuid_crate::Uuid) -> bool {
+    fn eq(&self, other: &_uuid::Uuid) -> bool {
         self.0.eq(other)
     }
 }
 
 #[cfg(test)]
 mod test {
-    use super::uuid_crate;
     use super::Uuid;
     use super::FromParam;
     use super::FromStr;
@@ -167,8 +168,8 @@ mod test {
     fn test_into_inner() {
         let uuid_str = "c1aa1e3b-9614-4895-9ebd-705255fa5bc2";
         let uuid_wrapper = Uuid::from_param(uuid_str.into()).unwrap();
-        let real_uuid: uuid_crate::Uuid = uuid_str.parse().unwrap();
-        let inner_uuid: uuid_crate::Uuid = uuid_wrapper.into_inner();
+        let real_uuid: _uuid::Uuid = uuid_str.parse().unwrap();
+        let inner_uuid: _uuid::Uuid = uuid_wrapper.into_inner();
         assert_eq!(real_uuid, inner_uuid)
     }
 
@@ -176,7 +177,7 @@ mod test {
     fn test_partial_eq() {
         let uuid_str = "c1aa1e3b-9614-4895-9ebd-705255fa5bc2";
         let uuid_wrapper = Uuid::from_param(uuid_str.into()).unwrap();
-        let real_uuid: uuid_crate::Uuid = uuid_str.parse().unwrap();
+        let real_uuid: _uuid::Uuid = uuid_str.parse().unwrap();
         assert_eq!(uuid_wrapper, real_uuid)
     }
 

examples/uuid/src/main.rs

@@ -4,14 +4,15 @@ use std::collections::HashMap;
 
 use rocket::State;
 use rocket_contrib::uuid::Uuid;
-use rocket_contrib::uuid::uuid_crate as uuid;
+use rocket_contrib::uuid::extern_uuid;
 
 #[cfg(test)] mod tests;
 
 // A small people mapping in managed state for the sake of this example. In a
-// real application this would be a database. Notice that we use the uuid::Uuid
-// type here and not the rocket_contrib::uuid::Uuid type.
-struct People(HashMap<uuid::Uuid, &'static str>);
+// real application this would be a database. Notice that we use the external
+// Uuid type here and not the rocket_contrib::uuid::Uuid type. We do this purely
+// for demonstrative purposes; in practice, we could use the contrib `Uuid`.
+struct People(HashMap<extern_uuid::Uuid, &'static str>);
 
 #[get("/people/<id>")]
 fn people(id: Uuid, people: State<People>) -> Result<String, String> {