Use serde derive where possible

Author: Andronik Ordian

Cargo.lock

@@ -48,7 +48,8 @@ pub struct EncodableDependency {
     pub downloads: i32,
 }
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Serialize, Deserialize, Debug)]
+#[serde(rename_all = "lowercase")]
 #[repr(u32)]
 pub enum Kind {
     Normal = 0,

src/dependency.rs

@@ -1034,6 +1034,7 @@ pub fn show(req: &mut Request) -> CargoResult<Response> {
 
     #[derive(Serialize)]
     struct R {
+        #[serde(rename = "crate")]
         krate: EncodableCrate,
         versions: Vec<EncodableVersion>,
         keywords: Vec<EncodableKeyword>,
@@ -1185,6 +1186,7 @@ pub fn new(req: &mut Request) -> CargoResult<Response> {
 
         #[derive(Serialize)]
         struct R<'a> {
+            #[serde(rename = "crate")]
             krate: EncodableCrate,
             warnings: Warnings<'a>,
         }

src/krate.rs

@@ -19,7 +19,6 @@ extern crate time;
 extern crate url;
 extern crate s3;
 
-use serde_json::Value;
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::env;
@@ -167,33 +166,9 @@ where
     let mut data = Vec::new();
     r.body.write_body(&mut data).unwrap();
     let s = std::str::from_utf8(&data).unwrap();
-    let j = match serde_json::from_str(s) {
+    match serde_json::from_str(s) {
         Ok(t) => t,
         Err(e) => panic!("failed to decode: {:?}\n{}", e, s),
-    };
-    let j = fixup(j);
-    return match serde_json::from_value::<T>(j) {
-        Ok(t) => t,
-        Err(e) => panic!("failed to decode: {:?}\n{}", e, s),
-    };
-
-
-    fn fixup(json: Value) -> Value {
-        match json {
-            Value::Object(object) => {
-                Value::Object(
-                    object
-                        .into_iter()
-                        .map(|(k, v)| {
-                            let k = if k == "crate" { "krate".to_string() } else { k };
-                            (k, fixup(v))
-                        })
-                        .collect(),
-                )
-            }
-            Value::Array(list) => Value::Array(list.into_iter().map(fixup).collect()),
-            j => j,
-        }
     }
 }
 

src/tests/all.rs

@@ -46,11 +46,13 @@ struct Warnings {
 }
 #[derive(Deserialize)]
 struct GoodCrate {
+    #[serde(rename = "crate")]
     krate: EncodableCrate,
     warnings: Warnings,
 }
 #[derive(Deserialize)]
 struct CrateResponse {
+    #[serde(rename = "crate")]
     krate: EncodableCrate,
     versions: Vec<EncodableVersion>,
     keywords: Vec<EncodableKeyword>,

src/tests/krate.rs

@@ -23,8 +23,8 @@ pub struct ApiToken {
 }
 
 /// The serialization format for the `ApiToken` model without its token value.
-pub struct EncodableApiToken {
 #[derive(Deserialize, Serialize)]
+pub struct EncodableApiToken {
     pub id: i32,
     pub name: String,
     pub created_at: String,
@@ -34,8 +34,8 @@ pub struct EncodableApiToken {
 /// The serialization format for the `ApiToken` model with its token value.
 /// This should only be used when initially creating a new token to minimize
 /// the chance of token leaks.
-pub struct EncodableApiTokenWithToken {
 #[derive(Deserialize, Serialize)]
+pub struct EncodableApiTokenWithToken {
     pub id: i32,
     pub name: String,
     pub token: String,

src/token.rs

@@ -27,24 +27,24 @@ pub struct NewCrate {
     pub badges: Option<HashMap<String, HashMap<String, String>>>,
 }
 
-#[derive(PartialEq, Eq, Hash, Debug)]
+#[derive(PartialEq, Eq, Hash, Serialize, Debug)]
 pub struct CrateName(pub String);
 #[derive(Debug)]
 pub struct CrateVersion(pub semver::Version);
 #[derive(Debug)]
 pub struct CrateVersionReq(pub semver::VersionReq);
-#[derive(Debug)]
+#[derive(Serialize, Debug)]
 pub struct KeywordList(pub Vec<Keyword>);
-#[derive(Debug)]
+#[derive(Serialize, Debug)]
 pub struct Keyword(pub String);
-#[derive(Debug)]
+#[derive(Serialize, Debug)]
 pub struct CategoryList(pub Vec<Category>);
-#[derive(Debug)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct Category(pub String);
-#[derive(Debug)]
+#[derive(Serialize, Debug)]
 pub struct Feature(pub String);
 
-#[derive(Deserialize, Serialize, Debug)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct CrateDependency {
     pub optional: bool,
     pub default_features: bool,
@@ -94,12 +94,6 @@ impl<'de> Deserialize<'de> for Keyword {
     }
 }
 
-impl<'de> Deserialize<'de> for Category {
-    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Category, D::Error> {
-        String::deserialize(d).map(Category)
-    }
-}
-
 impl<'de> Deserialize<'de> for Feature {
     fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Feature, D::Error> {
         let s = String::deserialize(d)?;
@@ -178,40 +172,6 @@ impl<'de> Deserialize<'de> for CategoryList {
         }
     }
 }
-
-impl<'de> Deserialize<'de> for DependencyKind {
-    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<DependencyKind, D::Error> {
-        let s = String::deserialize(d)?;
-        match &s[..] {
-            "dev" => Ok(DependencyKind::Dev),
-            "build" => Ok(DependencyKind::Build),
-            "normal" => Ok(DependencyKind::Normal),
-            _ => {
-                const KINDS: &'static [&'static str] = &["dev", "build", "normal"];
-                Err(de::Error::unknown_variant(&s, KINDS))
-            }
-        }
-    }
-}
-
-macro_rules! serialize_string {
-    ($name:ty) => (
-        impl Serialize for $name {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-                where S: Serializer
-            {
-                serializer.serialize_str(self.deref())
-            }
-        }
-    )
-}
-
-serialize_string!(CrateName);
-serialize_string!(Keyword);
-serialize_string!(Category);
-serialize_string!(Feature);
-
-
 impl Serialize for CrateVersion {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -230,39 +190,6 @@ impl Serialize for CrateVersionReq {
     }
 }
 
-impl Serialize for KeywordList {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let KeywordList(ref inner) = *self;
-        inner.serialize(serializer)
-    }
-}
-
-impl Serialize for CategoryList {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let CategoryList(ref inner) = *self;
-        inner.serialize(serializer)
-    }
-}
-
-impl Serialize for DependencyKind {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            DependencyKind::Normal => "normal".serialize(serializer),
-            DependencyKind::Build => "build".serialize(serializer),
-            DependencyKind::Dev => "dev".serialize(serializer),
-        }
-    }
-}
-
 impl Deref for CrateName {
     type Target = str;
     fn deref(&self) -> &str {

src/upload.rs

@@ -3,7 +3,7 @@ use std::error::Error;
 use std::io::{self, Cursor};
 use std::sync::Arc;
 
-use serde_json::{self, Value};
+use serde_json;
 use serde::Serialize;
 use url;
 
@@ -37,36 +37,17 @@ pub trait RequestUtils {
 }
 
 pub fn json_response<T: Serialize>(t: &T) -> Response {
-    let s = serde_json::to_string(t).unwrap();
-    let json = fixup(s.parse().unwrap()).to_string();
+    let json = serde_json::to_string(t).unwrap();
     let mut headers = HashMap::new();
     headers.insert(
         "Content-Type".to_string(),
         vec!["application/json; charset=utf-8".to_string()],
     );
     headers.insert("Content-Length".to_string(), vec![json.len().to_string()]);
-    return Response {
+    Response {
         status: (200, "OK"),
         headers: headers,
         body: Box::new(Cursor::new(json.into_bytes())),
-    };
-
-    fn fixup(json: Value) -> Value {
-        match json {
-            Value::Object(object) => {
-                Value::Object(
-                    object
-                        .into_iter()
-                        .map(|(k, v)| {
-                            let k = if k == "krate" { "crate".to_string() } else { k };
-                            (k, fixup(v))
-                        })
-                        .collect(),
-                )
-            }
-            Value::Array(list) => Value::Array(list.into_iter().map(fixup).collect()),
-            j => j,
-        }
     }
 }