thumbor 0.0.2

A Rust client for the Thumbor image service
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

use base64ct::{Base64Url, Encoding};
use hmac::Mac;
use http::Uri;

use crate::{
    error::Error,
    server::{HmacSha1, Security},
};

use super::{FitIn, ResponseMode, Settings, Trim};

impl Settings {
    fn build_path(&self, image_uri: &str) -> String {
        let mut path = vec![];

        if let Some(resp) = &self.response {
            path.push(
                match resp {
                    ResponseMode::Metadata => "meta",
                    ResponseMode::Debug => "debug",
                }
                .to_owned(),
            );
        }

        if let Some(orientation) = &self.trim {
            path.push(
                match orientation {
                    Trim::TopLeft => "trim:top-left",
                    Trim::BottomRight => "trim:bottom-right",
                }
                .to_owned(),
            );
        }

        if let Some(crop) = &self.crop {
            path.push(crop.to_string());
        }

        if let Some(fit_in) = &self.fit_in {
            path.push(
                match fit_in {
                    FitIn::Default => "fit-in",
                    FitIn::Adaptive => "adaptive-fit-in",
                    FitIn::Full => "full-fit-in",
                }
                .to_owned(),
            );
        }

        if let Some(resize) = &self.resize {
            path.push(resize.to_string());
        }

        if let Some(h_align) = &self.h_align {
            path.push(h_align.as_ref().to_owned());
        }

        if let Some(v_align) = &self.v_align {
            path.push(v_align.as_ref().to_owned());
        }

        if self.smart {
            path.push("smart".to_owned());
        }

        if !self.filters.is_empty() {
            let filters = self
                .filters
                .iter()
                .map(ToString::to_string)
                .collect::<Vec<_>>()
                .join(":");

            path.push(format!("filters:{filters}"));
        }

        path.push(image_uri.to_owned());

        path.join("/")
    }

    /// # Errors
    /// - `Error::UrlParseError`: URL parsing failed.
    /// - `Error::UrlCannotBeABase`: this URL is cannot-be-a-base.
    /// # Panics
    /// TODO: doc
    pub fn build(&self, image_uri: &str) -> Result<String, Error> {
        let path = self.build_path(image_uri);

        let security = match &self.server.security {
            Security::Unsafe => "unsafe".to_owned(),
            Security::Hmac(secret_key) => {
                let mut mac = HmacSha1::new_from_slice(secret_key.as_bytes()).unwrap();

                mac.update(path.as_bytes());

                let signature = mac.finalize().into_bytes();

                Base64Url::encode_string(&signature)
            }
        };

        Ok(format!("{}/{}/{}", self.server.origin, security, path))
    }

    /// # Errors
    /// - `Error::UrlParseError`: URL parsing failed.
    /// - `Error::UrlCannotBeABase`: this URL is cannot-be-a-base.
    /// # Panics
    /// TODO: doc
    pub fn build_uri(&self, image_uri: &str) -> Result<Uri, Error> {
        Ok(self.build(image_uri).unwrap().parse::<Uri>().unwrap())
    }
}