Implement ReleaseTracks

Author: eth3lbert

src/controllers/krate/versions.rs

@@ -303,3 +303,193 @@ struct ResponseMeta {
     total: i64,
     next_page: Option<String>,
 }
+
+#[derive(Debug, Eq, PartialEq, Serialize)]
+struct ReleaseTracks(IndexMap<ReleaseSlug, HighestSemver>);
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+enum ReleaseSlug {
+    MajorX(u64),
+    MajorMinor(u64, u64),
+    Major(u64),
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Serialize)]
+struct HighestSemver {
+    highest: SemverTriple,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+struct SemverTriple(u64, u64, u64);
+
+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::from_semver(num));
+            }
+        }
+
+        Self(map)
+    }
+}
+
+impl ReleaseSlug {
+    pub fn from_semver(version: &semver::Version) -> Self {
+        if version.major >= 100 {
+            Self::Major(version.major)
+        } else if version.major == 0 {
+            Self::MajorMinor(version.major, version.minor)
+        } else {
+            Self::MajorX(version.major)
+        }
+    }
+}
+
+impl HighestSemver {
+    pub fn from_semver(version: &semver::Version) -> Self {
+        Self {
+            highest: SemverTriple(version.major, version.minor, version.patch),
+        }
+    }
+}
+
+impl std::fmt::Display for ReleaseSlug {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::MajorX(major) => write!(f, "{major}.x"),
+            Self::MajorMinor(major, minor) => write!(f, "{major}.{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)
+    }
+}
+
+impl std::fmt::Display for SemverTriple {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}.{}.{}", self.0, self.1, self.2)
+    }
+}
+
+impl serde::Serialize for SemverTriple {
+    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::from_semver(&version("100.1.1"))
+                ),
+                (
+                    ReleaseSlug::MajorX(1),
+                    HighestSemver::from_semver(&version("1.3.5"))
+                ),
+                (
+                    ReleaseSlug::MajorMinor(0, 3),
+                    HighestSemver::from_semver(&version("0.3.23"))
+                ),
+                (
+                    ReleaseSlug::MajorMinor(0, 2),
+                    HighestSemver::from_semver(&version("0.2.1"))
+                ),
+                (
+                    ReleaseSlug::MajorMinor(0, 1),
+                    HighestSemver::from_semver(&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.x": { "highest": "1.3.5" },
+                "0.3": { "highest": "0.3.23" },
+                "0.2": { "highest": "0.2.1" },
+                "0.1": { "highest": "0.1.2" }
+            })
+        );
+    }
+}