Struct Buffer

Source

pub struct Buffer<W, C> { /* private fields */ }

Expand description

Wrapper arround a writer element.

Implementations§

Source §

pub fn doctype(self) -> Self

Appends the html doctype to the buffer

Source

pub fn try_doctype(self) -> Result<Self, Error>

Tries to append the html doctype to the buffer

Source §

impl<'a, W: Write> Buffer<W, Body<'a>>

Source

pub fn cond<F>(self, condition: bool, children: F) -> Buffer<W, Body<'a>>
where F: FnOnce(Buffer<W, Body<'_>>) -> Buffer<W, Body<'_>>,

Conditionally apply some children to an element

let is_error = true;
let html = another_html_builder::Buffer::default()
    .cond(is_error, |buf| {
        buf.node("p").content(|buf| buf.text("ERROR!"))
    })
    .into_inner();
assert_eq!(html, "<p>ERROR!</p>");

Source

pub fn try_cond<F>( self, condition: bool, children: F, ) -> Result<Buffer<W, Body<'a>>, Error>
where F: FnOnce(Buffer<W, Body<'_>>) -> Result<Buffer<W, Body<'_>>, Error>,

Source

pub fn optional<V, F>( self, value: Option<V>, children: F, ) -> Buffer<W, Body<'a>>
where F: FnOnce(Buffer<W, Body<'_>>, V) -> Buffer<W, Body<'_>>,

Conditionally apply some children to an element depending on an optional

let value: Option<u8> = Some(42);
let html = another_html_builder::Buffer::default()
    .optional(value, |buf, answer| {
        buf.node("p")
            .content(|buf| buf.text("Answer: ").raw(answer))
    })
    .into_inner();
assert_eq!(html, "<p>Answer: 42</p>");

Source

pub fn try_optional<V, F>( self, value: Option<V>, children: F, ) -> Result<Buffer<W, Body<'a>>, Error>
where F: FnOnce(Buffer<W, Body<'_>>, V) -> Result<Buffer<W, Body<'_>>, Error>,

Source

pub fn node(self, tag: &'a str) -> Buffer<W, Element<'a>>

Starts a new node in the buffer

After calling this function, the buffer will only allow to add attributes, close the current node or add content to the node.

let html = another_html_builder::Buffer::default()
    .node("p")
    .attr(("foo", "bar"))
    .close()
    .into_inner();
assert_eq!(html, "<p foo=\"bar\" />");

let html = another_html_builder::Buffer::default()
    .node("p")
    .content(|buf| buf.text("hello"))
    .into_inner();
assert_eq!(html, "<p>hello</p>");

Source

pub fn try_node(self, tag: &'a str) -> Result<Buffer<W, Element<'a>>, Error>

Source

pub fn raw<V: Display>(self, value: V) -> Self

Appends some raw content implementing Display

This will not escape the provided value.

Source

pub fn try_raw<V: Display>(self, value: V) -> Result<Self, Error>

Source

pub fn text(self, content: &str) -> Self

Appends some text and escape it.

let html = another_html_builder::Buffer::new()
    .node("p")
    .content(|b| b.text("asd\"weiofew!/<>"))
    .into_inner();
assert_eq!(html, "<p>asd&quot;weiofew!&#x2F;&lt;&gt;</p>");

Source

pub fn try_text(self, content: &str) -> Result<Self, Error>

Source §

impl<'a, W: Write> Buffer<W, Element<'a>>

Source

pub fn attr<T>(self, attr: T) -> Self
where Attribute<T>: Display,

Appends an attribute to the current node.

For more information about how to extend attributes, take a look at the Attribute trait.

let html = another_html_builder::Buffer::new()
    .node("p")
    .attr("single")
    .attr(("hello", "world"))
    .attr(("number", 42))
    .attr(Some(("foo", "bar")))
    .attr(None::<(&str, &str)>)
    .attr(Some("here"))
    .attr(None::<&str>)
    .close()
    .into_inner();
assert_eq!(
    html,
    "<p single hello=\"world\" number=\"42\" foo=\"bar\" here />"
);

Source

pub fn try_attr<T>(self, attr: T) -> Result<Self, Error>
where Attribute<T>: Display,

Source

pub fn cond_attr<T>(self, condition: bool, attr: T) -> Self
where Attribute<T>: Display,

Conditionally appends some attributes

let html = another_html_builder::Buffer::new()
    .node("p")
    .cond_attr(true, ("foo", "bar"))
    .cond_attr(false, ("foo", "baz"))
    .cond_attr(true, "here")
    .cond_attr(false, "not-here")
    .close()
    .into_inner();
assert_eq!(html, "<p foo=\"bar\" here />");

Source

pub fn try_cond_attr<T>(self, condition: bool, attr: T) -> Result<Self, Error>
where Attribute<T>: Display,

Source

pub fn close(self) -> Buffer<W, Body<'a>>

Closes the current node without providing any content

let html = another_html_builder::Buffer::new()
    .node("p")
    .close()
    .into_inner();
assert_eq!(html, "<p />");

Source

pub fn try_close(self) -> Result<Buffer<W, Body<'a>>, Error>

Source

pub fn content<F>(self, children: F) -> Buffer<W, Body<'a>>
where F: FnOnce(Buffer<W, Body<'_>>) -> Buffer<W, Body<'_>>,

Closes the current node and start writing it’s content

When returning the inner callback, the closing element will be written to the buffer

let html = another_html_builder::Buffer::new()
    .node("div")
    .content(|buf| buf.node("p").close())
    .into_inner();
assert_eq!(html, "<div><p /></div>");

Source