plait 0.8.1

A modern HTML templating library for Rust that embraces composition.
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

use std::{borrow::Cow, fmt};

use crate::utils::escape_html_to;

/// Trait for types that can be rendered as HTML-escaped text.
///
/// When a value is embedded in an [`html!`](crate::html) template with `(expr)`, it is rendered through this trait,
/// which ensures HTML-special characters (`&`, `<`, `>`, `"`, `'`) are escaped.
///
/// # Built-in implementations
///
/// | Type                                                       | Behavior                                   |
/// |------------------------------------------------------------|--------------------------------------------|
/// | `&str`, `String`                                           | HTML-escaped output                        |
/// | `bool`                                                     | `"true"` or `"false"`                      |
/// | `Option<T: RenderEscaped>`                                 | Renders inner value, or nothing for `None` |
/// | `Cow<'_, T: RenderEscaped>`                                | Delegates to inner value                   |
/// | Integer types (`u8`–`u128`, `i8`–`i128`, `usize`, `isize`) | Formatted via [`itoa`]                     |
/// | Float types (`f32`, `f64`)                                 | Formatted via [`ryu`]                      |
/// | [`Html`](crate::Html)                                      | Written as-is (already escaped)            |
/// | [`HtmlFragment`](crate::HtmlFragment)                      | Renders the fragment                       |
/// | `&T` where `T: RenderEscaped`                              | Delegates to inner value                   |
pub trait RenderEscaped {
    /// Writes the HTML-escaped representation of `self` into `f`.
    fn render_escaped(&self, f: &mut (dyn fmt::Write + '_)) -> fmt::Result;
}

impl<T> RenderEscaped for &T
where
    T: RenderEscaped + ?Sized,
{
    #[inline]
    fn render_escaped(&self, f: &mut (dyn fmt::Write + '_)) -> fmt::Result {
        (**self).render_escaped(f)
    }
}

impl RenderEscaped for str {
    #[inline]
    fn render_escaped(&self, f: &mut (dyn fmt::Write + '_)) -> fmt::Result {
        escape_html_to(f, self)
    }
}

impl RenderEscaped for String {
    #[inline]
    fn render_escaped(&self, f: &mut (dyn fmt::Write + '_)) -> fmt::Result {
        escape_html_to(f, self)
    }
}

impl RenderEscaped for bool {
    #[inline]
    fn render_escaped(&self, f: &mut (dyn fmt::Write + '_)) -> fmt::Result {
        f.write_str(if *self { "true" } else { "false" })
    }
}

impl<T> RenderEscaped for Option<T>
where
    T: RenderEscaped,
{
    #[inline]
    fn render_escaped(&self, f: &mut (dyn fmt::Write + '_)) -> fmt::Result {
        match self {
            Some(value) => value.render_escaped(f),
            None => Ok(()),
        }
    }
}

impl<'a, T> RenderEscaped for Cow<'a, T>
where
    T: RenderEscaped + ToOwned + ?Sized + 'a,
{
    #[inline]
    fn render_escaped(&self, f: &mut (dyn fmt::Write + '_)) -> fmt::Result {
        self.as_ref().render_escaped(f)
    }
}

macro_rules! impl_render_escaped_itoa {
    ($ty:ty) => {
        #[cfg(feature = "itoa")]
        impl RenderEscaped for $ty {
            #[inline]
            fn render_escaped(&self, f: &mut (dyn fmt::Write + '_)) -> fmt::Result {
                let mut buffer = itoa::Buffer::new();
                f.write_str(buffer.format(*self))
            }
        }

        #[cfg(not(feature = "itoa"))]
        impl RenderEscaped for $ty {
            #[inline]
            fn render_escaped(&self, f: &mut (dyn fmt::Write + '_)) -> fmt::Result {
                write!(f, "{}", *self)
            }
        }
    };
}

impl_render_escaped_itoa!(usize);
impl_render_escaped_itoa!(isize);
impl_render_escaped_itoa!(u8);
impl_render_escaped_itoa!(u16);
impl_render_escaped_itoa!(u32);
impl_render_escaped_itoa!(u64);
impl_render_escaped_itoa!(u128);
impl_render_escaped_itoa!(i8);
impl_render_escaped_itoa!(i16);
impl_render_escaped_itoa!(i32);
impl_render_escaped_itoa!(i64);
impl_render_escaped_itoa!(i128);

macro_rules! impl_render_escaped_ryu {
    ($ty:ty) => {
        #[cfg(feature = "ryu")]
        impl RenderEscaped for $ty {
            #[inline]
            fn render_escaped(&self, f: &mut (dyn fmt::Write + '_)) -> fmt::Result {
                let mut buffer = ryu::Buffer::new();
                f.write_str(buffer.format(*self))
            }
        }

        #[cfg(not(feature = "ryu"))]
        impl RenderEscaped for $ty {
            #[inline]
            fn render_escaped(&self, f: &mut (dyn fmt::Write + '_)) -> fmt::Result {
                write!(f, "{}", *self)
            }
        }
    };
}

impl_render_escaped_ryu!(f32);
impl_render_escaped_ryu!(f64);