Auto merge of #3889 - Turbo87:json-macro, r=hi-rustin

Use `json!` macro to simplify JSON serialization code

see https://docs.serde.rs/serde_json/macro.json.html

I guess `+132 −349` speaks for itself 😅

Author: bors

src/controllers/category.rs

@@ -18,25 +18,18 @@ pub fn index(req: &mut dyn RequestExt) -> EndpointResult {
     let conn = req.db_read_only()?;
     let categories =
         Category::toplevel(&conn, sort, i64::from(options.per_page), i64::from(offset))?;
-    let categories = categories.into_iter().map(Category::into).collect();
+    let categories = categories
+        .into_iter()
+        .map(Category::into)
+        .collect::<Vec<EncodableCategory>>();
 
     // Query for the total count of categories
     let total = Category::count_toplevel(&conn)?;
 
-    #[derive(Serialize)]
-    struct R {
-        categories: Vec<EncodableCategory>,
-        meta: Meta,
-    }
-    #[derive(Serialize)]
-    struct Meta {
-        total: i64,
-    }
-
-    Ok(req.json(&R {
-        categories,
-        meta: Meta { total },
-    }))
+    Ok(req.json(&json!({
+        "categories": categories,
+        "meta": { "total": total },
+    })))
 }
 
 /// Handles the `GET /categories/:category_id` route.
@@ -67,19 +60,13 @@ pub fn show(req: &mut dyn RequestExt) -> EndpointResult {
         parent_categories: parents,
     };
 
-    #[derive(Serialize)]
-    struct R {
-        category: EncodableCategoryWithSubcategories,
-    }
-    Ok(req.json(&R {
-        category: cat_with_subcats,
-    }))
+    Ok(req.json(&json!({ "category": cat_with_subcats })))
 }
 
 /// Handles the `GET /category_slugs` route.
 pub fn slugs(req: &mut dyn RequestExt) -> EndpointResult {
     let conn = req.db_read_only()?;
-    let slugs = categories::table
+    let slugs: Vec<Slug> = categories::table
         .select((categories::slug, categories::slug, categories::description))
         .order(categories::slug)
         .load(&*conn)?;
@@ -91,11 +78,5 @@ pub fn slugs(req: &mut dyn RequestExt) -> EndpointResult {
         description: String,
     }
 
-    #[derive(Serialize)]
-    struct R {
-        category_slugs: Vec<Slug>,
-    }
-    Ok(req.json(&R {
-        category_slugs: slugs,
-    }))
+    Ok(req.json(&json!({ "category_slugs": slugs })))
 }

src/controllers/crate_owner_invitation.rs

@@ -44,15 +44,10 @@ pub fn list(req: &mut dyn RequestExt) -> EndpointResult {
         })
         .collect::<AppResult<Vec<EncodableCrateOwnerInvitationV1>>>()?;
 
-    #[derive(Serialize)]
-    struct R {
-        crate_owner_invitations: Vec<EncodableCrateOwnerInvitationV1>,
-        users: Vec<EncodablePublicUser>,
-    }
-    Ok(req.json(&R {
-        crate_owner_invitations,
-        users,
-    }))
+    Ok(req.json(&json!({
+        "crate_owner_invitations": crate_owner_invitations,
+        "users": users,
+    })))
 }
 
 /// Handles the `GET /api/private/crate_owner_invitations` route.
@@ -271,13 +266,7 @@ pub fn handle_invite(req: &mut dyn RequestExt) -> EndpointResult {
         invitation.decline(conn)?;
     }
 
-    #[derive(Serialize)]
-    struct R {
-        crate_owner_invitation: InvitationResponse,
-    }
-    Ok(req.json(&R {
-        crate_owner_invitation: crate_invite,
-    }))
+    Ok(req.json(&json!({ "crate_owner_invitation": crate_invite })))
 }
 
 /// Handles the `PUT /api/v1/me/crate_owner_invitations/accept/:token` route.
@@ -290,14 +279,10 @@ pub fn handle_invite_with_token(req: &mut dyn RequestExt) -> EndpointResult {
     let crate_id = invitation.crate_id;
     invitation.accept(&conn, config)?;
 
-    #[derive(Serialize)]
-    struct R {
-        crate_owner_invitation: InvitationResponse,
-    }
-    Ok(req.json(&R {
-        crate_owner_invitation: InvitationResponse {
-            crate_id,
-            accepted: true,
+    Ok(req.json(&json!({
+        "crate_owner_invitation": {
+            "crate_id": crate_id,
+            "accepted": true,
         },
-    }))
+    })))
 }

src/controllers/helpers.rs

@@ -5,10 +5,6 @@ pub(crate) mod pagination;
 pub(crate) use self::pagination::Paginate;
 
 pub fn ok_true() -> EndpointResult {
-    #[derive(Serialize)]
-    struct R {
-        ok: bool,
-    }
-
-    Ok(json_response(&R { ok: true }))
+    let json = json!({ "ok": true });
+    Ok(json_response(&json))
 }

src/controllers/keyword.rs

@@ -24,22 +24,15 @@ pub fn index(req: &mut dyn RequestExt) -> EndpointResult {
     let conn = req.db_read_only()?;
     let data: Paginated<Keyword> = query.load(&*conn)?;
     let total = data.total();
-    let kws = data.into_iter().map(Keyword::into).collect::<Vec<_>>();
-
-    #[derive(Serialize)]
-    struct R {
-        keywords: Vec<EncodableKeyword>,
-        meta: Meta,
-    }
-    #[derive(Serialize)]
-    struct Meta {
-        total: Option<i64>,
-    }
-
-    Ok(req.json(&R {
-        keywords: kws,
-        meta: Meta { total: Some(total) },
-    }))
+    let kws = data
+        .into_iter()
+        .map(Keyword::into)
+        .collect::<Vec<EncodableKeyword>>();
+
+    Ok(req.json(&json!({
+        "keywords": kws,
+        "meta": { "total": total },
+    })))
 }
 
 /// Handles the `GET /keywords/:keyword_id` route.
@@ -49,9 +42,5 @@ pub fn show(req: &mut dyn RequestExt) -> EndpointResult {
 
     let kw = Keyword::find_by_keyword(&conn, name)?;
 
-    #[derive(Serialize)]
-    struct R {
-        keyword: EncodableKeyword,
-    }
-    Ok(req.json(&R { keyword: kw.into() }))
+    Ok(req.json(&json!({ "keyword": EncodableKeyword::from(kw) })))
 }

src/controllers/krate/downloads.rs

@@ -32,7 +32,7 @@ pub fn downloads(req: &mut dyn RequestExt) -> EndpointResult {
         .load(&*conn)?
         .into_iter()
         .map(VersionDownload::into)
-        .collect::<Vec<_>>();
+        .collect::<Vec<EncodableVersionDownload>>();
 
     let sum_downloads = sql::<BigInt>("SUM(version_downloads.downloads)");
     let extra: Vec<ExtraDownload> = VersionDownload::belonging_to(rest)
@@ -50,20 +50,11 @@ pub fn downloads(req: &mut dyn RequestExt) -> EndpointResult {
         date: String,
         downloads: i64,
     }
-    #[derive(Serialize)]
-    struct R {
-        version_downloads: Vec<EncodableVersionDownload>,
-        meta: Meta,
-    }
-    #[derive(Serialize)]
-    struct Meta {
-        extra_downloads: Vec<ExtraDownload>,
-    }
-    let meta = Meta {
-        extra_downloads: extra,
-    };
-    Ok(req.json(&R {
-        version_downloads: downloads,
-        meta,
-    }))
+
+    Ok(req.json(&json!({
+        "version_downloads": downloads,
+        "meta": {
+            "extra_downloads": extra,
+        },
+    })))
 }

src/controllers/krate/follow.rs

@@ -49,11 +49,8 @@ pub fn following(req: &mut dyn RequestExt) -> EndpointResult {
     let user_id = req.authenticate()?.forbid_api_token_auth()?.user_id();
     let conn = req.db_read_only()?;
     let follow = follow_target(req, &conn, user_id)?;
-    let following = diesel::select(exists(follows::table.find(follow.id()))).get_result(&*conn)?;
+    let following =
+        diesel::select(exists(follows::table.find(follow.id()))).get_result::<bool>(&*conn)?;
 
-    #[derive(Serialize)]
-    struct R {
-        following: bool,
-    }
-    Ok(req.json(&R { following }))
+    Ok(req.json(&json!({ "following": following })))
 }

src/controllers/krate/metadata.rs

@@ -25,8 +25,8 @@ pub fn summary(req: &mut dyn RequestExt) -> EndpointResult {
     use crate::schema::crates::dsl::*;
 
     let conn = req.db_read_only()?;
-    let num_crates = crates.count().get_result(&*conn)?;
-    let num_downloads = metadata::table
+    let num_crates: i64 = crates.count().get_result(&*conn)?;
+    let num_downloads: i64 = metadata::table
         .select(metadata::total_downloads)
         .get_result(&*conn)?;
 
@@ -89,34 +89,23 @@ pub fn summary(req: &mut dyn RequestExt) -> EndpointResult {
         .load(&*conn)?
         .into_iter()
         .map(Keyword::into)
-        .collect();
+        .collect::<Vec<EncodableKeyword>>();
 
     let popular_categories = Category::toplevel(&conn, "crates", 10, 0)?
         .into_iter()
         .map(Category::into)
-        .collect();
-
-    #[derive(Serialize)]
-    struct R {
-        num_downloads: i64,
-        num_crates: i64,
-        new_crates: Vec<EncodableCrate>,
-        most_downloaded: Vec<EncodableCrate>,
-        most_recently_downloaded: Vec<EncodableCrate>,
-        just_updated: Vec<EncodableCrate>,
-        popular_keywords: Vec<EncodableKeyword>,
-        popular_categories: Vec<EncodableCategory>,
-    }
-    Ok(req.json(&R {
-        num_downloads,
-        num_crates,
-        new_crates: encode_crates(new_crates)?,
-        most_downloaded: encode_crates(most_downloaded)?,
-        most_recently_downloaded: encode_crates(most_recently_downloaded)?,
-        just_updated: encode_crates(just_updated)?,
-        popular_keywords,
-        popular_categories,
-    }))
+        .collect::<Vec<EncodableCategory>>();
+
+    Ok(req.json(&json!({
+        "num_downloads": num_downloads,
+        "num_crates": num_crates,
+        "new_crates": encode_crates(new_crates)?,
+        "most_downloaded": encode_crates(most_downloaded)?,
+        "most_recently_downloaded": encode_crates(most_recently_downloaded)?,
+        "just_updated": encode_crates(just_updated)?,
+        "popular_keywords": popular_keywords,
+        "popular_categories": popular_categories,
+    })))
 }
 
 /// Handles the `GET /crates/:crate_id` route.
@@ -167,16 +156,8 @@ pub fn show(req: &mut dyn RequestExt) -> EndpointResult {
         .load(&*conn)?;
     let top_versions = krate.top_versions(&conn)?;
 
-    #[derive(Serialize)]
-    struct R {
-        #[serde(rename = "crate")]
-        krate: EncodableCrate,
-        versions: Vec<EncodableVersion>,
-        keywords: Vec<EncodableKeyword>,
-        categories: Vec<EncodableCategory>,
-    }
-    Ok(req.json(&R {
-        krate: EncodableCrate::from(
+    Ok(req.json(&json!({
+        "crate": EncodableCrate::from(
             krate.clone(),
             &top_versions,
             Some(ids),
@@ -186,13 +167,13 @@ pub fn show(req: &mut dyn RequestExt) -> EndpointResult {
             false,
             recent_downloads,
         ),
-        versions: versions_publishers_and_audit_actions
+        "versions": versions_publishers_and_audit_actions
             .into_iter()
             .map(|(v, pb, aas)| EncodableVersion::from(v, &krate.name, pb, aas))
-            .collect(),
-        keywords: kws.into_iter().map(Keyword::into).collect(),
-        categories: cats.into_iter().map(Category::into).collect(),
-    }))
+            .collect::<Vec<_>>(),
+        "keywords": kws.into_iter().map(Keyword::into).collect::<Vec<EncodableKeyword>>(),
+        "categories": cats.into_iter().map(Category::into).collect::<Vec<EncodableCategory>>(),
+    })))
 }
 
 /// Handles the `GET /crates/:crate_id/:version/readme` route.
@@ -207,11 +188,7 @@ pub fn readme(req: &mut dyn RequestExt) -> EndpointResult {
         .readme_location(crate_name, version);
 
     if req.wants_json() {
-        #[derive(Serialize)]
-        struct R {
-            url: String,
-        }
-        Ok(req.json(&R { url: redirect_url }))
+        Ok(req.json(&json!({ "url": redirect_url })))
     } else {
         Ok(req.redirect(redirect_url))
     }
@@ -242,13 +219,9 @@ pub fn versions(req: &mut dyn RequestExt) -> EndpointResult {
         .into_iter()
         .zip(VersionOwnerAction::for_versions(&conn, &versions)?.into_iter())
         .map(|((v, pb), aas)| EncodableVersion::from(v, crate_name, pb, aas))
-        .collect();
+        .collect::<Vec<_>>();
 
-    #[derive(Serialize)]
-    struct R {
-        versions: Vec<EncodableVersion>,
-    }
-    Ok(req.json(&R { versions }))
+    Ok(req.json(&json!({ "versions": versions })))
 }
 
 /// Handles the `GET /crates/:crate_id/reverse_dependencies` route.
@@ -288,21 +261,11 @@ pub fn reverse_dependencies(req: &mut dyn RequestExt) -> EndpointResult {
         .map(|((version, krate_name, published_by), actions)| {
             EncodableVersion::from(version, &krate_name, published_by, actions)
         })
-        .collect();
+        .collect::<Vec<_>>();
 
-    #[derive(Serialize)]
-    struct R {
-        dependencies: Vec<EncodableDependency>,
-        versions: Vec<EncodableVersion>,
-        meta: Meta,
-    }
-    #[derive(Serialize)]
-    struct Meta {
-        total: i64,
-    }
-    Ok(req.json(&R {
-        dependencies: rev_deps,
-        versions,
-        meta: Meta { total },
-    }))
+    Ok(req.json(&json!({
+        "dependencies": rev_deps,
+        "versions": versions,
+        "meta": { "total": total },
+    })))
 }