refactor: clean up electron versions (#10)

src/data/electron.rs

@@ -1,17 +1,51 @@
 use crate::error::Error;
-use nom::{
-    character::complete::{char, u16},
-    combinator::{all_consuming, opt},
-    number::complete::float,
-    sequence::{pair, terminated},
-};
-
 pub use crate::generated::electron_to_chromium::ELECTRON_VERSIONS;
 
-pub fn parse_version(version: &str) -> Result<f32, Error> {
-    all_consuming(terminated(float, opt(pair(char('.'), u16))))(version)
-        .map(|(_, v)| v)
-        .map_err(|_: nom::Err<nom::error::Error<_>>| {
-            Error::UnknownElectronVersion(version.to_string())
-        })
+#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
+pub struct ElectronVersion {
+    pub major: u16,
+    pub minor: u16,
+}
+
+impl ElectronVersion {
+    pub fn new(major: u16, minor: u16) -> Self {
+        Self { major, minor }
+    }
+
+    pub fn parse(major: &str, minor: &str) -> Result<Self, std::num::ParseIntError> {
+        let major = major.parse()?;
+        let minor = minor.parse()?;
+        Ok(Self { major, minor })
+    }
+}
+
+pub fn parse_version(version: &str) -> Result<ElectronVersion, Error> {
+    let mut split = version.split('.');
+
+    let Some(first) = split.next() else {
+        return Err(err(version));
+    };
+
+    let Some(second) = split.next().filter(|n| check_number(n)) else {
+        return Err(err(version));
+    };
+
+    if split.next().is_some() && split.next().is_some() {
+        return Err(err(version));
+    }
+
+    let election_version = ElectronVersion::parse(first, second).map_err(|_| err(version))?;
+    Ok(election_version)
+}
+
+fn check_number(n: &str) -> bool {
+    if n == "0" {
+        true
+    } else {
+        !n.starts_with('0')
+    }
+}
+
+fn err(version: &str) -> Error {
+    Error::UnknownElectronVersion(version.to_string())
 }

src/generated/electron_to_chromium.rs

@@ -1,154 +1,155 @@
+use crate::data::electron::ElectronVersion;
 use once_cell::sync::Lazy;
-pub static ELECTRON_VERSIONS: Lazy<Vec<(f32, &'static str)>> = Lazy::new(|| {
+pub static ELECTRON_VERSIONS: Lazy<Vec<(ElectronVersion, &'static str)>> = Lazy::new(|| {
     vec![
-        (0.2f32, "39"),
-        (0.21f32, "41"),
-        (0.22f32, "41"),
-        (0.23f32, "41"),
-        (0.24f32, "41"),
-        (0.25f32, "42"),
-        (0.26f32, "42"),
-        (0.27f32, "43"),
-        (0.28f32, "43"),
-        (0.29f32, "43"),
-        (0.3f32, "44"),
-        (0.31f32, "45"),
-        (0.32f32, "45"),
-        (0.33f32, "45"),
-        (0.34f32, "45"),
-        (0.35f32, "45"),
-        (0.36f32, "47"),
-        (0.37f32, "49"),
-        (1f32, "49"),
-        (1.1f32, "50"),
-        (1.2f32, "51"),
-        (1.3f32, "52"),
-        (1.4f32, "53"),
-        (1.5f32, "54"),
-        (1.6f32, "56"),
-        (1.7f32, "58"),
-        (1.8f32, "59"),
-        (2f32, "61"),
-        (2.1f32, "61"),
-        (3f32, "66"),
-        (3.1f32, "66"),
-        (4f32, "69"),
-        (4.1f32, "69"),
-        (4.2f32, "69"),
-        (5f32, "73"),
-        (6f32, "76"),
-        (6.1f32, "76"),
-        (7f32, "78"),
-        (7.1f32, "78"),
-        (7.2f32, "78"),
-        (7.3f32, "78"),
-        (8f32, "80"),
-        (8.1f32, "80"),
-        (8.2f32, "80"),
-        (8.3f32, "80"),
-        (8.4f32, "80"),
-        (8.5f32, "80"),
-        (9f32, "83"),
-        (9.1f32, "83"),
-        (9.2f32, "83"),
-        (9.3f32, "83"),
-        (9.4f32, "83"),
-        (10f32, "85"),
-        (10.1f32, "85"),
-        (10.2f32, "85"),
-        (10.3f32, "85"),
-        (10.4f32, "85"),
-        (11f32, "87"),
-        (11.1f32, "87"),
-        (11.2f32, "87"),
-        (11.3f32, "87"),
-        (11.4f32, "87"),
-        (11.5f32, "87"),
-        (12f32, "89"),
-        (12.1f32, "89"),
-        (12.2f32, "89"),
-        (13f32, "91"),
-        (13.1f32, "91"),
-        (13.2f32, "91"),
-        (13.3f32, "91"),
-        (13.4f32, "91"),
-        (13.5f32, "91"),
-        (13.6f32, "91"),
-        (14f32, "93"),
-        (14.1f32, "93"),
-        (14.2f32, "93"),
-        (15f32, "94"),
-        (15.1f32, "94"),
-        (15.2f32, "94"),
-        (15.3f32, "94"),
-        (15.4f32, "94"),
-        (15.5f32, "94"),
-        (16f32, "96"),
-        (16.1f32, "96"),
-        (16.2f32, "96"),
-        (17f32, "98"),
-        (17.1f32, "98"),
-        (17.2f32, "98"),
-        (17.3f32, "98"),
-        (17.4f32, "98"),
-        (18f32, "100"),
-        (18.1f32, "100"),
-        (18.2f32, "100"),
-        (18.3f32, "100"),
-        (19f32, "102"),
-        (19.1f32, "102"),
-        (20f32, "104"),
-        (20.1f32, "104"),
-        (20.2f32, "104"),
-        (20.3f32, "104"),
-        (21f32, "106"),
-        (21.1f32, "106"),
-        (21.2f32, "106"),
-        (21.3f32, "106"),
-        (21.4f32, "106"),
-        (22f32, "108"),
-        (22.1f32, "108"),
-        (22.2f32, "108"),
-        (22.3f32, "108"),
-        (23f32, "110"),
-        (23.1f32, "110"),
-        (23.2f32, "110"),
-        (23.3f32, "110"),
-        (24f32, "112"),
-        (24.1f32, "112"),
-        (24.2f32, "112"),
-        (24.3f32, "112"),
-        (24.4f32, "112"),
-        (24.5f32, "112"),
-        (24.6f32, "112"),
-        (24.7f32, "112"),
-        (24.8f32, "112"),
-        (25f32, "114"),
-        (25.1f32, "114"),
-        (25.2f32, "114"),
-        (25.3f32, "114"),
-        (25.4f32, "114"),
-        (25.5f32, "114"),
-        (25.6f32, "114"),
-        (25.7f32, "114"),
-        (25.8f32, "114"),
-        (25.9f32, "114"),
-        (26f32, "116"),
-        (26.1f32, "116"),
-        (26.2f32, "116"),
-        (26.3f32, "116"),
-        (26.4f32, "116"),
-        (26.5f32, "116"),
-        (26.6f32, "116"),
-        (27f32, "118"),
-        (27.1f32, "118"),
-        (27.2f32, "118"),
-        (27.3f32, "118"),
-        (28f32, "120"),
-        (28.1f32, "120"),
-        (28.2f32, "120"),
-        (29f32, "122"),
-        (29.1f32, "122"),
-        (30f32, "124"),
+        (ElectronVersion::new(0u16, 20u16), "39"),
+        (ElectronVersion::new(0u16, 21u16), "41"),
+        (ElectronVersion::new(0u16, 22u16), "41"),
+        (ElectronVersion::new(0u16, 23u16), "41"),
+        (ElectronVersion::new(0u16, 24u16), "41"),
+        (ElectronVersion::new(0u16, 25u16), "42"),
+        (ElectronVersion::new(0u16, 26u16), "42"),
+        (ElectronVersion::new(0u16, 27u16), "43"),
+        (ElectronVersion::new(0u16, 28u16), "43"),
+        (ElectronVersion::new(0u16, 29u16), "43"),
+        (ElectronVersion::new(0u16, 30u16), "44"),
+        (ElectronVersion::new(0u16, 31u16), "45"),
+        (ElectronVersion::new(0u16, 32u16), "45"),
+        (ElectronVersion::new(0u16, 33u16), "45"),
+        (ElectronVersion::new(0u16, 34u16), "45"),
+        (ElectronVersion::new(0u16, 35u16), "45"),
+        (ElectronVersion::new(0u16, 36u16), "47"),
+        (ElectronVersion::new(0u16, 37u16), "49"),
+        (ElectronVersion::new(1u16, 0u16), "49"),
+        (ElectronVersion::new(1u16, 1u16), "50"),
+        (ElectronVersion::new(1u16, 2u16), "51"),
+        (ElectronVersion::new(1u16, 3u16), "52"),
+        (ElectronVersion::new(1u16, 4u16), "53"),
+        (ElectronVersion::new(1u16, 5u16), "54"),
+        (ElectronVersion::new(1u16, 6u16), "56"),
+        (ElectronVersion::new(1u16, 7u16), "58"),
+        (ElectronVersion::new(1u16, 8u16), "59"),
+        (ElectronVersion::new(2u16, 0u16), "61"),
+        (ElectronVersion::new(2u16, 1u16), "61"),
+        (ElectronVersion::new(3u16, 0u16), "66"),
+        (ElectronVersion::new(3u16, 1u16), "66"),
+        (ElectronVersion::new(4u16, 0u16), "69"),
+        (ElectronVersion::new(4u16, 1u16), "69"),
+        (ElectronVersion::new(4u16, 2u16), "69"),
+        (ElectronVersion::new(5u16, 0u16), "73"),
+        (ElectronVersion::new(6u16, 0u16), "76"),
+        (ElectronVersion::new(6u16, 1u16), "76"),
+        (ElectronVersion::new(7u16, 0u16), "78"),
+        (ElectronVersion::new(7u16, 1u16), "78"),
+        (ElectronVersion::new(7u16, 2u16), "78"),
+        (ElectronVersion::new(7u16, 3u16), "78"),
+        (ElectronVersion::new(8u16, 0u16), "80"),
+        (ElectronVersion::new(8u16, 1u16), "80"),
+        (ElectronVersion::new(8u16, 2u16), "80"),
+        (ElectronVersion::new(8u16, 3u16), "80"),
+        (ElectronVersion::new(8u16, 4u16), "80"),
+        (ElectronVersion::new(8u16, 5u16), "80"),
+        (ElectronVersion::new(9u16, 0u16), "83"),
+        (ElectronVersion::new(9u16, 1u16), "83"),
+        (ElectronVersion::new(9u16, 2u16), "83"),
+        (ElectronVersion::new(9u16, 3u16), "83"),
+        (ElectronVersion::new(9u16, 4u16), "83"),
+        (ElectronVersion::new(10u16, 0u16), "85"),
+        (ElectronVersion::new(10u16, 1u16), "85"),
+        (ElectronVersion::new(10u16, 2u16), "85"),
+        (ElectronVersion::new(10u16, 3u16), "85"),
+        (ElectronVersion::new(10u16, 4u16), "85"),
+        (ElectronVersion::new(11u16, 0u16), "87"),
+        (ElectronVersion::new(11u16, 1u16), "87"),
+        (ElectronVersion::new(11u16, 2u16), "87"),
+        (ElectronVersion::new(11u16, 3u16), "87"),
+        (ElectronVersion::new(11u16, 4u16), "87"),
+        (ElectronVersion::new(11u16, 5u16), "87"),
+        (ElectronVersion::new(12u16, 0u16), "89"),
+        (ElectronVersion::new(12u16, 1u16), "89"),
+        (ElectronVersion::new(12u16, 2u16), "89"),
+        (ElectronVersion::new(13u16, 0u16), "91"),
+        (ElectronVersion::new(13u16, 1u16), "91"),
+        (ElectronVersion::new(13u16, 2u16), "91"),
+        (ElectronVersion::new(13u16, 3u16), "91"),
+        (ElectronVersion::new(13u16, 4u16), "91"),
+        (ElectronVersion::new(13u16, 5u16), "91"),
+        (ElectronVersion::new(13u16, 6u16), "91"),
+        (ElectronVersion::new(14u16, 0u16), "93"),
+        (ElectronVersion::new(14u16, 1u16), "93"),
+        (ElectronVersion::new(14u16, 2u16), "93"),
+        (ElectronVersion::new(15u16, 0u16), "94"),
+        (ElectronVersion::new(15u16, 1u16), "94"),
+        (ElectronVersion::new(15u16, 2u16), "94"),
+        (ElectronVersion::new(15u16, 3u16), "94"),
+        (ElectronVersion::new(15u16, 4u16), "94"),
+        (ElectronVersion::new(15u16, 5u16), "94"),
+        (ElectronVersion::new(16u16, 0u16), "96"),
+        (ElectronVersion::new(16u16, 1u16), "96"),
+        (ElectronVersion::new(16u16, 2u16), "96"),
+        (ElectronVersion::new(17u16, 0u16), "98"),
+        (ElectronVersion::new(17u16, 1u16), "98"),
+        (ElectronVersion::new(17u16, 2u16), "98"),
+        (ElectronVersion::new(17u16, 3u16), "98"),
+        (ElectronVersion::new(17u16, 4u16), "98"),
+        (ElectronVersion::new(18u16, 0u16), "100"),
+        (ElectronVersion::new(18u16, 1u16), "100"),
+        (ElectronVersion::new(18u16, 2u16), "100"),
+        (ElectronVersion::new(18u16, 3u16), "100"),
+        (ElectronVersion::new(19u16, 0u16), "102"),
+        (ElectronVersion::new(19u16, 1u16), "102"),
+        (ElectronVersion::new(20u16, 0u16), "104"),
+        (ElectronVersion::new(20u16, 1u16), "104"),
+        (ElectronVersion::new(20u16, 2u16), "104"),
+        (ElectronVersion::new(20u16, 3u16), "104"),
+        (ElectronVersion::new(21u16, 0u16), "106"),
+        (ElectronVersion::new(21u16, 1u16), "106"),
+        (ElectronVersion::new(21u16, 2u16), "106"),
+        (ElectronVersion::new(21u16, 3u16), "106"),
+        (ElectronVersion::new(21u16, 4u16), "106"),
+        (ElectronVersion::new(22u16, 0u16), "108"),
+        (ElectronVersion::new(22u16, 1u16), "108"),
+        (ElectronVersion::new(22u16, 2u16), "108"),
+        (ElectronVersion::new(22u16, 3u16), "108"),
+        (ElectronVersion::new(23u16, 0u16), "110"),
+        (ElectronVersion::new(23u16, 1u16), "110"),
+        (ElectronVersion::new(23u16, 2u16), "110"),
+        (ElectronVersion::new(23u16, 3u16), "110"),
+        (ElectronVersion::new(24u16, 0u16), "112"),
+        (ElectronVersion::new(24u16, 1u16), "112"),
+        (ElectronVersion::new(24u16, 2u16), "112"),
+        (ElectronVersion::new(24u16, 3u16), "112"),
+        (ElectronVersion::new(24u16, 4u16), "112"),
+        (ElectronVersion::new(24u16, 5u16), "112"),
+        (ElectronVersion::new(24u16, 6u16), "112"),
+        (ElectronVersion::new(24u16, 7u16), "112"),
+        (ElectronVersion::new(24u16, 8u16), "112"),
+        (ElectronVersion::new(25u16, 0u16), "114"),
+        (ElectronVersion::new(25u16, 1u16), "114"),
+        (ElectronVersion::new(25u16, 2u16), "114"),
+        (ElectronVersion::new(25u16, 3u16), "114"),
+        (ElectronVersion::new(25u16, 4u16), "114"),
+        (ElectronVersion::new(25u16, 5u16), "114"),
+        (ElectronVersion::new(25u16, 6u16), "114"),
+        (ElectronVersion::new(25u16, 7u16), "114"),
+        (ElectronVersion::new(25u16, 8u16), "114"),
+        (ElectronVersion::new(25u16, 9u16), "114"),
+        (ElectronVersion::new(26u16, 0u16), "116"),
+        (ElectronVersion::new(26u16, 1u16), "116"),
+        (ElectronVersion::new(26u16, 2u16), "116"),
+        (ElectronVersion::new(26u16, 3u16), "116"),
+        (ElectronVersion::new(26u16, 4u16), "116"),
+        (ElectronVersion::new(26u16, 5u16), "116"),
+        (ElectronVersion::new(26u16, 6u16), "116"),
+        (ElectronVersion::new(27u16, 0u16), "118"),
+        (ElectronVersion::new(27u16, 1u16), "118"),
+        (ElectronVersion::new(27u16, 2u16), "118"),
+        (ElectronVersion::new(27u16, 3u16), "118"),
+        (ElectronVersion::new(28u16, 0u16), "120"),
+        (ElectronVersion::new(28u16, 1u16), "120"),
+        (ElectronVersion::new(28u16, 2u16), "120"),
+        (ElectronVersion::new(29u16, 0u16), "122"),
+        (ElectronVersion::new(29u16, 1u16), "122"),
+        (ElectronVersion::new(30u16, 0u16), "124"),
     ]
 });

src/queries/electron_accurate.rs

@@ -6,7 +6,7 @@ use crate::{
 
 pub(super) fn electron_accurate(version: &str) -> QueryResult {
     let version_str = version;
-    let version: f32 = parse_version(version)?;
+    let version = parse_version(version)?;
 
     let distribs = ELECTRON_VERSIONS
         .iter()

src/queries/electron_bounded_range.rs

@@ -7,8 +7,8 @@ use crate::{
 pub(super) fn electron_bounded_range(from: &str, to: &str) -> QueryResult {
     let from_str = from;
     let to_str = to;
-    let from: f32 = parse_version(from)?;
-    let to: f32 = parse_version(to)?;
+    let from = parse_version(from)?;
+    let to = parse_version(to)?;
 
     if ELECTRON_VERSIONS
         .iter()

src/queries/electron_unbounded_range.rs

@@ -5,7 +5,7 @@ use crate::{
 };
 
 pub(super) fn electron_unbounded_range(comparator: Comparator, version: &str) -> QueryResult {
-    let version: f32 = parse_version(version)?;
+    let version = parse_version(version)?;
 
     let distribs = ELECTRON_VERSIONS
         .iter()