rustrails-storage 0.1.2

File storage (ActiveStorage equivalent)
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

//! Typed image transformation configuration helpers.

use std::collections::BTreeMap;

use serde_json::{Value, json};

/// Resize dimensions for an image variant.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ResizeTransform {
    /// Target width in pixels.
    pub width: u32,
    /// Target height in pixels.
    pub height: u32,
}

impl ResizeTransform {
    /// Creates a resize transform.
    #[must_use]
    pub const fn new(width: u32, height: u32) -> Self {
        Self { width, height }
    }
}

/// Crop rectangle for an image variant.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CropTransform {
    /// Left offset in pixels.
    pub x: u32,
    /// Top offset in pixels.
    pub y: u32,
    /// Crop width in pixels.
    pub width: u32,
    /// Crop height in pixels.
    pub height: u32,
}

impl CropTransform {
    /// Creates a crop transform.
    #[must_use]
    pub const fn new(x: u32, y: u32, width: u32, height: u32) -> Self {
        Self {
            x,
            y,
            width,
            height,
        }
    }
}

/// Typed image transformation configuration that converts into variant options.
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct ImageTransformations {
    /// Resize instruction applied before upload.
    pub resize: Option<ResizeTransform>,
    /// Crop instruction applied before upload.
    pub crop: Option<CropTransform>,
    /// Optional output image format such as `png`.
    pub format: Option<String>,
}

impl ImageTransformations {
    /// Creates an empty transformation set.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Adds a resize transform.
    #[must_use]
    pub fn resize(mut self, width: u32, height: u32) -> Self {
        self.resize = Some(ResizeTransform::new(width, height));
        self
    }

    /// Adds a crop transform.
    #[must_use]
    pub fn crop(mut self, x: u32, y: u32, width: u32, height: u32) -> Self {
        self.crop = Some(CropTransform::new(x, y, width, height));
        self
    }

    /// Sets the output image format.
    #[must_use]
    pub fn format(mut self, format: impl Into<String>) -> Self {
        self.format = Some(format.into());
        self
    }

    /// Converts the transformation set into variant options.
    #[must_use]
    pub fn to_map(&self) -> BTreeMap<String, Value> {
        let mut transformations = BTreeMap::new();
        if let Some(resize) = self.resize {
            transformations.insert(
                "resize".to_owned(),
                json!({"width": resize.width, "height": resize.height}),
            );
        }
        if let Some(crop) = self.crop {
            transformations.insert(
                "crop".to_owned(),
                json!({
                    "x": crop.x,
                    "y": crop.y,
                    "width": crop.width,
                    "height": crop.height,
                }),
            );
        }
        if let Some(format) = &self.format {
            transformations.insert("format".to_owned(), Value::String(format.clone()));
        }
        transformations
    }
}

impl From<ImageTransformations> for BTreeMap<String, Value> {
    fn from(value: ImageTransformations) -> Self {
        value.to_map()
    }
}

impl From<&ImageTransformations> for BTreeMap<String, Value> {
    fn from(value: &ImageTransformations) -> Self {
        value.to_map()
    }
}

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

    #[test]
    fn resize_and_crop_transformations_convert_to_variant_map() {
        let transformations = ImageTransformations::new()
            .resize(100, 200)
            .crop(10, 20, 80, 160)
            .format("png")
            .to_map();
        assert_eq!(
            transformations.get("resize"),
            Some(&json!({"width": 100, "height": 200})),
        );
        assert_eq!(
            transformations.get("crop"),
            Some(&json!({"x": 10, "y": 20, "width": 80, "height": 160})),
        );
        assert_eq!(
            transformations.get("format"),
            Some(&Value::String("png".to_owned()))
        );
    }

    #[test]
    fn empty_transformations_produce_empty_map() {
        assert!(ImageTransformations::new().to_map().is_empty());
    }
}