diff options
Diffstat (limited to 'vendor/askama_escape/src/lib.rs')
| -rw-r--r-- | vendor/askama_escape/src/lib.rs | 186 |
1 files changed, 186 insertions, 0 deletions
diff --git a/vendor/askama_escape/src/lib.rs b/vendor/askama_escape/src/lib.rs new file mode 100644 index 000000000..4643390ca --- /dev/null +++ b/vendor/askama_escape/src/lib.rs @@ -0,0 +1,186 @@ +#![no_std] +#![deny(elided_lifetimes_in_paths)] + +#[cfg(test)] +extern crate std; + +use core::fmt::{self, Display, Formatter, Write}; +use core::str; + +pub struct MarkupDisplay<E, T> +where + E: Escaper, + T: Display, +{ + value: DisplayValue<T>, + escaper: E, +} + +impl<E, T> MarkupDisplay<E, T> +where + E: Escaper, + T: Display, +{ + pub fn new_unsafe(value: T, escaper: E) -> Self { + Self { + value: DisplayValue::Unsafe(value), + escaper, + } + } + + pub fn new_safe(value: T, escaper: E) -> Self { + Self { + value: DisplayValue::Safe(value), + escaper, + } + } + + pub fn mark_safe(mut self) -> MarkupDisplay<E, T> { + self.value = match self.value { + DisplayValue::Unsafe(t) => DisplayValue::Safe(t), + _ => self.value, + }; + self + } +} + +impl<E, T> Display for MarkupDisplay<E, T> +where + E: Escaper, + T: Display, +{ + fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result { + match self.value { + DisplayValue::Unsafe(ref t) => write!( + EscapeWriter { + fmt, + escaper: &self.escaper + }, + "{}", + t + ), + DisplayValue::Safe(ref t) => t.fmt(fmt), + } + } +} + +pub struct EscapeWriter<'a, E, W> { + fmt: W, + escaper: &'a E, +} + +impl<'a, E, W> Write for EscapeWriter<'a, E, W> +where + W: Write, + E: Escaper, +{ + fn write_str(&mut self, s: &str) -> fmt::Result { + self.escaper.write_escaped(&mut self.fmt, s) + } +} + +pub fn escape<E>(string: &str, escaper: E) -> Escaped<'_, E> +where + E: Escaper, +{ + Escaped { string, escaper } +} + +pub struct Escaped<'a, E> +where + E: Escaper, +{ + string: &'a str, + escaper: E, +} + +impl<'a, E> Display for Escaped<'a, E> +where + E: Escaper, +{ + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + self.escaper.write_escaped(fmt, self.string) + } +} + +pub struct Html; + +macro_rules! escaping_body { + ($start:ident, $i:ident, $fmt:ident, $bytes:ident, $quote:expr) => {{ + if $start < $i { + $fmt.write_str(unsafe { str::from_utf8_unchecked(&$bytes[$start..$i]) })?; + } + $fmt.write_str($quote)?; + $start = $i + 1; + }}; +} + +impl Escaper for Html { + fn write_escaped<W>(&self, mut fmt: W, string: &str) -> fmt::Result + where + W: Write, + { + let bytes = string.as_bytes(); + let mut start = 0; + for (i, b) in bytes.iter().enumerate() { + if b.wrapping_sub(b'"') <= FLAG { + match *b { + b'<' => escaping_body!(start, i, fmt, bytes, "<"), + b'>' => escaping_body!(start, i, fmt, bytes, ">"), + b'&' => escaping_body!(start, i, fmt, bytes, "&"), + b'"' => escaping_body!(start, i, fmt, bytes, """), + b'\'' => escaping_body!(start, i, fmt, bytes, "'"), + _ => (), + } + } + } + if start < bytes.len() { + fmt.write_str(unsafe { str::from_utf8_unchecked(&bytes[start..]) }) + } else { + Ok(()) + } + } +} + +pub struct Text; + +impl Escaper for Text { + fn write_escaped<W>(&self, mut fmt: W, string: &str) -> fmt::Result + where + W: Write, + { + fmt.write_str(string) + } +} + +#[derive(Debug, PartialEq)] +enum DisplayValue<T> +where + T: Display, +{ + Safe(T), + Unsafe(T), +} + +pub trait Escaper { + fn write_escaped<W>(&self, fmt: W, string: &str) -> fmt::Result + where + W: Write; +} + +const FLAG: u8 = b'>' - b'"'; + +#[cfg(test)] +mod tests { + use super::*; + use std::string::ToString; + + #[test] + fn test_escape() { + assert_eq!(escape("", Html).to_string(), ""); + assert_eq!(escape("<&>", Html).to_string(), "<&>"); + assert_eq!(escape("bla&", Html).to_string(), "bla&"); + assert_eq!(escape("<foo", Html).to_string(), "<foo"); + assert_eq!(escape("bla&h", Html).to_string(), "bla&h"); + } +} |