use crate::Hemplate;
use crate::context::HtmlValue;
use crate::error::RenderError;
use crate::escape::HtmlEscape;
use alloc::{boxed::Box, sync::Arc, vec::Vec};
use core::fmt;
struct RenderBuffer<'a>(&'a mut dyn fmt::Write);
impl fmt::Write for RenderBuffer<'_> {
fn write_str(&mut self, text: &str) -> fmt::Result {
self.0.write_str(text)
}
}
#[doc(hidden)]
pub struct Escaped<'a, T: ?Sized, L = ()>(pub &'a T, pub core::marker::PhantomData<L>);
impl<'a, T: ?Sized> Escaped<'a, T> {
#[doc(hidden)]
pub fn new(value: &'a T) -> Self {
Self(value, core::marker::PhantomData)
}
}
impl<T: Hemplate + ?Sized, L> Escaped<'_, T, L> {
#[doc(hidden)]
pub fn render_to(&self, buf: &mut dyn core::fmt::Write) -> Result<(), RenderError> {
self.0.render_into(buf)
}
}
#[doc(hidden)]
pub trait EscapedFallback {
fn render_to(&self, buf: &mut dyn core::fmt::Write) -> Result<(), RenderError>;
}
impl<T: fmt::Display + ?Sized, L> EscapedFallback for Escaped<'_, T, L> {
fn render_to(&self, buf: &mut dyn core::fmt::Write) -> Result<(), RenderError> {
use fmt::Write as _;
write!(RenderBuffer(buf), "{}", HtmlEscape(self.0))?;
Ok(())
}
}
#[doc(hidden)]
pub struct Present<'a, T: ?Sized>(pub &'a T);
impl<'a, T> Present<'a, Option<T>> {
#[doc(hidden)]
pub fn get(&self) -> Option<&'a T> {
self.0.as_ref()
}
}
#[doc(hidden)]
pub trait PresentFallback<'a, T: ?Sized> {
fn get(&self) -> Option<&'a T>;
}
impl<'a, T: ?Sized> PresentFallback<'a, T> for Present<'a, T> {
fn get(&self) -> Option<&'a T> {
Some(self.0)
}
}
#[doc(hidden)]
pub struct RawGuard<'a, T: ?Sized>(pub &'a T);
pub struct RawComponent;
impl<T: Hemplate + ?Sized> RawGuard<'_, T> {
#[doc(hidden)]
pub fn check(&self) -> RawComponent {
RawComponent
}
}
#[doc(hidden)]
pub trait RawGuardFallback {
fn check(&self);
}
impl<T: ?Sized> RawGuardFallback for RawGuard<'_, T> {
#[inline(always)]
fn check(&self) {}
}
#[diagnostic::on_unimplemented(
message = "a Hemplate component cannot be inserted as raw output `{{+= .. =+}}`",
label = "a component renders itself; raw output would insert it as unchecked markup",
note = "compose it with escaped interpolation: `{{+ child +}}`"
)]
pub trait RawOutputAllowed {}
#[diagnostic::do_not_recommend]
impl RawOutputAllowed for () {}
#[doc(hidden)]
pub fn render_raw<T: HtmlValue + ?Sized>(
value: &T,
buf: &mut dyn core::fmt::Write,
) -> Result<(), RenderError> {
use fmt::Write as _;
write!(RenderBuffer(buf), "{value}")?;
Ok(())
}
impl<T: Hemplate + ?Sized> Hemplate for &T {
fn render_into(&self, buf: &mut dyn core::fmt::Write) -> Result<(), RenderError> {
(*self).render_into(buf)
}
}
impl<T: Hemplate + ?Sized> Hemplate for Box<T> {
fn render_into(&self, buf: &mut dyn core::fmt::Write) -> Result<(), RenderError> {
(**self).render_into(buf)
}
}
impl<T: Hemplate + ?Sized> Hemplate for Arc<T> {
fn render_into(&self, buf: &mut dyn core::fmt::Write) -> Result<(), RenderError> {
(**self).render_into(buf)
}
}
impl<T: Hemplate> Hemplate for Option<T> {
fn render_into(&self, buf: &mut dyn core::fmt::Write) -> Result<(), RenderError> {
if let Some(inner) = self {
inner.render_into(buf)?;
}
Ok(())
}
}
impl<T: Hemplate> Hemplate for Vec<T> {
fn render_into(&self, buf: &mut dyn core::fmt::Write) -> Result<(), RenderError> {
for item in self {
item.render_into(buf)?;
}
Ok(())
}
}
impl<T: Hemplate> Hemplate for [T] {
fn render_into(&self, buf: &mut dyn core::fmt::Write) -> Result<(), RenderError> {
for item in self {
item.render_into(buf)?;
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use alloc::{string::String, vec};
struct TestComponent(String);
impl Hemplate for TestComponent {
fn render_into(&self, buf: &mut dyn core::fmt::Write) -> Result<(), RenderError> {
buf.write_str("<b>")?;
buf.write_str(&self.0)?;
buf.write_str("</b>")?;
Ok(())
}
}
struct FailingComponent;
impl Hemplate for FailingComponent {
fn render_into(&self, _buf: &mut dyn core::fmt::Write) -> Result<(), RenderError> {
Err(fmt::Error.into())
}
}
struct FailingDisplay;
impl fmt::Display for FailingDisplay {
fn fmt(&self, _formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
Err(fmt::Error)
}
}
fn render_to_string(value: &(impl Hemplate + ?Sized)) -> Result<String, RenderError> {
let mut buf = String::new();
value.render_into(&mut buf)?;
Ok(buf)
}
#[test]
fn render_into_accepts_custom_writer() -> Result<(), RenderError> {
struct Writer(String);
impl fmt::Write for Writer {
fn write_str(&mut self, value: &str) -> fmt::Result {
self.0.push_str(value);
Ok(())
}
}
let mut writer = Writer(String::new());
TestComponent("caller-owned".into()).render_into(&mut writer)?;
assert_eq!(writer.0, "<b>caller-owned</b>");
Ok(())
}
#[test]
fn escaped_hemplate_renders_directly() -> Result<(), RenderError> {
let comp = TestComponent("hello".into());
let mut buf = String::new();
Escaped::new(&comp).render_to(&mut buf)?;
assert_eq!(buf, "<b>hello</b>");
Ok(())
}
#[test]
fn escaped_display_html_escapes() -> Result<(), RenderError> {
let text = "<script>alert('xss')</script>";
let mut buf = String::new();
EscapedFallback::render_to(&Escaped::new(text), &mut buf)?;
assert_eq!(buf, "<script>alert('xss')</script>");
Ok(())
}
#[test]
fn raw_trusted_html_is_not_escaped() -> Result<(), RenderError> {
let mut buf = String::new();
render_raw(&crate::TrustedHtml::new_unchecked("<b>bold</b>"), &mut buf)?;
assert_eq!(buf, "<b>bold</b>");
Ok(())
}
#[test]
fn interpolation_fallbacks_propagate_display_failure() {
let mut escaped = String::new();
assert!(EscapedFallback::render_to(&Escaped::new(&FailingDisplay), &mut escaped).is_err());
}
#[test]
fn option_some_renders() -> Result<(), RenderError> {
let comp = Some(TestComponent("yes".into()));
assert_eq!(render_to_string(&comp)?, "<b>yes</b>");
Ok(())
}
#[test]
fn option_none_renders_empty() -> Result<(), RenderError> {
let comp: Option<TestComponent> = None;
assert_eq!(render_to_string(&comp)?, "");
Ok(())
}
#[test]
fn vec_renders_all() -> Result<(), RenderError> {
let comps = vec![TestComponent("a".into()), TestComponent("b".into())];
assert_eq!(render_to_string(&comps)?, "<b>a</b><b>b</b>");
Ok(())
}
#[test]
fn vec_empty_renders_empty() -> Result<(), RenderError> {
let comps: Vec<TestComponent> = vec![];
assert_eq!(render_to_string(&comps)?, "");
Ok(())
}
#[test]
fn box_renders() -> Result<(), RenderError> {
let comp: Box<TestComponent> = Box::new(TestComponent("boxed".into()));
assert_eq!(render_to_string(&comp)?, "<b>boxed</b>");
Ok(())
}
#[test]
fn arc_renders() -> Result<(), RenderError> {
let comp: Arc<TestComponent> = Arc::new(TestComponent("shared".into()));
assert_eq!(render_to_string(&comp)?, "<b>shared</b>");
Ok(())
}
#[test]
fn ref_renders() -> Result<(), RenderError> {
let comp = TestComponent("ref".into());
let r: &TestComponent = ∁
assert_eq!(render_to_string(&r)?, "<b>ref</b>");
Ok(())
}
#[test]
fn slice_renders() -> Result<(), RenderError> {
let comps = vec![TestComponent("x".into()), TestComponent("y".into())];
assert_eq!(render_to_string(comps.as_slice())?, "<b>x</b><b>y</b>");
Ok(())
}
#[test]
fn box_dyn_hemplate_renders() -> Result<(), RenderError> {
let comp: Box<dyn Hemplate> = Box::new(TestComponent("dyn".into()));
assert_eq!(render_to_string(comp.as_ref())?, "<b>dyn</b>");
Ok(())
}
#[test]
fn references_box_arc_option_vec_and_slices_render() -> Result<(), RenderError> {
let value = TestComponent("one".into());
assert_eq!(render_to_string(&&value)?, "<b>one</b>");
assert_eq!(
render_to_string(&Box::new(TestComponent("two".into())))?,
"<b>two</b>"
);
assert_eq!(
render_to_string(&Arc::new(TestComponent("three".into())))?,
"<b>three</b>"
);
assert_eq!(
render_to_string(&Some(TestComponent("four".into())))?,
"<b>four</b>"
);
assert_eq!(
render_to_string(&vec![TestComponent("five".into())])?,
"<b>five</b>"
);
let slice = [TestComponent("six".into())];
assert_eq!(render_to_string(&slice[..])?, "<b>six</b>");
let dynamic: Box<dyn Hemplate> = Box::new(TestComponent("seven".into()));
assert_eq!(render_to_string(dynamic.as_ref())?, "<b>seven</b>");
Ok(())
}
#[test]
fn blanket_implementations_propagate_child_failure() {
let by_ref = &FailingComponent;
assert!(render_to_string(&by_ref).is_err());
assert!(render_to_string(&Box::new(FailingComponent)).is_err());
assert!(render_to_string(&Arc::new(FailingComponent)).is_err());
assert!(render_to_string(&Some(FailingComponent)).is_err());
assert!(render_to_string(&vec![FailingComponent]).is_err());
assert!(render_to_string([FailingComponent].as_slice()).is_err());
}
}