Implement ReleaseTracks

This will add `release_tracks` information to the meta field for
paginated versions. This is necessary for pagination because it only
loads a portion of versions per page, while `release_tracks` may require
all sorted versions to determine their values. Therefore, we also need
to calculate these on the server side.

Author: eth3lbert

src/controllers/krate/versions.rs

@@ -133,7 +133,11 @@ fn list_by_date(
 
     Ok(PaginatedVersionsAndPublishers {
         data,
-        meta: ResponseMeta { total, next_page },
+        meta: ResponseMeta {
+            total,
+            next_page,
+            release_tracks: None,
+        },
     })
 }
 
@@ -233,6 +237,7 @@ fn list_by_semver(
         meta: ResponseMeta {
             total: total as i64,
             next_page,
+            release_tracks: None,
         },
     })
 }
@@ -302,4 +307,180 @@ struct PaginatedVersionsAndPublishers {
 struct ResponseMeta {
     total: i64,
     next_page: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    release_tracks: Option<ReleaseTracks>,
+}
+
+#[derive(Debug, Eq, PartialEq, Serialize)]
+struct ReleaseTracks(IndexMap<ReleaseSlug, HighestSemver>);
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+enum ReleaseSlug {
+    Minor(u64),
+    Major(u64),
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Serialize)]
+struct HighestSemver {
+    highest: semver::Version,
+}
+
+impl ReleaseTracks {
+    // Return the release tracks based on a sorted semver versions iterator (in descending order).
+    // **Remember to** filter out yanked versions manually before calling this function.
+    pub fn from_sorted_semver_iter<'a, I>(versions: I) -> Self
+    where
+        I: Iterator<Item = &'a semver::Version>,
+    {
+        let mut map = IndexMap::new();
+        for num in versions.filter(|num| num.pre.is_empty()) {
+            let key = ReleaseSlug::from_semver(num);
+            let prev = map.last();
+            if prev.filter(|&(k, _)| *k == key).is_none() {
+                map.insert(
+                    key,
+                    HighestSemver {
+                        highest: num.clone(),
+                    },
+                );
+            }
+        }
+
+        Self(map)
+    }
+}
+
+impl ReleaseSlug {
+    pub fn from_semver(version: &semver::Version) -> Self {
+        if version.major == 0 {
+            Self::Minor(version.minor)
+        } else {
+            Self::Major(version.major)
+        }
+    }
+}
+
+impl std::fmt::Display for ReleaseSlug {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Minor(minor) => write!(f, "0.{minor}"),
+            Self::Major(major) => write!(f, "{major}"),
+        }
+    }
+}
+
+impl serde::Serialize for ReleaseSlug {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+        Self: std::fmt::Display,
+    {
+        serializer.collect_str(self)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{HighestSemver, ReleaseSlug, ReleaseTracks};
+    use indexmap::IndexMap;
+
+    #[track_caller]
+    fn version(str: &str) -> semver::Version {
+        semver::Version::parse(str).unwrap()
+    }
+
+    #[test]
+    fn release_tracks_empty() {
+        let versions = [];
+        assert_eq!(
+            ReleaseTracks::from_sorted_semver_iter(versions.into_iter()),
+            ReleaseTracks(IndexMap::new())
+        );
+    }
+
+    #[test]
+    fn release_tracks_prerelease() {
+        let versions = [version("1.0.0-beta.5")];
+        assert_eq!(
+            ReleaseTracks::from_sorted_semver_iter(versions.iter()),
+            ReleaseTracks(IndexMap::new())
+        );
+    }
+
+    #[test]
+    fn release_tracks_multiple() {
+        let versions = [
+            "100.1.1",
+            "100.1.0",
+            "1.3.5",
+            "1.2.5",
+            "1.1.5",
+            "0.4.0-rc.1",
+            "0.3.23",
+            "0.3.22",
+            "0.3.21-pre.0",
+            "0.3.20",
+            "0.3.3",
+            "0.3.2",
+            "0.3.1",
+            "0.3.0",
+            "0.2.1",
+            "0.2.0",
+            "0.1.2",
+            "0.1.1",
+        ]
+        .map(version);
+
+        let release_tracks = ReleaseTracks::from_sorted_semver_iter(versions.iter());
+        assert_eq!(
+            release_tracks,
+            ReleaseTracks(IndexMap::from([
+                (
+                    ReleaseSlug::Major(100),
+                    HighestSemver {
+                        highest: version("100.1.1")
+                    }
+                ),
+                (
+                    ReleaseSlug::Major(1),
+                    HighestSemver {
+                        highest: version("1.3.5")
+                    }
+                ),
+                (
+                    ReleaseSlug::Minor(3),
+                    HighestSemver {
+                        highest: version("0.3.23")
+                    }
+                ),
+                (
+                    ReleaseSlug::Minor(2),
+                    HighestSemver {
+                        highest: version("0.2.1")
+                    }
+                ),
+                (
+                    ReleaseSlug::Minor(1),
+                    HighestSemver {
+                        highest: version("0.1.2")
+                    }
+                ),
+            ]))
+        );
+
+        let json = serde_json::from_str::<serde_json::Value>(
+            &serde_json::to_string(&release_tracks).unwrap(),
+        )
+        .unwrap();
+        assert_eq!(
+            json,
+            json!({
+                "100": { "highest": "100.1.1" },
+                "1": { "highest": "1.3.5" },
+                "0.3": { "highest": "0.3.23" },
+                "0.2": { "highest": "0.2.1" },
+                "0.1": { "highest": "0.1.2" }
+            })
+        );
+    }
 }