Make html escaping available to derive

Author: Kijewski

rinja/src/filters/escape.rs

@@ -1,6 +1,5 @@
 use std::convert::Infallible;
 use std::fmt::{self, Display, Formatter, Write};
-use std::num::NonZeroU8;
 use std::{borrow, str};
 
 /// Marks a string (or other `Display` type) as safe
@@ -83,69 +82,14 @@ pub fn e(text: impl fmt::Display, escaper: impl Escaper) -> Result<Safe<impl Dis
 pub struct Html;
 
 impl Escaper for Html {
-    fn write_escaped_str<W: Write>(&self, mut fmt: W, string: &str) -> fmt::Result {
-        let mut escaped_buf = *b"&#__;";
-        let mut last = 0;
-
-        for (index, byte) in string.bytes().enumerate() {
-            const MIN_CHAR: u8 = b'"';
-            const MAX_CHAR: u8 = b'>';
-
-            struct Table {
-                _align: [usize; 0],
-                lookup: [Option<[NonZeroU8; 2]>; (MAX_CHAR - MIN_CHAR + 1) as usize],
-            }
-
-            const TABLE: Table = {
-                const fn n(c: u8) -> Option<[NonZeroU8; 2]> {
-                    let n0 = match NonZeroU8::new(c / 10 + b'0') {
-                        Some(n) => n,
-                        None => panic!(),
-                    };
-                    let n1 = match NonZeroU8::new(c % 10 + b'0') {
-                        Some(n) => n,
-                        None => panic!(),
-                    };
-                    Some([n0, n1])
-                }
-
-                let mut table = Table {
-                    _align: [],
-                    lookup: [None; (MAX_CHAR - MIN_CHAR + 1) as usize],
-                };
-
-                table.lookup[(b'"' - MIN_CHAR) as usize] = n(b'"');
-                table.lookup[(b'&' - MIN_CHAR) as usize] = n(b'&');
-                table.lookup[(b'\'' - MIN_CHAR) as usize] = n(b'\'');
-                table.lookup[(b'<' - MIN_CHAR) as usize] = n(b'<');
-                table.lookup[(b'>' - MIN_CHAR) as usize] = n(b'>');
-                table
-            };
-
-            let escaped = match byte {
-                MIN_CHAR..=MAX_CHAR => TABLE.lookup[(byte - MIN_CHAR) as usize],
-                _ => None,
-            };
-            if let Some(escaped) = escaped {
-                escaped_buf[2] = escaped[0].get();
-                escaped_buf[3] = escaped[1].get();
-                fmt.write_str(&string[last..index])?;
-                fmt.write_str(unsafe { std::str::from_utf8_unchecked(escaped_buf.as_slice()) })?;
-                last = index + 1;
-            }
-        }
-        fmt.write_str(&string[last..])
+    #[inline]
+    fn write_escaped_str<W: Write>(&self, fmt: W, string: &str) -> fmt::Result {
+        crate::html::write_escaped_str(fmt, string)
     }
 
-    fn write_escaped_char<W: Write>(&self, mut fmt: W, c: char) -> fmt::Result {
-        fmt.write_str(match (c.is_ascii(), c as u8) {
-            (true, b'"') => "&#34;",
-            (true, b'&') => "&#38;",
-            (true, b'\'') => "&#39;",
-            (true, b'<') => "&#60;",
-            (true, b'>') => "&#62;",
-            _ => return fmt.write_char(c),
-        })
+    #[inline]
+    fn write_escaped_char<W: Write>(&self, fmt: W, c: char) -> fmt::Result {
+        crate::html::write_escaped_char(fmt, c)
     }
 }
 

rinja/src/html.rs

@@ -0,0 +1,71 @@
+use std::fmt;
+use std::num::NonZeroU8;
+
+#[allow(unused)]
+pub(crate) fn write_escaped_str(mut fmt: impl fmt::Write, string: &str) -> fmt::Result {
+    let mut escaped_buf = *b"&#__;";
+    let mut last = 0;
+
+    for (index, byte) in string.bytes().enumerate() {
+        let escaped = match byte {
+            MIN_CHAR..=MAX_CHAR => TABLE.lookup[(byte - MIN_CHAR) as usize],
+            _ => None,
+        };
+        if let Some(escaped) = escaped {
+            escaped_buf[2] = escaped[0].get();
+            escaped_buf[3] = escaped[1].get();
+            fmt.write_str(&string[last..index])?;
+            fmt.write_str(unsafe { std::str::from_utf8_unchecked(escaped_buf.as_slice()) })?;
+            last = index + 1;
+        }
+    }
+    fmt.write_str(&string[last..])
+}
+
+#[allow(unused)]
+pub(crate) fn write_escaped_char(mut fmt: impl fmt::Write, c: char) -> fmt::Result {
+    fmt.write_str(match (c.is_ascii(), c as u8) {
+        (true, b'"') => """,
+        (true, b'&') => "&",
+        (true, b'\'') => "'",
+        (true, b'<') => "&#60;",
+        (true, b'>') => "&#62;",
+        _ => return fmt.write_char(c),
+    })
+}
+
+const MIN_CHAR: u8 = b'"';
+const MAX_CHAR: u8 = b'>';
+
+struct Table {
+    _align: [usize; 0],
+    lookup: [Option<[NonZeroU8; 2]>; (MAX_CHAR - MIN_CHAR + 1) as usize],
+}
+
+const TABLE: Table = {
+    const fn n(c: u8) -> Option<[NonZeroU8; 2]> {
+        assert!(MIN_CHAR <= c && c <= MAX_CHAR);
+
+        let n0 = match NonZeroU8::new(c / 10 + b'0') {
+            Some(n) => n,
+            None => panic!(),
+        };
+        let n1 = match NonZeroU8::new(c % 10 + b'0') {
+            Some(n) => n,
+            None => panic!(),
+        };
+        Some([n0, n1])
+    }
+
+    let mut table = Table {
+        _align: [],
+        lookup: [None; (MAX_CHAR - MIN_CHAR + 1) as usize],
+    };
+
+    table.lookup[(b'"' - MIN_CHAR) as usize] = n(b'"');
+    table.lookup[(b'&' - MIN_CHAR) as usize] = n(b'&');
+    table.lookup[(b'\'' - MIN_CHAR) as usize] = n(b'\'');
+    table.lookup[(b'<' - MIN_CHAR) as usize] = n(b'<');
+    table.lookup[(b'>' - MIN_CHAR) as usize] = n(b'>');
+    table
+};

rinja/src/lib.rs

@@ -57,6 +57,7 @@
 mod error;
 pub mod filters;
 pub mod helpers;
+mod html;
 
 use std::{fmt, io};
 

rinja_derive/src/html.rs

@@ -0,0 +1 @@
+../../rinja/src/html.rs

rinja_derive/src/lib.rs

@@ -4,6 +4,7 @@
 mod config;
 mod generator;
 mod heritage;
+mod html;
 mod input;
 #[cfg(test)]
 mod tests;