crapify 0.1.0

Deep-fry your images, and other crimes against pixels.
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
126
127
128

use std::fmt;
use std::path::PathBuf;

pub enum CrapifyError {
    MissingInput(PathBuf),
    InputIsDirectory(PathBuf),
    NoStages,
    EmptyStage(usize),
    UnknownStage(String),
    UnsupportedFormat(String),
    DecoderError(image::ImageError),
    EncoderError(image::ImageError),
    Io(std::io::Error),
    Clap(clap::Error),
}

impl fmt::Display for CrapifyError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::MissingInput(p) => {
                write!(
                    f,
                    "crapify: {}: not where you said it would be.",
                    p.display()
                )
            }
            Self::InputIsDirectory(p) => {
                write!(
                    f,
                    "crapify: cowardly refused to crapify a directory ({}).",
                    p.display()
                )
            }
            Self::NoStages => {
                write!(f, "crapify: no stages given. crapify what, exactly?")
            }
            Self::EmptyStage(i) => {
                write!(f, "crapify: empty stage at position {i}. one '+' too many.")
            }
            Self::UnknownStage(s) => {
                write!(f, "crapify: '{s}': not a crapifier i know about.")
            }
            Self::UnsupportedFormat(s) => {
                write!(
                    f,
                    "crapify: don't know how to encode '{s}'. try .png or .jpg."
                )
            }
            Self::DecoderError(e) => {
                write!(
                    f,
                    "crapify: that file claims to be an image but won't decode: {e}"
                )
            }
            Self::EncoderError(e) => {
                write!(
                    f,
                    "crapify: ruined the pixels, then ruined the encoder: {e}"
                )
            }
            Self::Io(e) => write!(f, "crapify: {e}"),
            Self::Clap(e) => write!(f, "{e}"),
        }
    }
}

impl fmt::Debug for CrapifyError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(self, f)
    }
}

impl std::error::Error for CrapifyError {}

impl From<clap::Error> for CrapifyError {
    fn from(e: clap::Error) -> Self {
        Self::Clap(e)
    }
}

impl From<std::io::Error> for CrapifyError {
    fn from(e: std::io::Error) -> Self {
        Self::Io(e)
    }
}

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

    #[test]
    fn missing_input_brand_voice() {
        let e = CrapifyError::MissingInput(PathBuf::from("foo.png"));
        assert!(format!("{e}").starts_with("crapify: foo.png:"));
    }

    #[test]
    fn directory_brand_voice() {
        let e = CrapifyError::InputIsDirectory(PathBuf::from("/tmp"));
        let s = format!("{e}");
        assert!(s.starts_with("crapify: cowardly refused to crapify a directory"));
        assert!(s.contains("/tmp"));
    }

    #[test]
    fn no_stages_brand_voice() {
        let e = CrapifyError::NoStages;
        assert!(format!("{e}").starts_with("crapify: no stages given"));
    }

    #[test]
    fn empty_stage_brand_voice() {
        let e = CrapifyError::EmptyStage(2);
        assert!(format!("{e}").contains("empty stage at position 2"));
    }

    #[test]
    fn unknown_stage_brand_voice() {
        let e = CrapifyError::UnknownStage("xerox".into());
        assert!(format!("{e}").contains("'xerox': not a crapifier"));
    }

    #[test]
    fn unsupported_format_brand_voice() {
        let e = CrapifyError::UnsupportedFormat("heic".into());
        assert!(format!("{e}").contains("'heic'"));
    }
}