diffogus 0.4.0

Rust crate to calculate the difference between 2 instances of a type.
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

#[cfg(test)]
mod tests {
    use diffogus::diff::{Changeable, CollectionDiffEntry, Diffable, OptionDiff, PrimitiveDiff};
    use std::collections::HashMap;

    #[test]
    fn test_primitive_diff() {
        // Integer diff
        let a: i32 = 5;
        let b = 10;
        let diff = a.diff(&b);
        assert!(diff.is_changed());
        if let PrimitiveDiff::Changed { old, new } = diff {
            assert_eq!(old, 5);
            assert_eq!(new, 10);
        }

        // Float diff (with EPSILON)
        let a = 1.0;
        let b = 1.0 + f64::EPSILON;
        let diff = a.diff(&b);
        assert!(!diff.is_changed()); // No significant change

        // Boolean diff
        let a = true;
        let b = false;
        let diff = a.diff(&b);
        assert!(diff.is_changed());
    }

    #[test]
    fn test_string_diff() {
        let a = String::from("hello");
        let b = String::from("world");
        let diff = a.diff(&b);

        assert!(diff.is_changed());
        if let PrimitiveDiff::Changed { old, new } = diff {
            assert_eq!(old, "hello");
            assert_eq!(new, "world");
        }

        // Unchanged case
        let a = String::from("same");
        let b = String::from("same");
        let diff = a.diff(&b);
        assert!(!diff.is_changed());
    }

    #[test]
    fn test_option_diff() {
        let a: Option<i32> = Some(10);
        let b: Option<i32> = Some(20);

        let diff = a.diff(&b);
        assert!(diff.is_changed());
        if let OptionDiff::Changed(PrimitiveDiff::Changed { old, new }) = diff {
            assert_eq!(old, 10);
            assert_eq!(new, 20);
        }

        // Removed case
        let a: Option<i32> = Some(10);
        let b: Option<i32> = None;
        let diff = a.diff(&b);
        assert!(diff.is_changed());
        if let OptionDiff::Removed(value) = diff {
            assert_eq!(value, 10);
        }

        // Unchanged case
        let a: Option<i32> = None;
        let b: Option<i32> = None;
        let diff = a.diff(&b);
        assert!(!diff.is_changed());
    }

    #[test]
    fn test_vec_diff() {
        let a = vec![1, 2, 3];
        let b = vec![1, 4, 3];

        let diff = a.diff(&b);
        assert!(diff.is_changed());

        let vec = diff.0;
        assert!(matches!(vec[0], CollectionDiffEntry::Unchanged));
        assert!(matches!(vec[1], CollectionDiffEntry::Changed(_)));
        assert!(matches!(vec[2], CollectionDiffEntry::Unchanged));

        // Unchanged case
        let a = vec![1, 2, 3];
        let b = vec![1, 2, 3];
        let diff = a.diff(&b);
        assert!(!diff.is_changed());
    }

    #[test]
    fn test_hashmap_diff() {
        let mut a = HashMap::new();
        a.insert("key1".to_string(), 1);
        a.insert("key2".to_string(), 2);

        let mut b = HashMap::new();
        b.insert("key1".to_string(), 1); // unchanged
        b.insert("key2".to_string(), 3); // changed
        b.insert("key3".to_string(), 4); // added

        let diff = a.diff(&b);
        assert!(diff.is_changed());

        let map = diff.0;
        assert!(matches!(map["key1"], CollectionDiffEntry::Unchanged));
        assert!(matches!(map["key2"], CollectionDiffEntry::Changed(_)));
        assert!(matches!(map["key3"], CollectionDiffEntry::Added(_)));

        // Unchanged case
        let diff = a.diff(&a);
        assert!(!diff.is_changed());
    }
}