oxihuman-core 0.1.2

Core data structures, algorithms, and asset management for OxiHuman
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
125

// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
// SPDX-License-Identifier: Apache-2.0
#![allow(dead_code)]

use std::collections::HashMap;

/// Keys present in `new` but not in `old`.
pub fn config_added_keys<'a>(
    old: &'a HashMap<String, String>,
    new: &'a HashMap<String, String>,
) -> Vec<&'a str> {
    let mut result: Vec<&'a str> = new
        .keys()
        .filter(|k| !old.contains_key(*k))
        .map(|k| k.as_str())
        .collect();
    result.sort();
    result
}

/// Keys present in `old` but not in `new`.
pub fn config_removed_keys<'a>(
    old: &'a HashMap<String, String>,
    new: &'a HashMap<String, String>,
) -> Vec<&'a str> {
    let mut result: Vec<&'a str> = old
        .keys()
        .filter(|k| !new.contains_key(*k))
        .map(|k| k.as_str())
        .collect();
    result.sort();
    result
}

/// Keys present in both but with different values.
pub fn config_changed_keys<'a>(
    old: &'a HashMap<String, String>,
    new: &'a HashMap<String, String>,
) -> Vec<&'a str> {
    let mut result: Vec<&'a str> = old
        .keys()
        .filter(|k| {
            new.get(*k).map(|v| v.as_str()) != old.get(*k).map(|v| v.as_str())
                && new.contains_key(*k)
        })
        .map(|k| k.as_str())
        .collect();
    result.sort();
    result
}

/// Total number of added + removed + changed keys.
pub fn config_diff_count(old: &HashMap<String, String>, new: &HashMap<String, String>) -> usize {
    config_added_keys(old, new).len()
        + config_removed_keys(old, new).len()
        + config_changed_keys(old, new).len()
}

/// Returns true if both maps are identical.
pub fn config_is_identical(old: &HashMap<String, String>, new: &HashMap<String, String>) -> bool {
    config_diff_count(old, new) == 0
}

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

    fn make_map(pairs: &[(&str, &str)]) -> HashMap<String, String> {
        pairs
            .iter()
            .map(|(k, v)| (k.to_string(), v.to_string()))
            .collect()
    }

    #[test]
    fn test_identical_maps() {
        /* identical maps have no diff */
        let a = make_map(&[("x", "1")]);
        let b = make_map(&[("x", "1")]);
        assert!(config_is_identical(&a, &b));
    }

    #[test]
    fn test_added_keys() {
        /* new key detected as added */
        let old = make_map(&[("a", "1")]);
        let new = make_map(&[("a", "1"), ("b", "2")]);
        let added = config_added_keys(&old, &new);
        assert_eq!(added, vec!["b"]);
    }

    #[test]
    fn test_removed_keys() {
        /* removed key detected */
        let old = make_map(&[("a", "1"), ("b", "2")]);
        let new = make_map(&[("a", "1")]);
        let removed = config_removed_keys(&old, &new);
        assert_eq!(removed, vec!["b"]);
    }

    #[test]
    fn test_changed_keys() {
        /* changed value detected */
        let old = make_map(&[("x", "old")]);
        let new = make_map(&[("x", "new")]);
        let changed = config_changed_keys(&old, &new);
        assert_eq!(changed, vec!["x"]);
    }

    #[test]
    fn test_diff_count() {
        /* diff count sums all changes */
        let old = make_map(&[("a", "1"), ("b", "2")]);
        let new = make_map(&[("a", "9"), ("c", "3")]);
        assert_eq!(config_diff_count(&old, &new), 3);
    }

    #[test]
    fn test_empty_maps() {
        /* two empty maps are identical */
        let a: HashMap<String, String> = HashMap::new();
        let b: HashMap<String, String> = HashMap::new();
        assert!(config_is_identical(&a, &b));
    }
}