hers 0.1.1

HTML Embedded Rust - Runtime types and utilities
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

use std::fmt;

pub use hers_macro::hers;

/// A type-safe wrapper for HTML content
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HtmlString(String);

impl HtmlString {
    /// Create a new HtmlString from a raw string
    /// Note: This assumes the string is already properly escaped
    pub fn new(s: String) -> Self {
        Self(s)
    }

    /// Get the inner HTML string
    pub fn as_str(&self) -> &str {
        &self.0
    }

    /// Convert to owned String
    pub fn into_string(self) -> String {
        self.0
    }
}

impl fmt::Display for HtmlString {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl From<String> for HtmlString {
    fn from(s: String) -> Self {
        Self::new(s)
    }
}

impl From<&str> for HtmlString {
    fn from(s: &str) -> Self {
        Self::new(s.to_string())
    }
}

/// Trait for types that can be converted to HTML
pub trait ToHtml {
    fn to_html(&self) -> HtmlString;
}

impl ToHtml for String {
    fn to_html(&self) -> HtmlString {
        HtmlString::new(escape_html(self))
    }
}

impl ToHtml for &str {
    fn to_html(&self) -> HtmlString {
        HtmlString::new(escape_html(self))
    }
}

impl ToHtml for i32 {
    fn to_html(&self) -> HtmlString {
        HtmlString::new(self.to_string())
    }
}

impl ToHtml for f64 {
    fn to_html(&self) -> HtmlString {
        HtmlString::new(self.to_string())
    }
}

impl ToHtml for bool {
    fn to_html(&self) -> HtmlString {
        HtmlString::new(self.to_string())
    }
}

impl ToHtml for usize {
    fn to_html(&self) -> HtmlString {
        HtmlString::new(self.to_string())
    }
}

/// Escape HTML special characters to prevent XSS
pub fn escape_html(input: &str) -> String {
    input
        .replace('&', "&amp;")
        .replace('<', "&lt;")
        .replace('>', "&gt;")
        .replace('"', "&quot;")
        .replace('\'', "&#x27;")
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_html_string_creation() {
        let html = HtmlString::new("Hello".to_string());
        assert_eq!(html.as_str(), "Hello");
        assert_eq!(html.to_string(), "Hello");
    }

    #[test]
    fn test_html_string_from_str() {
        let html: HtmlString = "Hello".into();
        assert_eq!(html.as_str(), "Hello");
    }

    #[test]
    fn test_escape_html() {
        assert_eq!(escape_html("Hello"), "Hello");
        assert_eq!(escape_html("<script>"), "&lt;script&gt;");
        assert_eq!(escape_html("&"), "&amp;");
        assert_eq!(escape_html("\""), "&quot;");
        assert_eq!(escape_html("'"), "&#x27;");
        assert_eq!(
            escape_html("<script>alert('xss')</script>"),
            "&lt;script&gt;alert(&#x27;xss&#x27;)&lt;/script&gt;"
        );
    }

    #[test]
    fn test_to_html_string() {
        let s = "Hello <world>".to_string();
        let html = s.to_html();
        assert_eq!(html.as_str(), "Hello &lt;world&gt;");
    }

    #[test]
    fn test_to_html_str() {
        let html = "Hello <world>".to_html();
        assert_eq!(html.as_str(), "Hello &lt;world&gt;");
    }

    #[test]
    fn test_to_html_numbers() {
        assert_eq!(42.to_html().as_str(), "42");
        assert_eq!(7.99.to_html().as_str(), "7.99");
        assert_eq!(true.to_html().as_str(), "true");
        assert_eq!(false.to_html().as_str(), "false");
    }
}