Struct HtmlWriter 

pub struct HtmlWriter { /* private fields */ }

HTML output writer with pre-allocated, reusable buffer.

Example

use ferromark::HtmlWriter;

let mut writer = HtmlWriter::with_capacity_for(1000);
writer.write_str("<p>");
writer.write_escaped_text(b"Hello <World>");
writer.write_str("</p>");

let html = writer.into_string();
assert_eq!(html, "<p>Hello &lt;World&gt;</p>");

Implementations

impl HtmlWriter

pub fn new() -> Self

Create a new writer with default capacity.

pub fn with_capacity_for(input_len: usize) -> Self

Create with pre-allocated capacity based on expected input size.

Typical HTML is ~1.25x input size; we reserve extra for safety.

pub fn with_capacity(capacity: usize) -> Self

Create with explicit capacity.

pub fn write_bytes(&mut self, bytes: &[u8])

Write raw bytes without escaping.

pub fn write_str(&mut self, s: &'static str)

Write a static string (compile-time known).

pub fn write_string(&mut self, s: &str)

Write a dynamic string without escaping.

pub fn write_byte(&mut self, b: u8)

Write a single byte.

pub fn write_escaped_text(&mut self, text: &[u8])

Write text with HTML escaping (for text content).

pub fn write_text_with_entities(&mut self, text: &[u8])

Write text with entity decoding and HTML escaping (for inline text content). First decodes HTML entities, then escapes for output.

pub fn write_escaped_range(&mut self, input: &[u8], range: Range)

Write text with HTML escaping from a range.

pub fn write_escaped_attr(&mut self, attr: &[u8])

Write attribute value with full escaping (including quotes).

pub fn write_escaped_link_attr(&mut self, attr: &[u8])

Write URL/title with backslash escape processing and HTML attribute escaping. Backslash-escaped punctuation characters have the backslash removed.

pub fn write_link_title(&mut self, title: &[u8])

Write link title with entity decoding, backslash escape processing, and HTML escaping.

pub fn write_url_encoded(&mut self, url: &[u8])

Write autolink URL with percent-encoding and HTML escaping. Used for autolink hrefs per CommonMark spec.

pub fn write_link_url(&mut self, url: &[u8])

Write link destination with backslash escape processing and URL encoding. Used for link destinations in [text](url) syntax.

pub fn newline(&mut self)

Write a newline.

pub fn len(&self) -> usize

Current output length.

pub fn is_empty(&self) -> bool

Check if output is empty.

pub fn clear(&mut self)

Clear output for reuse (keeps capacity).

pub fn as_bytes(&self) -> &[u8]

Get output as byte slice.

pub fn as_str(&self) -> &str

Get output as str (assumes valid UTF-8).

pub fn into_vec(self) -> Vec<u8>

Take ownership of output buffer.

pub fn into_string(self) -> String

Take ownership as String.

pub fn buffer_mut(&mut self) -> &mut Vec<u8>

Get mutable reference to internal buffer.

Use with caution - allows bypassing escaping.

pub fn open_tag(&mut self, tag: &'static str)

Write opening tag: <tagname>

pub fn close_tag(&mut self, tag: &'static str)

Write closing tag: </tagname>

pub fn self_closing_tag(&mut self, tag: &'static str)

Write self-closing tag: <tagname />

pub fn open_tag_nl(&mut self, tag: &'static str)

Write opening tag with newline: <tagname>\n

pub fn close_tag_nl(&mut self, tag: &'static str)

Write closing tag with newline: </tagname>\n

pub fn paragraph_start(&mut self)

Write paragraph start: <p>

pub fn paragraph_end(&mut self)

Write paragraph end: </p>\n

pub fn heading_start(&mut self, level: u8)

Write heading start: <hN>

pub fn heading_start_with_id(&mut self, level: u8, id: &str)

Write heading start with ID: <hN id="slug">

pub fn heading_end(&mut self, level: u8)

Write heading end: </hN>\n

pub fn code_block_start(&mut self, lang: Option<&[u8]>)

Write code block start with optional language class. Processes backslash escapes in the language string.

pub fn write_info_string_attr(&mut self, info: &[u8])

Write fenced code info string with entity decoding and attribute escaping.

pub fn code_block_end(&mut self)

Write code block end: </code></pre>\n

pub fn thematic_break(&mut self)

Write thematic break: <hr />\n

pub fn blockquote_start(&mut self)

Write blockquote start: <blockquote>\n

pub fn blockquote_end(&mut self)

Write blockquote end: </blockquote>\n

pub fn callout_start(&mut self, callout: CalloutType)

Write callout/admonition start.

pub fn callout_end(&mut self)

Write callout/admonition end.

pub fn ul_start(&mut self)

Write list start (unordered): <ul>\n

pub fn ul_end(&mut self)

Write list end (unordered): </ul>\n

pub fn ol_start(&mut self, start: Option<u32>)

Write list start (ordered): <ol>\n or <ol start="N">\n

pub fn ol_end(&mut self)

Write list end (ordered): </ol>\n

pub fn li_start(&mut self)

Write list item start: <li>

pub fn li_end(&mut self)

Write list item end: </li>\n

pub fn table_start(&mut self)

Write table start: <table>\n

pub fn table_end(&mut self)

Write table end: </table>\n

pub fn thead_start(&mut self)

Write thead start: <thead>\n

pub fn thead_end(&mut self)

Write thead end: </thead>\n

pub fn tbody_start(&mut self)

Write tbody start: <tbody>\n

pub fn tbody_end(&mut self)

Write tbody end: </tbody>\n

pub fn tr_start(&mut self)

Write tr start: <tr>\n

pub fn tr_end(&mut self)

Write tr end: </tr>\n

pub fn th_start(&mut self, align: Alignment)

Write th start with optional alignment: <th> or <th align="...">

pub fn th_end(&mut self)

Write th end: </th>\n

pub fn td_start(&mut self, align: Alignment)

Write td start with optional alignment: <td> or <td align="...">

pub fn td_end(&mut self)

Write td end: </td>\n

pub fn inline_code(&mut self, content: &[u8])

Write inline code: <code>escaped_content</code>

pub fn em_start(&mut self)

Write emphasis start: <em>

pub fn em_end(&mut self)

Write emphasis end: </em>

pub fn strong_start(&mut self)

Write strong start: <strong>

pub fn strong_end(&mut self)

Write strong end: </strong>

pub fn del_start(&mut self)

Write strikethrough start: <del>

pub fn del_end(&mut self)

Write strikethrough end: </del>

pub fn link_start(&mut self, url: &[u8], title: Option<&[u8]>)

Write link start: <a href="url">

pub fn link_end(&mut self)

Write link end: </a>

pub fn line_break(&mut self)

Write line break: <br />\n

pub fn write_html_filtered(&mut self, html: &[u8])

Write raw HTML with GFM disallowed-tag filtering. Replaces < with < before disallowed tag names.

Trait Implementations

impl Default for HtmlWriter

fn default() -> Self

Returns the “default value” for a type.

impl Write for HtmlWriter

fn write_str(&mut self, s: &str) -> Result

Writes a string slice into this writer, returning whether the write succeeded.

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a char into this writer, returning whether the write succeeded.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the write! macro with implementors of this trait.