Generate maintenance badges via badge crate

Author: Turbo87

Cargo.lock

@@ -30,6 +30,7 @@ rustdoc-args = [
 [dependencies]
 ammonia = "3.0.0"
 anyhow = "1.0"
+badge = "0.3.0"
 base64 = "0.13"
 cargo-registry-s3 = { path = "src/s3", version = "0.2.0" }
 chrono = { version = "0.4.0", features = ["serde"] }

Cargo.toml

@@ -21,51 +21,57 @@ pub fn maintenance(req: &mut dyn RequestExt) -> EndpointResult {
 
     let krate = krate.unwrap();
 
-    let maintenance_badge = CrateBadge::belonging_to(&krate)
+    let maintenance_badge: Option<CrateBadge> = CrateBadge::belonging_to(&krate)
         .select((badges::crate_id, badges::all_columns))
         .load::<CrateBadge>(&*conn)?
         .into_iter()
         .find(|cb| matches!(cb.badge, Badge::Maintenance { .. }));
 
-    if maintenance_badge.is_none() {
-        return Ok(req.redirect(
-            "https://img.shields.io/badge/maintenance-unknown-lightgrey.svg".to_owned(),
-        ));
-    }
+    let status = maintenance_badge
+        .map(|it| match it.badge {
+            Badge::Maintenance { status } => Some(status),
+            _ => None,
+        })
+        .flatten();
 
-    let status = match maintenance_badge {
-        Some(CrateBadge {
-            badge: Badge::Maintenance { status },
-            ..
-        }) => Some(status),
-        _ => None,
-    };
+    let badge = generate_badge(status);
+
+    let response = Response::builder()
+        .status(200)
+        .body(Body::from_vec(badge.into_bytes()))
+        .unwrap();
 
-    let status = status.unwrap();
+    Ok(response)
+}
 
+fn generate_badge(status: Option<MaintenanceStatus>) -> String {
     let message = match status {
-        MaintenanceStatus::ActivelyDeveloped => "actively--developed",
-        MaintenanceStatus::PassivelyMaintained => "passively--maintained",
-        MaintenanceStatus::AsIs => "as--is",
-        MaintenanceStatus::None => "unknown",
-        MaintenanceStatus::Experimental => "experimental",
-        MaintenanceStatus::LookingForMaintainer => "looking--for--maintainer",
-        MaintenanceStatus::Deprecated => "deprecated",
+        Some(MaintenanceStatus::ActivelyDeveloped) => "actively-developed",
+        Some(MaintenanceStatus::PassivelyMaintained) => "passively-maintained",
+        Some(MaintenanceStatus::AsIs) => "as-is",
+        Some(MaintenanceStatus::None) => "unknown",
+        Some(MaintenanceStatus::Experimental) => "experimental",
+        Some(MaintenanceStatus::LookingForMaintainer) => "looking-for-maintainer",
+        Some(MaintenanceStatus::Deprecated) => "deprecated",
+        None => "unknown",
     };
 
     let color = match status {
-        MaintenanceStatus::ActivelyDeveloped => "brightgreen",
-        MaintenanceStatus::PassivelyMaintained => "yellowgreen",
-        MaintenanceStatus::AsIs => "yellow",
-        MaintenanceStatus::None => "lightgrey",
-        MaintenanceStatus::Experimental => "blue",
-        MaintenanceStatus::LookingForMaintainer => "orange",
-        MaintenanceStatus::Deprecated => "red",
+        Some(MaintenanceStatus::ActivelyDeveloped) => "brightgreen",
+        Some(MaintenanceStatus::PassivelyMaintained) => "yellowgreen",
+        Some(MaintenanceStatus::AsIs) => "yellow",
+        Some(MaintenanceStatus::None) => "lightgrey",
+        Some(MaintenanceStatus::Experimental) => "blue",
+        Some(MaintenanceStatus::LookingForMaintainer) => "orange",
+        Some(MaintenanceStatus::Deprecated) => "red",
+        None => "lightgrey",
+    };
+
+    let badge_options = badge::BadgeOptions {
+        subject: "maintenance".to_owned(),
+        status: message.to_owned(),
+        color: color.to_string(),
     };
 
-    let url = format!(
-        "https://img.shields.io/badge/maintenance-{}-{}.svg",
-        message, color
-    );
-    Ok(req.redirect(url))
+    badge::Badge::new(badge_options).unwrap().to_svg()
 }

src/controllers/krate/badges.rs

@@ -198,10 +198,7 @@ fn bad_resp(r: &mut AppResponse) -> Option<Bad> {
     Some(bad)
 }
 
-fn json<T>(r: &mut AppResponse) -> T
-where
-    for<'de> T: serde::Deserialize<'de>,
-{
+fn text(r: &mut AppResponse) -> String {
     use conduit::Body::*;
 
     let mut body = Body::empty();
@@ -212,8 +209,15 @@ where
         File(_) => unimplemented!(),
     };
 
-    let s = std::str::from_utf8(&body).unwrap();
-    match serde_json::from_str(s) {
+    std::str::from_utf8(&body).unwrap().to_owned()
+}
+
+fn json<T>(r: &mut AppResponse) -> T
+where
+    for<'de> T: serde::Deserialize<'de>,
+{
+    let s = text(r);
+    match serde_json::from_str(&s) {
         Ok(t) => t,
         Err(e) => panic!("failed to decode: {:?}\n{}", e, s),
     }

src/tests/all.rs

@@ -31,20 +31,24 @@ fn set_up() -> MockAnonymousUser {
 fn crate_with_maintenance_badge() {
     let anon = set_up();
 
-    anon.get::<()>("/api/v1/crates/foo/maintenance.svg")
-        .assert_status(StatusCode::FOUND)
-        .assert_redirects_to(
-            "https://img.shields.io/badge/maintenance-looking--for--maintainer-orange.svg",
-        );
+    let response = anon
+        .get::<String>("/api/v1/crates/foo/maintenance.svg")
+        .good_text();
+
+    assert!(response.contains("looking-for-maintainer"));
+    assert!(response.contains("fill=\"orange\""));
 }
 
 #[test]
 fn crate_without_maintenance_badge() {
     let anon = set_up();
 
-    anon.get::<()>("/api/v1/crates/bar/maintenance.svg")
-        .assert_status(StatusCode::FOUND)
-        .assert_redirects_to("https://img.shields.io/badge/maintenance-unknown-lightgrey.svg");
+    let response = anon
+        .get::<String>("/api/v1/crates/bar/maintenance.svg")
+        .good_text();
+
+    assert!(response.contains("unknown"));
+    assert!(response.contains("fill=\"lightgrey\""));
 }
 
 #[test]

src/tests/maintenance_badge.rs

@@ -584,7 +584,7 @@ impl Bad {
 /// A type providing helper methods for working with responses
 #[must_use]
 pub struct Response<T> {
-    response: AppResponse,
+    pub response: AppResponse,
     callback_on_good: Option<Box<dyn Fn(&T)>>,
 }
 
@@ -606,6 +606,15 @@ where
         }
     }
 
+    /// Assert that the response is good and deserialize the message
+    #[track_caller]
+    pub fn good_text(mut self) -> String {
+        if !self.response.status().is_success() {
+            panic!("bad response: {:?}", self.response.status());
+        }
+        crate::text(&mut self.response).to_owned()
+    }
+
     /// Assert that the response is good and deserialize the message
     #[track_caller]
     pub fn good(mut self) -> T {
@@ -649,19 +658,6 @@ where
             .ends_with(target));
         self
     }
-
-    pub fn assert_redirects_to(&self, target: &str) -> &Self {
-        assert_eq!(
-            self.response
-                .headers()
-                .get(header::LOCATION)
-                .unwrap()
-                .to_str()
-                .unwrap(),
-            target
-        );
-        self
-    }
 }
 
 impl Response<()> {