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

use std::fmt;

use crate::{RenderEscaped, RenderRaw};

/// Trait for conditionally rendering an HTML attribute with a raw (unescaped) value.
///
/// Used by the `attr?: #(expr)` syntax in [`html!`](crate::html). The attribute is only rendered when the value is
/// "present" (e.g. `Some(_)` or `true`).
///
/// # Built-in implementations
///
/// | Type                   | Behavior                                                            |
/// |------------------------|---------------------------------------------------------------------|
/// | `bool`                 | Renders the attribute name (no value) if `true`; nothing if `false` |
/// | `Option<T: RenderRaw>` | Renders `name="value"` if `Some`; nothing if `None`                 |
pub trait RenderMaybeAttributeRaw {
    /// Conditionally writes ` name` or ` name="value"` into `f`.
    fn render_maybe_attribute_raw(&self, name: &str, f: &mut (dyn fmt::Write + '_)) -> fmt::Result;
}

impl<T> RenderMaybeAttributeRaw for &T
where
    T: RenderMaybeAttributeRaw + ?Sized,
{
    fn render_maybe_attribute_raw(&self, name: &str, f: &mut (dyn fmt::Write + '_)) -> fmt::Result {
        (**self).render_maybe_attribute_raw(name, f)
    }
}

impl RenderMaybeAttributeRaw for bool {
    fn render_maybe_attribute_raw(&self, name: &str, f: &mut (dyn fmt::Write + '_)) -> fmt::Result {
        if *self {
            f.write_str(" ")?;
            f.write_str(name)?;

            Ok(())
        } else {
            Ok(())
        }
    }
}

impl<T> RenderMaybeAttributeRaw for Option<T>
where
    T: RenderRaw,
{
    fn render_maybe_attribute_raw(&self, name: &str, f: &mut (dyn fmt::Write + '_)) -> fmt::Result {
        match self {
            Some(value) => {
                f.write_str(" ")?;
                f.write_str(name)?;
                f.write_str("=\"")?;
                value.render_raw(f)?;
                f.write_str("\"")?;

                Ok(())
            }
            None => Ok(()),
        }
    }
}

/// Trait for conditionally rendering an HTML attribute with an escaped value.
///
/// Used by the `attr?: expr` syntax in [`html!`](crate::html). The attribute is only rendered when the value is
/// "present" (e.g. `Some(_)` or `true`).
///
/// # Built-in implementations
///
/// | Type                       | Behavior                                                            |
/// |----------------------------|---------------------------------------------------------------------|
/// | `bool`                     | Renders the attribute name (no value) if `true`; nothing if `false` |
/// | `Option<T: RenderEscaped>` | Renders `name="value"` (escaped) if `Some`; nothing if `None`       |
pub trait RenderMaybeAttributeEscaped {
    /// Conditionally writes ` name` or ` name="value"` (escaped) into `f`.
    fn render_maybe_attribute_escaped(
        &self,
        name: &str,
        f: &mut (dyn fmt::Write + '_),
    ) -> fmt::Result;
}

impl<T> RenderMaybeAttributeEscaped for &T
where
    T: RenderMaybeAttributeEscaped + ?Sized,
{
    fn render_maybe_attribute_escaped(
        &self,
        name: &str,
        f: &mut (dyn fmt::Write + '_),
    ) -> fmt::Result {
        (**self).render_maybe_attribute_escaped(name, f)
    }
}

impl RenderMaybeAttributeEscaped for bool {
    fn render_maybe_attribute_escaped(
        &self,
        name: &str,
        f: &mut (dyn fmt::Write + '_),
    ) -> fmt::Result {
        if *self {
            f.write_str(" ")?;
            f.write_str(name)?;

            Ok(())
        } else {
            Ok(())
        }
    }
}

impl<T> RenderMaybeAttributeEscaped for Option<T>
where
    T: RenderEscaped,
{
    fn render_maybe_attribute_escaped(
        &self,
        name: &str,
        f: &mut (dyn fmt::Write + '_),
    ) -> fmt::Result {
        match self {
            Some(value) => {
                f.write_str(" ")?;
                f.write_str(name)?;
                f.write_str("=\"")?;
                value.render_escaped(f)?;
                f.write_str("\"")?;

                Ok(())
            }
            None => Ok(()),
        }
    }
}