os-identifier 0.4.0

Resolve product / release names of operating systems used by endoflife.date into canonical names.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use regex::Regex;

//
// Returns true if a string consists of multiple parts separated by '-'.
// or not separated at all
// String does not use any other separator.
// . is not considered a separator
//
pub(crate) fn is_subdivided_by_dashes_only(s: &str) -> bool {
    // Return false if string is empty
    if s.is_empty() {
        return false;
    }

    // Return false if there are invalid separators present
    let forbidden_separators = [' ', '_', ',', ';', '/', '\\', ':', '|', '+'];
    if s.chars().any(|ch| forbidden_separators.contains(&ch)) {
        return false;
    }

    // If splitting by dash gives more than one part, it's separated by dashes
    // and no other separators are present
    s.split('-').count() > 0
}

//
pub fn contains_any_word(haystack: &str, words: &[&str]) -> bool {
    let pattern = words
        .iter()
        .map(|w| regex::escape(w))
        .collect::<Vec<_>>()
        .join("|");
    let regex_pattern = format!(r"\b({})\b", pattern);
    let re = Regex::new(&regex_pattern).unwrap();
    re.is_match(haystack)
}

pub fn find_number_with_digits(input: &str, digits: usize) -> Option<String> {
    let pattern = format!(r"\b\d{{{}}}\b", digits);
    let re = Regex::new(&pattern).unwrap();
    re.find(input).map(|m| m.as_str().to_string())
}

pub fn resolve_build_to_release(build: &str, map: phf::Map<&'static str, &'static [&'static str]>) -> Result<String, String> {
    if let Some(release) = map.get(build) {
        Ok(release.get(0).unwrap().to_string())
    } else {
        Err(format!("Build '{}' does not exist.", build))
    }
}

pub fn identify_release(input: &str, pattern: &str) -> Option<String> {
    let pattern = format!(r"\b({})\b", pattern);
    let re = Regex::new(&pattern).unwrap();
    re.find(input).map(|m| m.as_str().to_string())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_is_subdivided_by_dashes_only() {
        let label1 = "windows-11-24h2-iot-lts";
        let label2 = "windows-11-24h2-iot lts";
        let label3 = "2025";
        let label4 = "8.1";

        assert_eq!(is_subdivided_by_dashes_only(label1), true);
        assert_eq!(is_subdivided_by_dashes_only(label2), false);
        assert_eq!(is_subdivided_by_dashes_only(label3), true);
        assert_eq!(is_subdivided_by_dashes_only(label4), true);
    }

    #[test]
    fn test_contains_any_word_true() {
        let label1 = "Windows 11 Professional Edition";
        let label2 = "Windows 11 Pro 24H2";
        let word = ["Professional Edition", "Professional", "Pro"];

        assert_eq!(contains_any_word(label1, &word), true);
        assert_eq!(contains_any_word(label2, &word), true);
    }

    #[test]
    fn test_contains_any_word_false() {
        let label1 = "Windows 11 Professional Edition";
        let label2 = "Windows 11 Pro 24H2";
        let word = ["Enterprise Edition", "Enterprise"];

        assert_eq!(contains_any_word(label1, &word), false);
        assert_eq!(contains_any_word(label2, &word), false);
    }

    #[test]
    fn test_find_number_with_digits_some() {
        let label1 = "Windows 11 Professional Edition 26100";
        let label2 = "Windows 11 Professional Edition 26100.4533";

        assert_eq!(find_number_with_digits(label1, 5), Some(String::from("26100")));
        assert_eq!(find_number_with_digits(label2, 5), Some(String::from("26100")));
    }

    #[test]
    fn test_find_number_with_digits_none() {
        let label1 = "Windows 11 Professional Edition 26100";

        assert_eq!(find_number_with_digits(label1, 4), None);
    }

    #[test]
    fn test_identify_release_some() {
        let label1 = "Windows 11 Professional Edition 24H2";

        assert_eq!(identify_release(label1, "22H2|24H2"), Some(String::from("24H2")));
    }

    #[test]
    fn test_identify_release_none() {
        let label1 = "Windows 11 Professional Edition 25H2";

        assert_eq!(identify_release(label1, "22H2|24H2"), None);
    }
}