gotmpl 0.6.1

A Rust reimplementation of Go's text/template library
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

//! Trusted-content wrappers — analogs of Go's `template.HTML`, `template.JS`,
//! etc. A value wrapped in one of these becomes a [`Value::Safe`] and bypasses
//! escaping in its matching context (see [`crate::SafeKind`]).
//!
//! Construct from a string and drop into template data:
//!
//! ```
//! use gotmpl::html::HTML;
//! use gotmpl::{SafeKind, ToValue, Value};
//!
//! let v = HTML::from("<b>hi</b>").to_value();
//! assert!(matches!(v, Value::Safe { kind: SafeKind::Html, .. }));
//! ```

use alloc::string::String;
use alloc::sync::Arc;

use crate::value::{SafeKind, ToValue, Value};

macro_rules! safe_content {
    ($($(#[$m:meta])* $name:ident => $kind:ident),+ $(,)?) => {$(
        $(#[$m])*
        #[derive(Debug, Clone, PartialEq, Eq)]
        pub struct $name(pub Arc<str>);

        impl From<&str> for $name {
            fn from(s: &str) -> Self { $name(Arc::from(s)) }
        }
        impl From<String> for $name {
            fn from(s: String) -> Self { $name(Arc::from(s)) }
        }
        impl From<Arc<str>> for $name {
            fn from(s: Arc<str>) -> Self { $name(s) }
        }
        impl ToValue for $name {
            fn to_value(&self) -> Value {
                Value::Safe { kind: SafeKind::$kind, s: Arc::clone(&self.0) }
            }
        }
        impl From<$name> for Value {
            fn from(v: $name) -> Value {
                Value::Safe { kind: SafeKind::$kind, s: v.0 }
            }
        }
    )+};
}

safe_content! {
    /// Content that is known-safe HTML markup (Go's `template.HTML`).
    HTML => Html,
    /// A known-safe HTML attribute name/value fragment (Go's `template.HTMLAttr`).
    HTMLAttr => HtmlAttr,
    /// Known-safe JavaScript source (Go's `template.JS`).
    JS => Js,
    /// A known-safe JavaScript string-literal body (Go's `template.JSStr`).
    JSStr => JsStr,
    /// Known-safe CSS source (Go's `template.CSS`).
    CSS => Css,
    /// A known-safe URL (Go's `template.URL`).
    URL => Url,
    /// A known-safe `<img srcset>` value (Go's `template.Srcset`).
    Srcset => Srcset,
}