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

//! Output formatters for diffs.
//!
//! This module provides various formatters to display diffs in different formats:
//! - Pretty: Human-readable colored terminal output
//! - JSON: JSON representation
//! - JSON Patch: RFC 6902 JSON Patch format
//! - Markdown: Markdown table format

mod json;
mod markdown;
mod patch;
mod pretty;

pub use json::JsonFormatter;
pub use markdown::MarkdownFormatter;
pub use patch::JsonPatchFormatter;
pub use pretty::PrettyFormatter;

use crate::{Diff, FormatError};

/// Trait for formatting diffs into various representations.
pub trait Formatter {
    /// Format the diff into a string.
    fn format(&self, diff: &Diff) -> Result<String, FormatError>;
}

// Convenience methods on Diff
impl Diff {
    /// Format as pretty colored output.
    ///
    /// # Examples
    ///
    /// ```
    /// use diffo::diff;
    ///
    /// let old = vec![1, 2, 3];
    /// let new = vec![1, 2, 4];
    ///
    /// let d = diff(&old, &new).unwrap();
    /// println!("{}", d.to_pretty());
    /// ```
    pub fn to_pretty(&self) -> String {
        PrettyFormatter::new()
            .format(self)
            .unwrap_or_else(|_| String::from("Error formatting diff"))
    }

    /// Format as JSON.
    ///
    /// # Examples
    ///
    /// ```
    /// use diffo::diff;
    ///
    /// let old = vec![1, 2, 3];
    /// let new = vec![1, 2, 4];
    ///
    /// let d = diff(&old, &new).unwrap();
    /// let json = d.to_json().unwrap();
    /// ```
    pub fn to_json(&self) -> Result<String, FormatError> {
        JsonFormatter::new().pretty().format(self)
    }

    /// Format as JSON Patch (RFC 6902).
    ///
    /// # Examples
    ///
    /// ```
    /// use diffo::diff;
    ///
    /// let old = vec![1, 2, 3];
    /// let new = vec![1, 2, 4];
    ///
    /// let d = diff(&old, &new).unwrap();
    /// let patch = d.to_json_patch().unwrap();
    /// ```
    pub fn to_json_patch(&self) -> Result<String, FormatError> {
        JsonPatchFormatter::new().format(self)
    }

    /// Format as Markdown table.
    ///
    /// # Examples
    ///
    /// ```
    /// use diffo::diff;
    ///
    /// let old = vec![1, 2, 3];
    /// let new = vec![1, 2, 4];
    ///
    /// let d = diff(&old, &new).unwrap();
    /// let markdown = d.to_markdown().unwrap();
    /// ```
    pub fn to_markdown(&self) -> Result<String, FormatError> {
        MarkdownFormatter::new().format(self)
    }
}