eger 0.1.2

Parallel, async image/video -> ASCII-art pipeline built on iascii
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Error types for `eger`.
//!
//! [`ConfigError`] covers everything that can go wrong while *building* a
//! [`crate::config::Config`]. [`EgerError`] is the crate-wide error used by
//! every rendering/processing API and wraps `ConfigError` alongside I/O,
//! `iascii`, `image`, `ffmpeg`, and Tokio task failures.

use std::path::PathBuf;
use std::process::ExitStatus;
use thiserror::Error;

/// Errors that can occur while validating and building a [`crate::config::Config`].
#[derive(Debug, Error)]
pub enum ConfigError {
    #[error("no file found at: {0}")]
    FileNotFound(PathBuf),

    #[error("no directory found at: {0}")]
    FolderNotFound(PathBuf),

    #[error("invalid regex pattern '{0}': {1}")]
    InvalidRegexPattern(String, #[source] regex::Error),

    #[error("failed to read {path}: {source}")]
    Io {
        path: PathBuf,
        #[source]
        source: std::io::Error,
    },

    #[error("no media type (Image/Video) was configured")]
    MediaTypeNotFound,

    #[error("no input source was configured; call `from_file` or `from_dir`")]
    MissingSource,

    #[error("no files in '{dir}' matched pattern '{pattern}'")]
    NoMatchingFiles { dir: PathBuf, pattern: String },

    #[error("invalid ASCII rendering configuration: {0}")]
    Ascii(#[from] iascii::error::ImageError),
}

/// The crate-wide error type returned by every `eger` API.
#[derive(Debug, Error)]
pub enum EgerError {
    #[error(transparent)]
    Config(#[from] ConfigError),

    #[error("ASCII conversion failed: {0}")]
    Ascii(#[from] iascii::error::ImageError),

    #[error("image decode/encode error: {0}")]
    Image(#[from] ::image::ImageError),

    #[error("I/O error: {0}")]
    Io(#[from] std::io::Error),

    #[error("video pipeline error: {0}")]
    Video(String),

    #[error("ffmpeg exited with {0}: {1}")]
    Ffmpeg(ExitStatus, String),

    #[error("`ffmpeg`/`ffprobe` was not found on PATH; install ffmpeg to enable video support")]
    FfmpegNotFound,

    #[cfg(feature = "video")]
    #[error("background task failed: {0}")]
    Join(#[from] tokio::task::JoinError),

    #[error("render error: {0}")]
    Render(String),
}

/// Convenience alias used throughout the crate.
pub type Result<T> = std::result::Result<T, EgerError>;

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

    #[test]
    fn config_error_messages_include_the_offending_path() {
        let path = PathBuf::from("/tmp/does-not-exist.png");
        let err = ConfigError::FileNotFound(path.clone());
        assert!(err.to_string().contains(&path.display().to_string()));

        let err = ConfigError::FolderNotFound(path.clone());
        assert!(err.to_string().contains(&path.display().to_string()));
    }

    #[test]
    fn no_matching_files_message_includes_dir_and_pattern() {
        let err = ConfigError::NoMatchingFiles {
            dir: PathBuf::from("/tmp/frames"),
            pattern: r"\.png$".to_string(),
        };
        let msg = err.to_string();
        assert!(msg.contains("/tmp/frames"));
        assert!(msg.contains(r"\.png$"));
    }

    #[test]
    fn config_error_converts_into_eger_error() {
        let config_err = ConfigError::MissingSource;
        let eger_err: EgerError = config_err.into();
        assert!(matches!(
            eger_err,
            EgerError::Config(ConfigError::MissingSource)
        ));
    }

    #[test]
    fn io_error_converts_into_eger_error() {
        let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "gone");
        let eger_err: EgerError = io_err.into();
        assert!(matches!(eger_err, EgerError::Io(_)));
    }

    #[test]
    fn ffmpeg_error_reports_exit_status_and_stderr() {
        let status = std::process::Command::new("false").status().or_else(|_| {
            std::process::Command::new("cmd")
                .arg("/C")
                .arg("exit 1")
                .status()
        });
        let Ok(status) = status else {
            eprintln!("skipping: no shell available to produce a failing ExitStatus");
            return;
        };
        let err = EgerError::Ffmpeg(status, "boom".into());
        let msg = err.to_string();
        assert!(msg.contains("boom"));
    }

    #[test]
    fn ffmpeg_not_found_has_actionable_message() {
        let err = EgerError::FfmpegNotFound;
        assert!(err.to_string().to_lowercase().contains("ffmpeg"));
        assert!(err.to_string().to_lowercase().contains("path"));
    }
}