diffo 0.2.0

Semantic diffing for Rust structs via serde
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

use super::Formatter;
use crate::{Diff, FormatError};

/// Pretty formatter for human-readable colored terminal output.
///
/// # Examples
///
/// ```
/// use diffo::{diff, format::PrettyFormatter, format::Formatter};
///
/// let old = vec![1, 2, 3];
/// let new = vec![1, 2, 4];
///
/// let d = diff(&old, &new).unwrap();
/// let formatter = PrettyFormatter::new();
/// println!("{}", formatter.format(&d).unwrap());
/// ```
#[derive(Debug)]
pub struct PrettyFormatter {
    use_colors: bool,
    indent: usize,
}

impl PrettyFormatter {
    /// Create a new pretty formatter with default settings.
    pub fn new() -> Self {
        Self {
            use_colors: cfg!(feature = "pretty"),
            indent: 2,
        }
    }

    /// Enable or disable colors.
    pub fn with_colors(mut self, enabled: bool) -> Self {
        self.use_colors = enabled;
        self
    }

    /// Set the indentation level.
    pub fn with_indent(mut self, spaces: usize) -> Self {
        self.indent = spaces;
        self
    }
}

impl Default for PrettyFormatter {
    fn default() -> Self {
        Self::new()
    }
}

impl Formatter for PrettyFormatter {
    fn format(&self, diff: &Diff) -> Result<String, FormatError> {
        if diff.is_empty() {
            return Ok(String::from("No changes"));
        }

        let mut output = String::new();

        for (path, change) in diff.changes() {
            use crate::Change;

            match change {
                Change::Added(val) => {
                    output.push_str(&format!("+ {}: {:?}\n", path, val));
                }
                Change::Removed(val) => {
                    output.push_str(&format!("- {}: {:?}\n", path, val));
                }
                Change::Modified { from, to } => {
                    output.push_str(&format!("{}\n", path));
                    output.push_str(&format!("  - {:?}\n", from));
                    output.push_str(&format!("  + {:?}\n", to));
                }
                Change::Elided { reason, count } => {
                    output.push_str(&format!("~ {}: {} ({} items)\n", path, reason, count));
                }
            }
        }

        Ok(output)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{Change, Path};
    use serde_value::Value;

    #[test]
    fn test_empty_diff() {
        let diff = Diff::new();
        let formatter = PrettyFormatter::new();
        let output = formatter.format(&diff).unwrap();
        assert_eq!(output, "No changes");
    }

    #[test]
    fn test_added() {
        let mut diff = Diff::new();
        diff.insert(Path::root().field("x"), Change::Added(Value::I64(42)));

        let formatter = PrettyFormatter::new();
        let output = formatter.format(&diff).unwrap();
        assert!(output.contains("+ x:"));
    }
}