use crate::escape;
#[derive(Debug, Clone, Default, Eq, PartialEq, Hash)]
pub struct Markup(pub(crate) String);
impl Markup {
#[must_use]
pub fn new() -> Self {
Self(String::new())
}
#[must_use]
pub fn with_capacity(n: usize) -> Self {
Self(String::with_capacity(n))
}
pub fn into_string(self) -> String {
self.0
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
pub fn push_str(&mut self, s: &str) {
self.0.push_str(s);
}
pub fn push_text(&mut self, s: &str) {
escape::escape_text(s, &mut self.0);
}
pub fn push_attr(&mut self, name: &str, value: &str) {
self.0.push(' ');
self.0.push_str(name);
self.0.push_str("=\"");
escape::escape_attr(value, &mut self.0);
self.0.push('"');
}
pub fn push_self_closing(&mut self, name: &str) {
self.0.push('<');
self.0.push_str(name);
self.0.push_str("/>");
}
pub fn render_to_fmt<W: std::fmt::Write>(&self, w: &mut W) -> std::fmt::Result {
w.write_str(&self.0)
}
}
impl std::fmt::Display for Markup {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0)
}
}
impl std::fmt::Write for Markup {
fn write_str(&mut self, s: &str) -> std::fmt::Result {
self.0.push_str(s);
Ok(())
}
}
impl std::ops::Deref for Markup {
type Target = str;
fn deref(&self) -> &str {
&self.0
}
}
impl From<String> for Markup {
fn from(s: String) -> Self {
Self(s)
}
}
impl From<&str> for Markup {
fn from(s: &str) -> Self {
Self(s.to_owned())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn new_and_into_string() {
let m = Markup::new();
assert_eq!(m.into_string(), "");
}
#[test]
fn push_str_is_raw() {
let mut m = Markup::new();
m.push_str("<raw>");
assert_eq!(m.as_str(), "<raw>");
}
#[test]
fn push_text_escapes() {
let mut m = Markup::new();
m.push_text("a & b < c > d");
assert_eq!(m.as_str(), "a & b < c > d");
}
#[test]
fn push_attr_escapes_value() {
let mut m = Markup::new();
m.push_attr("href", "a & b");
assert_eq!(m.as_str(), " href=\"a & b\"");
}
#[test]
fn push_self_closing_works() {
let mut m = Markup::new();
m.push_self_closing("br");
assert_eq!(m.as_str(), "<br/>");
}
#[test]
fn display_yields_underlying_string() {
let m = Markup::from("<root/>".to_string());
assert_eq!(format!("{}", m), "<root/>");
}
#[test]
fn deref_to_str() {
let m = Markup::from("hello".to_string());
assert_eq!(&*m, "hello");
assert!(m.starts_with("he"));
}
#[test]
fn render_to_fmt_works() {
let m = Markup::from("<a/>".to_string());
let mut out = String::new();
m.render_to_fmt(&mut out).unwrap();
assert_eq!(out, "<a/>");
}
}