Struct Document 

#[non_exhaustive]
pub struct Document {
    pub lang: Option<String>,
    pub head: Element,
    pub body: Element,
}

A complete HTML document: a language, a <head> and a <body>.

The Document owns the doctype — Document::render prepends <!DOCTYPE html>\n, while Document::root gives you the bare <html> element without it.

Rendering default

Document::render defaults to pretty, while Element::render defaults to compact. The asymmetry is deliberate and the golden fixtures depend on it, so it is not tidied up.

Examples

use molt::prelude::*;
use molt::Document;

let page = Document::new(Some("pt-BR"))
    .head_children([title().text("RideKeeper")])
    .body_children([h1().text("Track every service")]);

assert!(page.render().starts_with("<!DOCTYPE html>\n<html lang=\"pt-BR\">"));

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

lang: Option<String>

The document language, rendered as <html lang="…">. Omitted when None.

head: Element

The <head> element.

body: Element

The <body> element.

Implementations

impl Document

pub fn new(lang: Option<&str>) -> Self

Creates an empty document with the given language.

pub fn with_parts(lang: Option<&str>, head: Element, body: Element) -> Self

Creates a document from an existing <head> and <body>.

pub fn head_children<N: Into<Node>>( self, children: impl IntoIterator<Item = N>, ) -> Self

Appends nodes to the <head>.

pub fn body_children<N: Into<Node>>( self, children: impl IntoIterator<Item = N>, ) -> Self

Appends nodes to the <body>.

pub fn root(&self) -> Element

The <html> element, without the doctype.

Kept separate from render because the static site generator and several tests want the tree rather than the serialized page.

pub fn render_with(&self, options: &RenderOptions) -> String

Renders the document with the given options, prefixed by the doctype.

pub fn render(&self) -> String

Renders the document pretty-printed, which is the default for a document.

pub fn render_compact(&self) -> String

Renders the document on a single line.

pub fn render_to(&self, sink: impl Write, options: &RenderOptions) -> Result<()>

Writes the same bytes as render_with to sink.

When <body> is only a list of children, each child is rendered with Render::write_into into its own buffer and then written out, so memory stays bounded by the largest section rather than the whole page. A body with text content, no children, or a self-closing flag is written in one piece — still the same bytes.

Errors

Returns an error if sink does.

Examples

use molt::prelude::*;
use molt::{Document, RenderOptions};
let page = Document::new(Some("en")).body_children([h1().text("Hi")]);
let mut buf = Vec::new();
page.render_to(&mut buf, &RenderOptions::compact())?;
assert_eq!(buf, page.render_compact().into_bytes());

Trait Implementations

impl Clone for Document

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Document

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Document

fn default() -> Self

An empty document with no lang, same as Document::new(None).

impl Display for Document

fn fmt(&self, f: &mut Formatter<'_>) -> Result

The pretty render with doctype, same as Document::render.

impl Eq for Document

impl PartialEq for Document

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Document