auto-palette 0.7.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

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

/// The `Error` enum represents the errors that can occur in the palette extraction process.
#[derive(Debug, Error)]
pub enum Error {
    /// The image data is empty and cannot be processed.
    #[error("The image data is empty and cannot be processed.")]
    EmptyImageData,

    /// The image data contains invalid pixel data.
    #[error("The image data contains invalid pixel data.")]
    InvalidImageData,

    /// The palette extraction process failed.
    /// The details provide more information about the error.
    #[error("The palette extraction process failed with error: {0}")]
    ExtractionFailure(String),

    /// The algorithm is not supported.
    /// The name provides more information about the unsupported algorithm.
    #[error("The algorithm '{0}' is not supported.")]
    UnsupportedAlgorithm(String),

    /// The theme is not supported.
    /// The name provides more information about the unsupported theme.
    #[error("The theme '{0}' is not supported.")]
    UnsupportedTheme(String),

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

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

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

    #[test]
    fn test_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_invalid_image_data() {
        // Act
        let actual = Error::InvalidImageData;

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

    #[test]
    fn test_extraction_failure() {
        // Act
        let actual = Error::ExtractionFailure("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_unsupported_algorithm() {
        // Act
        let actual = Error::UnsupportedAlgorithm("unknown_algorithm".to_string());

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

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

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

    #[test]
    #[cfg(feature = "image")]
    fn test_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_unsupported_image() {
        // Act
        let actual = Error::UnsupportedImage;

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