Deal with TopVersions everywhere

This contains far too much repeated code.
It does basically work and the relevant test passes!
I'll refactor the redundant code into a shared function.

Author: bruceadams

src/controllers/krate/metadata.rs

@@ -4,6 +4,8 @@
 //! index or cached metadata which was extracted (client side) from the
 //! `Cargo.toml` file.
 
+use chrono::NaiveDateTime;
+
 use crate::controllers::prelude::*;
 use crate::models::{
     Category, Crate, CrateCategory, CrateKeyword, CrateVersions, Keyword, RecentCrateDownloads,
@@ -31,10 +33,29 @@ pub fn summary(req: &mut dyn Request) -> AppResult<Response> {
         versions
             .grouped_by(&krates)
             .into_iter()
-            .map(|versions| Version::max(versions.into_iter().map(|v| v.num)).to_string())
+            .map(|versions| {
+                let pairs: Vec<_> = versions
+                    .into_iter()
+                    .map(|version| (version.created_at, version.num.to_string()))
+                    .collect();
+                TopVersions {
+                    newest: pairs
+                        .to_owned()
+                        .into_iter()
+                        .max()
+                        .unwrap_or((NaiveDateTime::from_timestamp(0, 0), "0.0.0".to_owned()))
+                        .1,
+                    highest: Version::max(
+                        pairs
+                            .into_iter()
+                            .map(|(_, s)| semver::Version::parse(&s).unwrap()),
+                    )
+                    .to_string(),
+                }
+            })
             .zip(krates)
-            .map(|(max_version, krate)| {
-                Ok(krate.minimal_encodable(&max_version, None, false, None))
+            .map(|(top_versions, krate)| {
+                Ok(krate.minimal_encodable(&top_versions, None, false, None))
             })
             .collect()
     };

src/controllers/krate/publish.rs

@@ -215,7 +215,7 @@ pub fn publish(req: &mut dyn Request) -> AppResult<Response> {
         };
 
         Ok(req.json(&GoodCrate {
-            krate: krate.minimal_encodable(&top_versions.highest, None, false, None),
+            krate: krate.minimal_encodable(&top_versions, None, false, None),
             warnings,
         }))
     })

src/controllers/krate/search.rs

@@ -1,10 +1,12 @@
 //! Endpoint for searching and discovery functionality
 
+use chrono::NaiveDateTime;
 use diesel::dsl::*;
 use diesel_full_text_search::*;
 
 use crate::controllers::helpers::Paginate;
 use crate::controllers::prelude::*;
+use crate::models::krate::TopVersions;
 use crate::models::{Crate, CrateBadge, CrateOwner, CrateVersions, OwnerKind, Version};
 use crate::schema::*;
 use crate::views::EncodableCrate;
@@ -179,7 +181,26 @@ pub fn search(req: &mut dyn Request) -> AppResult<Response> {
         .load::<Version>(&*conn)?
         .grouped_by(&crates)
         .into_iter()
-        .map(|versions| Version::max(versions.into_iter().map(|v| v.num)).to_string());
+        .map(|versions| {
+            let pairs: Vec<_> = versions
+                .into_iter()
+                .map(|version| (version.created_at, version.num.to_string()))
+                .collect();
+            TopVersions {
+                newest: pairs
+                    .to_owned()
+                    .into_iter()
+                    .max()
+                    .unwrap_or((NaiveDateTime::from_timestamp(0, 0), "0.0.0".to_owned()))
+                    .1,
+                highest: Version::max(
+                    pairs
+                        .into_iter()
+                        .map(|(_, s)| semver::Version::parse(&s).unwrap()),
+                )
+                .to_string(),
+            }
+        });
 
     let badges = CrateBadge::belonging_to(&crates)
         .select((badges::crate_id, badges::all_columns))

src/models/krate.rs

@@ -289,16 +289,13 @@ impl Crate {
 
     pub fn minimal_encodable(
         self,
-        max_version: &str,
+        top_versions: &TopVersions,
         badges: Option<Vec<Badge>>,
         exact_match: bool,
         recent_downloads: Option<i64>,
     ) -> EncodableCrate {
         self.encodable(
-            &TopVersions {
-                highest: max_version.to_owned(),
-                newest: max_version.to_owned(),
-            },
+            top_versions,
             None,
             None,
             None,

src/tests/krate.rs

@@ -1249,7 +1249,6 @@ fn summary_new_crates() {
         let krate4 = CrateBuilder::new("just_updated_patch", user.id)
             .version(VersionBuilder::new("0.1.0"))
             .version(VersionBuilder::new("0.2.0"))
-            .version(VersionBuilder::new("0.1.1"))
             .expect_build(conn);
 
         CrateBuilder::new("with_downloads", user.id)
@@ -1277,13 +1276,19 @@ fn summary_new_crates() {
             .execute(&*conn)
             .unwrap();
 
-        // Adjust 'just_updated_patch' to be a little newer than 'just_updated'
-        update(&krate4)
-            .set(crates::updated_at.eq(updated + chrono::Duration::seconds(2)))
+        let plus_two = Utc::now().naive_utc() + chrono::Duration::seconds(2);
+        let newer = VersionBuilder::new("0.1.1").expect_build(krate4.id, user.id, conn);
+
+        // Update the patch version to be newer than the other versions, including the higher one.
+        update(&newer)
+            .set(versions::created_at.eq(plus_two))
             .execute(&*conn)
             .unwrap();
 
-        // TODO: Make sure that the most recently updated version for just_updated_patch is 0.1.1.
+        update(&krate4)
+            .set(crates::updated_at.eq(plus_two))
+            .execute(&*conn)
+            .unwrap();
     });
 
     let json: SummaryResponse = anon.get("/api/v1/summary").good();
@@ -1301,7 +1306,7 @@ fn summary_new_crates() {
 
     assert_eq!(json.just_updated[0].name, "just_updated_patch");
     assert_eq!(json.just_updated[0].max_version, "0.2.0");
-    // FIXME: assert_eq!(json.just_updated[0].newest_version, "0.1.1");
+    assert_eq!(json.just_updated[0].newest_version, "0.1.1");
 
     assert_eq!(json.just_updated[1].name, "just_updated");
     assert_eq!(json.just_updated[1].max_version, "0.1.2");