models/krate: Allow retrieval of crate versions from slice of reference

Author: eth3lbert

src/controllers/krate/search.rs

@@ -214,15 +214,7 @@ pub async fn search(app: AppState, req: Parts) -> AppResult<Json<Value>> {
             )
         };
 
-        let perfect_matches = data.iter().map(|&(_, b, _, _, _)| b).collect::<Vec<_>>();
-        let downloads = data
-            .iter()
-            .map(|&(_, _, total, recent, _)| (total, recent.unwrap_or(0)))
-            .collect::<Vec<_>>();
-        let crates = data
-            .into_iter()
-            .map(|(c, _, _, _, _)| c)
-            .collect::<Vec<_>>();
+        let crates = data.iter().map(|(c, ..)| c).collect::<Vec<_>>();
 
         let versions: Vec<Version> = info_span!("db.query", message = "SELECT ... FROM versions")
             .in_scope(|| crates.versions().load(conn))?;
@@ -232,17 +224,15 @@ pub async fn search(app: AppState, req: Parts) -> AppResult<Json<Value>> {
             .map(TopVersions::from_versions);
 
         let crates = versions
-            .zip(crates)
-            .zip(perfect_matches)
-            .zip(downloads)
-            .map(|(((max_version, krate), perfect_match), (total, recent))| {
+            .zip(data)
+            .map(|(max_version, (krate, perfect_match, total, recent, _))| {
                 EncodableCrate::from_minimal(
                     krate,
                     Some(&max_version),
                     Some(vec![]),
                     perfect_match,
                     total,
-                    Some(recent),
+                    Some(recent.unwrap_or(0)),
                 )
             })
             .collect::<Vec<_>>();

src/controllers/summary.rs

@@ -27,21 +27,14 @@ pub async fn summary(state: AppState) -> AppResult<Json<Value>> {
             conn: &mut impl Conn,
             data: Vec<(Crate, i64, Option<i64>)>,
         ) -> AppResult<Vec<EncodableCrate>> {
-            let downloads = data
-                .iter()
-                .map(|&(_, total, recent)| (total, recent))
-                .collect::<Vec<_>>();
-
-            let krates = data.into_iter().map(|(c, _, _)| c).collect::<Vec<_>>();
-
+            let krates = data.iter().map(|(c, ..)| c).collect::<Vec<_>>();
             let versions: Vec<Version> = krates.versions().load(conn)?;
             versions
                 .grouped_by(&krates)
                 .into_iter()
                 .map(TopVersions::from_versions)
-                .zip(krates)
-                .zip(downloads)
-                .map(|((top_versions, krate), (total, recent))| {
+                .zip(data)
+                .map(|(top_versions, (krate, total, recent))| {
                     Ok(EncodableCrate::from_minimal(
                         krate,
                         Some(&top_versions),

src/models/krate.rs

@@ -494,6 +494,12 @@ impl CrateVersions for [Crate] {
     }
 }
 
+impl CrateVersions for [&Crate] {
+    fn all_versions(&self) -> versions::BoxedQuery<'_, Pg> {
+        Version::belonging_to(self).into_boxed()
+    }
+}
+
 #[derive(Debug, Eq, PartialEq, thiserror::Error)]
 pub enum InvalidFeature {
     #[error("feature cannot be empty")]