mrml 6.0.1

Rust implementation of MJML renderer
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

//! Module containing a loader where all the possible files are stored on the
//! filesystem.

use std::io::ErrorKind;
use std::path::PathBuf;
use std::sync::Arc;

use super::loader::IncludeLoaderError;
#[cfg(feature = "async")]
use crate::prelude::parser::loader::AsyncIncludeLoader;
use crate::prelude::parser::loader::IncludeLoader;

#[derive(Debug, Default)]
/// This struct is an
/// [`IncludeLoader`](crate::prelude::parser::loader::IncludeLoader) where
/// you can read a template for the filesystem and be able to use it with
/// [`mj-include`](crate::mj_include).
///
/// # Example
/// ```rust
/// use std::path::PathBuf;
/// use mrml::mj_include::body::MjIncludeBodyKind;
/// use mrml::prelude::parser::local_loader::LocalIncludeLoader;
/// use mrml::prelude::parser::ParserOptions;
///
/// let root = PathBuf::default()
///     .join("resources")
///     .join("compare")
///     .join("success");
/// let resolver = LocalIncludeLoader::new(root);
/// let opts = ParserOptions {
///     include_loader: Box::new(resolver),
/// };
/// let template = r#"<mjml>
///   <mj-body>
///     <mj-include path="file:///mj-accordion.mjml" />
///   </mj-body>
/// </mjml>"#;
/// match mrml::parse_with_options(template, &opts) {
///     Ok(_) => println!("Success!"),
///     Err(err) => eprintln!("Couldn't parse template: {err:?}"),
/// }
/// ```
///
/// About the security: this loader doesn't allow to go fetch a template that
/// is in a parent directory of the root directory.
pub struct LocalIncludeLoader {
    root: PathBuf,
}

impl LocalIncludeLoader {
    pub fn new(root: PathBuf) -> Self {
        Self { root }
    }

    fn build_path(&self, url: &str) -> Result<PathBuf, IncludeLoaderError> {
        let path = self.root.join(url.trim_start_matches("file:///"));
        path.canonicalize()
            .map_err(|err| IncludeLoaderError::new(url, err.kind()))
            .and_then(|path| {
                if !path.starts_with(&self.root) {
                    Err(IncludeLoaderError::new(url, ErrorKind::NotFound))
                } else {
                    Ok(path)
                }
            })
            .map_err(|err| err.with_message("the path should stay in the context of the loader"))
    }
}

impl IncludeLoader for LocalIncludeLoader {
    fn resolve(&self, url: &str) -> Result<String, IncludeLoaderError> {
        let path = self.build_path(url)?;
        std::fs::read_to_string(path).map_err(|err| {
            IncludeLoaderError::new(url, ErrorKind::InvalidData)
                .with_message("unable to load the template file")
                .with_cause(Arc::new(err))
        })
    }
}

#[cfg(feature = "async")]
#[cfg_attr(target_arch = "wasm32", async_trait::async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)]
impl AsyncIncludeLoader for LocalIncludeLoader {
    async fn async_resolve(&self, url: &str) -> Result<String, IncludeLoaderError> {
        let path = self.build_path(url)?;
        std::fs::read_to_string(path).map_err(|err| {
            IncludeLoaderError::new(url, ErrorKind::InvalidData)
                .with_message("unable to load the template file")
                .with_cause(Arc::new(err))
        })
    }
}

#[cfg(test)]
mod tests {
    use std::io::ErrorKind;
    use std::path::PathBuf;

    use super::LocalIncludeLoader;
    use crate::prelude::parser::loader::IncludeLoader;

    impl LocalIncludeLoader {
        fn current_dir() -> Self {
            Self::new(PathBuf::from(env!("CARGO_MANIFEST_DIR")))
        }
    }

    #[test]
    fn should_turn_into_path() {
        let loader = LocalIncludeLoader::current_dir();
        let path = loader
            .build_path("file:///resources/compare/success/mj-body.mjml")
            .unwrap();

        assert_eq!(
            path.as_os_str(),
            format!(
                "{}/resources/compare/success/mj-body.mjml",
                loader.root.to_string_lossy()
            )
            .as_str()
        );
    }

    #[test]
    fn should_handle_dots_with_existing_file() {
        let loader = LocalIncludeLoader::new(PathBuf::default().join("src"));

        let err = loader
            .build_path("file:///../resources/compare/success/mj-body.mjml")
            .unwrap_err();

        assert_eq!(err.reason, ErrorKind::NotFound);
    }

    #[test]
    fn should_handle_dots_with_missing_file() {
        let loader = LocalIncludeLoader::new(PathBuf::default().join("src"));

        let err = loader.build_path("file:///../partial.mjml").unwrap_err();

        assert_eq!(err.reason, ErrorKind::NotFound);
        assert_eq!(err.to_string(), "file:///../partial.mjml entity not found (the path should stay in the context of the loader)");
    }

    #[test]
    fn should_resolve_path() {
        let loader = LocalIncludeLoader::current_dir();
        let _payload = loader
            .resolve("file:///resources/compare/success/mj-body.mjml")
            .unwrap();
    }
}