auto-palette 0.5.0

🎨 A Rust library that extracts prominent color palettes from images automatically.
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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

#[cfg(feature = "image")]
use image::ImageError;

/// The error type for the auto-palette crate.
/// This error type is used for all errors in the crate.
#[derive(Debug)]
pub enum Error {
    /// The image data is empty and cannot be processed.
    EmptyImageData,

    /// The image data contains invalid pixel data.
    InvalidImageData,

    /// The palette extraction process failed.
    /// The details provide more information about the error.
    ExtractionFailure { details: String },

    /// The algorithm is not supported.
    /// The name provides more information about the unsupported algorithm.
    UnsupportedAlgorithm { name: String },

    /// The theme is not supported.
    /// The name provides more information about the unsupported theme.
    UnsupportedTheme { name: String },

    /// The image loading process failed.
    /// The cause provides more information about the error.
    #[cfg(feature = "image")]
    ImageLoadError { cause: ImageError },

    /// The color type of the image is not supported.
    #[cfg(feature = "image")]
    UnsupportedImage,
}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            Error::InvalidImageData => write!(f, "The image data contains invalid pixel data."),
            Error::EmptyImageData => {
                write!(f, "The image data is empty and cannot be processed.")
            }
            Error::ExtractionFailure { details } => {
                write!(
                    f,
                    "The palette extraction process failed with error: {}",
                    details
                )
            }
            Error::UnsupportedAlgorithm { name } => {
                write!(f, "The algorithm '{}' is not supported.", name)
            }
            Error::UnsupportedTheme { name } => {
                write!(f, "The theme '{}' is not supported.", name)
            }
            #[cfg(feature = "image")]
            Error::ImageLoadError { cause } => {
                write!(f, "The image loading process failed with error: {}", cause)
            }
            #[cfg(feature = "image")]
            Error::UnsupportedImage => {
                write!(f, "The image format is not supported.")
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_fmt_empty_image_data() {
        // Act
        let actual = Error::EmptyImageData;

        // Assert
        assert_eq!(
            actual.to_string(),
            "The image data is empty and cannot be processed."
        );
    }

    #[test]
    fn test_fmt_invalid_image_data() {
        // Act
        let actual = Error::InvalidImageData;

        // Assert
        assert_eq!(
            actual.to_string(),
            "The image data contains invalid pixel data."
        );
    }

    #[test]
    fn test_fmt_extraction_failure() {
        // Act
        let actual = Error::ExtractionFailure {
            details: "Failed to extract palette.".to_string(),
        };

        // Assert
        assert_eq!(
            actual.to_string(),
            "The palette extraction process failed with error: Failed to extract palette."
        );
    }

    #[test]
    fn test_fmt_unsupported_algorithm() {
        // Act
        let actual = Error::UnsupportedAlgorithm {
            name: "unknown_algorithm".to_string(),
        };

        // Assert
        assert_eq!(
            actual.to_string(),
            "The algorithm 'unknown_algorithm' is not supported."
        );
    }

    #[test]
    fn test_fmt_unsupported_theme() {
        // Act
        let actual = Error::UnsupportedTheme {
            name: "unknown_theme".to_string(),
        };

        // Assert
        assert_eq!(
            actual.to_string(),
            "The theme 'unknown_theme' is not supported."
        );
    }

    #[test]
    #[cfg(feature = "image")]
    fn test_fmt_image_load_error() {
        // Arrange
        let cause = ImageError::IoError(std::io::Error::from(std::io::ErrorKind::NotFound));
        let error = Error::ImageLoadError { cause };

        // Act
        let actual = error.to_string();

        // Assert
        assert_eq!(
            actual,
            "The image loading process failed with error: entity not found"
        );
    }

    #[test]
    #[cfg(feature = "image")]
    fn test_fmt_unsupported_image() {
        // Act
        let actual = Error::UnsupportedImage;

        // Assert
        assert_eq!(actual.to_string(), "The image format is not supported.");
    }
}