TopVersions for highest and newest

Author: bruceadams

src/controllers/krate/metadata.rs

@@ -31,7 +31,7 @@ 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)))
+            .map(|versions| Version::max(versions.into_iter().map(|v| v.num)).to_string())
             .zip(krates)
             .map(|(max_version, krate)| {
                 Ok(krate.minimal_encodable(&max_version, None, false, None))
@@ -142,7 +142,7 @@ pub fn show(req: &mut dyn Request) -> AppResult<Response> {
     let badges = badges::table
         .filter(badges::crate_id.eq(krate.id))
         .load(&*conn)?;
-    let max_version = krate.max_version(&conn)?;
+    let top_versions = krate.top_versions(&conn)?;
 
     #[derive(Serialize)]
     struct R {
@@ -154,7 +154,7 @@ pub fn show(req: &mut dyn Request) -> AppResult<Response> {
     }
     Ok(req.json(&R {
         krate: krate.clone().encodable(
-            &max_version,
+            &top_versions,
             Some(ids),
             Some(&kws),
             Some(&cats),

src/controllers/krate/publish.rs

@@ -168,7 +168,7 @@ pub fn publish(req: &mut dyn Request) -> AppResult<Response> {
         // Update all badges for this crate, collecting any invalid badges in
         // order to be able to warn about them
         let ignored_invalid_badges = Badge::update_crate(&conn, &krate, new_crate.badges.as_ref())?;
-        let max_version = krate.max_version(&conn)?;
+        let top_versions = krate.top_versions(&conn)?;
 
         if let Some(readme) = new_crate.readme {
             render::render_and_upload_readme(
@@ -215,7 +215,7 @@ pub fn publish(req: &mut dyn Request) -> AppResult<Response> {
         };
 
         Ok(req.json(&GoodCrate {
-            krate: krate.minimal_encodable(&max_version, None, false, None),
+            krate: krate.minimal_encodable(&top_versions.highest, None, false, None),
             warnings,
         }))
     })

src/controllers/krate/search.rs

@@ -179,7 +179,7 @@ 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)));
+        .map(|versions| Version::max(versions.into_iter().map(|v| v.num)).to_string());
 
     let badges = CrateBadge::belonging_to(&crates)
         .select((badges::crate_id, badges::all_columns))

src/models/krate.rs

@@ -48,6 +48,14 @@ pub struct Crate {
     pub max_upload_size: Option<i32>,
 }
 
+/// The highest version (in semver order) and the most recently updated version
+/// for a single crate.
+#[derive(Debug, Clone)]
+pub struct TopVersions {
+    pub highest: String,
+    pub newest: String,
+}
+
 /// We literally never want to select `textsearchable_index_col`
 /// so we provide this type and constant to pass to `.select`
 type AllColumns = (
@@ -204,7 +212,7 @@ impl<'a> NewCrate<'a> {
 }
 
 impl Crate {
-    /// SQL filter based on whether the crate's name loosly matches the given
+    /// SQL filter based on whether the crate's name loosely matches the given
     /// string.
     ///
     /// The operator used varies based on the input.
@@ -281,13 +289,16 @@ impl Crate {
 
     pub fn minimal_encodable(
         self,
-        max_version: &semver::Version,
+        max_version: &str,
         badges: Option<Vec<Badge>>,
         exact_match: bool,
         recent_downloads: Option<i64>,
     ) -> EncodableCrate {
         self.encodable(
-            max_version,
+            &TopVersions {
+                highest: max_version.to_owned(),
+                newest: max_version.to_owned(),
+            },
             None,
             None,
             None,
@@ -300,7 +311,7 @@ impl Crate {
     #[allow(clippy::too_many_arguments)]
     pub fn encodable(
         self,
-        max_version: &semver::Version,
+        top_versions: &TopVersions,
         versions: Option<Vec<i32>>,
         keywords: Option<&[Keyword]>,
         categories: Option<&[Category]>,
@@ -339,8 +350,8 @@ impl Crate {
             keywords: keyword_ids,
             categories: category_ids,
             badges,
-            max_version: max_version.to_string(),
-            newest_version: max_version.to_string(), // FIXME: Make this the newest, not the highest
+            max_version: top_versions.highest.to_owned(),
+            newest_version: top_versions.newest.to_owned(),
             documentation,
             homepage,
             exact_match,
@@ -385,16 +396,28 @@ impl Crate {
         }
     }
 
-    pub fn max_version(&self, conn: &PgConnection) -> AppResult<semver::Version> {
+    pub fn top_versions(&self, conn: &PgConnection) -> AppResult<TopVersions> {
         use crate::schema::versions::dsl::*;
 
-        let vs = self
+        let results = self
             .versions()
-            .select(num)
-            .load::<String>(conn)?
-            .into_iter()
-            .map(|s| semver::Version::parse(&s).unwrap());
-        Ok(Version::max(vs))
+            .select((updated_at, num))
+            .load::<(NaiveDateTime, String)>(conn)?;
+
+        Ok(TopVersions {
+            newest: results
+                .to_owned()
+                .into_iter()
+                .max()
+                .unwrap_or((NaiveDateTime::from_timestamp(0, 0), "0.0.0".to_owned()))
+                .1,
+            highest: Version::max(
+                results
+                    .into_iter()
+                    .map(|(_, s)| semver::Version::parse(&s).unwrap()),
+            )
+            .to_string(),
+        })
     }
 
     pub fn owners(&self, conn: &PgConnection) -> AppResult<Vec<Owner>> {

src/tests/util.rs

@@ -305,7 +305,7 @@ impl TestAppBuilder {
     }
 }
 
-/// A colleciton of helper methods for the 3 authentication types
+/// A collection of helper methods for the 3 authentication types
 ///
 /// Helper methods go through public APIs, and should not modify the database directly
 pub trait RequestHelper {