aer 0.2.1

A command-line toolkit for creatives.
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

use std::io::Cursor;

use image::ImageFormat;

use super::{Asset, Environment, LayeredContext, MediaCategory, ProcessesAssets, ProcessingError};

/// Resizes images to fit within a given width and height,
/// preserving the image's original aspect ratio.
///
/// If the image is already within the given width and height,
/// this processor does nothing.
///
/// This processor uses a [Lanczos](https://mazzo.li/posts/lanczos.html)
/// filter when resizing images. This filter is one of the slowest, but
/// produces consistently high-quality results, making it best suited
/// for processing _static_ content.
pub struct ImageResizeProcessor {
    /// The maximum width of the resized image.
    width: u32,

    /// The maximum height of the resized image.
    height: u32,
}

impl ImageResizeProcessor {
    pub fn new(width: u32, height: u32) -> Self {
        Self { width, height }
    }
}

impl ProcessesAssets for ImageResizeProcessor {
    fn process(
        &self,
        _env: &Environment,
        _context: &LayeredContext,
        asset: &mut Asset,
    ) -> Result<bool, ProcessingError> {
        // Skip assets that aren't images.
        if asset.media_type().category() != MediaCategory::Image {
            return Ok(false);
        }

        // Extract image bytes.
        let asset_path = asset.path().clone();
        let image_format = ImageFormat::from_path(asset_path.as_str()).map_err(|e| {
            ProcessingError::Malformed {
                message: e.to_string().into(),
            }
        })?;
        let image_bytes = asset.as_mut_bytes()?;
        let image =
            image::load_from_memory(image_bytes).map_err(|e| ProcessingError::Malformed {
                message: e.to_string().into(),
            })?;

        // Skip resizing if the image is already inside the bounding box.
        if image.width() <= self.width && image.height() <= self.height {
            return Ok(false);
        }

        tracing::trace!("image: {}", asset_path);

        // Resize the image to fit the bounding box.
        let image = image.resize(
            self.width,
            self.height,
            image::imageops::FilterType::Lanczos3,
        );

        // Write resized image.
        image_bytes.clear();
        let mut cursor = Cursor::new(image_bytes);
        image
            .write_to(&mut cursor, image_format)
            .map_err(|e| ProcessingError::Malformed {
                message: e.to_string().into(),
            })?;

        Ok(true)
    }
}

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

    #[test_log::test]
    #[test_log(default_log_filter = "debug")]
    fn resizes_image() {
        let _ = tracing_subscriber::fmt()
            .with_max_level(tracing::Level::DEBUG)
            .with_test_writer()
            .try_init();

        let source_bytes = std::fs::read("test/example.png").unwrap();

        // Wrap the source image in an asset.
        let mut asset = Asset::new("test/example.png".into(), source_bytes.clone());

        // Resize the image.
        let (width, height) = (300, 300);
        ImageResizeProcessor { width, height }
            .process(
                &Environment::test(),
                &LayeredContext::from_flat(Default::default()),
                &mut asset,
            )
            .unwrap();

        // Check the dimensions of the resized image.
        let resized_image = image::load_from_memory(asset.as_bytes()).unwrap();
        assert_eq!(width, resized_image.width());
        assert_eq!(243, resized_image.height());
    }

    #[test]
    fn skips_image_already_within_bounds() {
        let source_bytes = std::fs::read("test/example.png").unwrap();
        let original_bytes = source_bytes.clone();

        let mut asset = Asset::new("photo.png".into(), source_bytes);

        // Use dimensions larger than the test image.
        let modified = ImageResizeProcessor::new(9999, 9999)
            .process(
                &Environment::test(),
                &LayeredContext::from_flat(Default::default()),
                &mut asset,
            )
            .unwrap();

        assert!(!modified);
        assert_eq!(asset.as_bytes(), &original_bytes);
    }

    #[test]
    fn skips_non_image_assets() {
        let mut asset = Asset::new("style.css".into(), b"body {}".to_vec());
        let modified = ImageResizeProcessor::new(300, 300)
            .process(
                &Environment::test(),
                &LayeredContext::from_flat(Default::default()),
                &mut asset,
            )
            .unwrap();
        assert!(!modified);
    }
}