chromacat 0.1.0

A versatile command-line tool for applying color gradients to text output
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

use crate::renderer::RendererError;
use std::fmt;
use std::io;

/// Custom error types for ChromaCat
#[derive(Debug)]
pub enum ChromaCatError {
    /// I/O operation failed
    IoError(io::Error),
    /// Invalid parameter value
    InvalidParameter {
        name: String,
        value: f64,
        min: f64,
        max: f64,
    },
    /// Invalid theme name or configuration
    InvalidTheme(String),
    /// Invalid gradient configuration
    GradientError(String),
    /// Pattern parameter validation error
    PatternError {
        pattern: String,
        param: String,
        message: String,
    },
    /// Input file error
    InputError(String),
    /// Parameter parsing error
    ParseError(String),
    /// Rendering error
    RenderError(String),
    /// General error with message
    Other(String),
}

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

impl fmt::Display for ChromaCatError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::IoError(err) => write!(f, "I/O error: {}", err),
            Self::InvalidParameter {
                name,
                value,
                min,
                max,
            } => {
                write!(
                    f,
                    "Invalid {} value {}: must be between {} and {}",
                    name, value, min, max
                )
            }
            Self::InvalidTheme(msg) => write!(f, "Invalid theme: {}", msg),
            Self::GradientError(msg) => write!(f, "Gradient error: {}", msg),
            Self::PatternError {
                pattern,
                param,
                message,
            } => {
                write!(
                    f,
                    "Pattern '{}' parameter '{}' error: {}",
                    pattern, param, message
                )
            }
            Self::InputError(msg) => write!(f, "Input error: {}", msg),
            Self::ParseError(msg) => write!(f, "Parse error: {}", msg),
            Self::RenderError(msg) => write!(f, "Render error: {}", msg),
            Self::Other(msg) => write!(f, "{}", msg),
        }
    }
}

impl From<io::Error> for ChromaCatError {
    fn from(err: io::Error) -> Self {
        Self::IoError(err)
    }
}

impl From<std::fmt::Error> for ChromaCatError {
    fn from(err: std::fmt::Error) -> Self {
        Self::Other(err.to_string())
    }
}

impl From<String> for ChromaCatError {
    fn from(msg: String) -> Self {
        Self::ParseError(msg)
    }
}

// Add conversion from parameter validation errors
impl From<(String, String, String)> for ChromaCatError {
    fn from((pattern, param, message): (String, String, String)) -> Self {
        Self::PatternError {
            pattern,
            param,
            message,
        }
    }
}

// Add conversion from RendererError
impl From<RendererError> for ChromaCatError {
    fn from(err: RendererError) -> Self {
        match err {
            RendererError::IoError(e) => Self::IoError(e),
            RendererError::TerminalError(msg) => Self::RenderError(msg),
            RendererError::BufferError(msg) => Self::RenderError(msg),
            RendererError::InvalidConfig(msg) => Self::RenderError(msg),
            RendererError::PatternError(msg) => Self::PatternError {
                pattern: "render".to_string(),
                param: "pattern".to_string(),
                message: msg,
            },
            RendererError::Other(msg) => Self::RenderError(msg),
        }
    }
}

/// Result type alias using ChromaCatError
pub type Result<T> = std::result::Result<T, ChromaCatError>;