diffy 0.5.0

Tools for finding and manipulating differences between files
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

//! Error types for patches parsing.

use alloc::string::String;
use core::fmt;
use core::ops::Range;

use crate::binary::BinaryPatchParseError;
use crate::patch::ParsePatchError;

/// An error returned when parsing patches fails.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PatchSetParseError {
    pub(crate) kind: PatchSetParseErrorKind,
    span: Option<Range<usize>>,
}

impl PatchSetParseError {
    /// Creates a new error with the given kind and span.
    pub(crate) fn new(kind: PatchSetParseErrorKind, span: Range<usize>) -> Self {
        Self {
            kind,
            span: Some(span),
        }
    }

    /// Sets the byte range span for this error.
    pub(crate) fn set_span(&mut self, span: Range<usize>) {
        self.span = Some(span);
    }
}

impl fmt::Display for PatchSetParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if let Some(span) = &self.span {
            write!(
                f,
                "error parsing patches at byte {}: {}",
                span.start, self.kind
            )
        } else {
            write!(f, "error parsing patches: {}", self.kind)
        }
    }
}

impl core::error::Error for PatchSetParseError {}

impl From<PatchSetParseErrorKind> for PatchSetParseError {
    fn from(kind: PatchSetParseErrorKind) -> Self {
        Self { kind, span: None }
    }
}

/// The kind of error that occurred when parsing patches.
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub(crate) enum PatchSetParseErrorKind {
    /// Single patch parsing failed.
    Patch(ParsePatchError),

    /// No valid patches found in input.
    NoPatchesFound,

    /// Patch has no file path.
    NoFilePath,

    /// Patch has both original and modified as /dev/null.
    BothDevNull,

    /// Delete patch missing original path.
    DeleteMissingOriginalPath,

    /// Create patch missing modified path.
    CreateMissingModifiedPath,

    /// Invalid file mode string.
    InvalidFileMode(String),

    /// Invalid `diff --git` path.
    InvalidDiffGitPath,

    /// Binary patch parsing failed.
    BinaryParse(BinaryPatchParseError),
}

impl fmt::Display for PatchSetParseErrorKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Patch(e) => write!(f, "{e}"),
            Self::NoPatchesFound => write!(f, "no valid patches found"),
            Self::NoFilePath => write!(f, "patch has no file path"),
            Self::BothDevNull => write!(f, "patch has both original and modified as /dev/null"),
            Self::DeleteMissingOriginalPath => write!(f, "delete patch has no original path"),
            Self::CreateMissingModifiedPath => write!(f, "create patch has no modified path"),
            Self::InvalidFileMode(mode) => write!(f, "invalid file mode: {mode}"),
            Self::InvalidDiffGitPath => write!(f, "invalid diff --git path"),
            Self::BinaryParse(e) => write!(f, "{e}"),
        }
    }
}

impl From<ParsePatchError> for PatchSetParseError {
    fn from(e: ParsePatchError) -> Self {
        PatchSetParseErrorKind::Patch(e).into()
    }
}

impl From<BinaryPatchParseError> for PatchSetParseError {
    fn from(e: BinaryPatchParseError) -> Self {
        PatchSetParseErrorKind::BinaryParse(e).into()
    }
}