Refactor top_version into the version module

Where we used to have max_version, we now have two kinds of top versions:
- the highest semver version
- the most recently updated version.

Author: bruceadams

src/controllers/krate/metadata.rs

@@ -1,11 +1,10 @@
 //! Endpoints that expose metadata about a crate
 //!
-//! These endpoints provide data that could be obtained direclty from the
+//! These endpoints provide data that could be obtained directly from the
 //! index or cached metadata which was extracted (client side) from the
 //! `Cargo.toml` file.
 
 use crate::controllers::frontend_prelude::*;
-use chrono::NaiveDateTime;
 
 use crate::models::{
     Category, Crate, CrateCategory, CrateKeyword, CrateVersions, Keyword, RecentCrateDownloads,
@@ -33,26 +32,7 @@ pub fn summary(req: &mut dyn Request) -> AppResult<Response> {
         versions
             .grouped_by(&krates)
             .into_iter()
-            .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(),
-                }
-            })
+            .map(|versions| Version::top(versions.into_iter().map(|v| (v.created_at, v.num))))
             .zip(krates)
             .map(|(top_versions, krate)| {
                 Ok(krate.minimal_encodable(&top_versions, None, false, None))

src/controllers/krate/search.rs

@@ -1,12 +1,10 @@
 //! Endpoint for searching and discovery functionality
 
-use chrono::NaiveDateTime;
 use diesel::dsl::*;
 use diesel_full_text_search::*;
 
 use crate::controllers::cargo_prelude::*;
 use crate::controllers::helpers::Paginate;
-use crate::models::krate::TopVersions;
 use crate::models::{Crate, CrateBadge, CrateOwner, CrateVersions, OwnerKind, Version};
 use crate::schema::*;
 use crate::views::EncodableCrate;
@@ -181,26 +179,7 @@ pub fn search(req: &mut dyn Request) -> AppResult<Response> {
         .load::<Version>(&*conn)?
         .grouped_by(&crates)
         .into_iter()
-        .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(),
-            }
-        });
+        .map(|versions| Version::top(versions.into_iter().map(|v| (v.created_at, v.num))));
 
     let badges = CrateBadge::belonging_to(&crates)
         .select((badges::crate_id, badges::all_columns))

src/models/krate.rs

@@ -8,12 +8,12 @@ use url::Url;
 
 use crate::app::App;
 use crate::email;
-use crate::util::{cargo_err, AppResult};
-
+use crate::models::version::TopVersions;
 use crate::models::{
     Badge, Category, CrateOwner, CrateOwnerInvitation, Keyword, NewCrateOwnerInvitation, Owner,
     OwnerKind, ReverseDependency, User, Version,
 };
+use crate::util::{cargo_err, AppResult};
 use crate::views::{EncodableCrate, EncodableCrateLinks};
 
 use crate::models::helpers::with_count::*;
@@ -48,14 +48,6 @@ 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 = (
@@ -347,8 +339,8 @@ impl Crate {
             keywords: keyword_ids,
             categories: category_ids,
             badges,
-            max_version: top_versions.highest.to_owned(),
-            newest_version: top_versions.newest.to_owned(),
+            max_version: top_versions.highest.to_string(),
+            newest_version: top_versions.newest.to_string(),
             documentation,
             homepage,
             exact_match,
@@ -398,25 +390,11 @@ impl Crate {
     pub fn top_versions(&self, conn: &PgConnection) -> AppResult<TopVersions> {
         use crate::schema::versions::dsl::*;
 
-        let results = self
-            .versions()
-            .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(),
-        })
+        Ok(Version::top(
+            self.versions()
+                .select((updated_at, num))
+                .load::<(NaiveDateTime, semver::Version)>(conn)?,
+        ))
     }
 
     pub fn owners(&self, conn: &PgConnection) -> AppResult<Vec<Owner>> {

src/models/version.rs

@@ -37,6 +37,25 @@ pub struct NewVersion {
     published_by: i32,
 }
 
+/// The highest version (semver order) and the most recently updated version.
+/// Typically used for a single crate.
+#[derive(Debug, Clone)]
+pub struct TopVersions {
+    pub highest: semver::Version,
+    pub newest: semver::Version,
+}
+
+/// A default semver value, "0.0.0", for use in TopVersions
+fn default_semver_version() -> semver::Version {
+    semver::Version {
+        major: 0,
+        minor: 0,
+        patch: 0,
+        pre: vec![],
+        build: vec![],
+    }
+}
+
 impl Version {
     pub fn encodable(
         self,
@@ -96,20 +115,28 @@ impl Version {
             .load(conn)
     }
 
-    pub fn max<T>(versions: T) -> semver::Version
+    /// Return both the newest (most recently updated) and the
+    /// highest version (in semver order) for a collection of date/version pairs.
+    pub fn top<T>(pairs: T) -> TopVersions
     where
-        T: IntoIterator<Item = semver::Version>,
+        T: Clone + IntoIterator<Item = (NaiveDateTime, semver::Version)>,
     {
-        versions
-            .into_iter()
-            .max()
-            .unwrap_or_else(|| semver::Version {
-                major: 0,
-                minor: 0,
-                patch: 0,
-                pre: vec![],
-                build: vec![],
-            })
+        TopVersions {
+            newest: pairs
+                .clone()
+                .into_iter()
+                .max()
+                .unwrap_or((
+                    NaiveDateTime::from_timestamp(0, 0),
+                    default_semver_version(),
+                ))
+                .1,
+            highest: pairs
+                .into_iter()
+                .map(|(_, v)| v)
+                .max()
+                .unwrap_or_else(default_semver_version),
+        }
     }
 
     pub fn record_readme_rendering(version_id_: i32, conn: &PgConnection) -> QueryResult<usize> {