Enum Node 

#[non_exhaustive]
pub enum Node {
    Element(Element),
    Text(Markup),
    Raw(Markup),
    Comment(Markup),
    Fragment(Vec<Node>),
}

A node in the HTML tree.

Examples

use molt::prelude::*;
let node = Node::from(div().text("hi"));
assert_eq!(node.render(), "<div>hi</div>");

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Element(Element)

An element with a tag name, attributes and children.

Text(Markup)

Escaped text. The escaping already happened — see crate::core::escape.

Raw(Markup)

Verbatim markup, never escaped. For imported snippets: an SVG, an embed code.

Unlike Node::Fragment, this is an opaque string, so pretty printing can only indent the whole blob. Reach for a fragment when you want the children indented.

Comment(Markup)

An HTML comment.

The content has -- neutralised so the comment cannot be closed early.

Fragment(Vec<Node>)

A transparent group that renders its children with no wrapper element.

Use it to return several nodes from one expression — a map of cards, the body of an if, a group of <meta> tags — without introducing an extra <div>.

Implementations

impl Node

pub fn text(content: impl AsRef<str>) -> Self

Creates a text node, escaping the content.

pub fn raw(content: impl Into<String>) -> Self

Creates a raw markup node. The content is not escaped.

One of the three escape hatches, with Element::raw_text and Attribute::raw; grep for the three to audit a codebase. Use it for markup you wrote or already sanitised: an SVG icon, an embed snippet. Never pass text a user typed. < in it becomes markup, </script> ends a script, and nothing downstream will stop it.

For JSON in a <script> use seo::json_ld, which escapes it. To show untrusted text, use Node::text.

Examples

use molt::prelude::*;
let icon = Node::raw(r#"<svg viewBox="0 0 1 1"><path d="M0 0h1v1z"/></svg>"#);
assert!(icon.render().starts_with("<svg"));

// The same text through `Node::text` is shown, not interpreted.
assert_eq!(Node::text("<b>").render(), "&lt;b&gt;");

pub fn comment(content: impl AsRef<str>) -> Self

Creates a comment node.

A space is put between every two adjacent - and after a trailing -, so no run of two hyphens survives and the comment cannot terminate early and inject markup.

Examples

use molt::prelude::*;
assert_eq!(Node::comment("a -- b").render(), "<!-- a - - b -->");
assert_eq!(Node::comment("x--->").render(), "<!-- x- - -> -->");

pub fn fragment(children: impl IntoIterator<Item = Node>) -> Self

Creates a transparent group of nodes.

pub fn is_empty(&self) -> bool

Whether this node renders to nothing.

The pretty-print writer arrives at the same answer without calling this: it lets a child write straight into the output and rolls the separator back if the child wrote nothing, which is what stops an empty fragment — the body of a false if — from leaving a blank line behind.

Trait Implementations

impl Clone for Node

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 Node

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

Formats the value using the given formatter.

impl Display for Node

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

The compact render, or the pretty one with the alternate flag: {node} / {node:#}.

impl Eq for Node

impl From<&str> for Node

fn from(text: &str) -> Self

Converts to this type from the input type.

impl From<Element> for Node

fn from(element: Element) -> Self

Converts to this type from the input type.

impl<T: Into<Node>> From<Option<T>> for Node

None is an empty fragment, which renders to nothing and leaves no blank line.

fn from(value: Option<T>) -> Self

Converts to this type from the input type.

impl From<String> for Node

fn from(text: String) -> Self

Converts to this type from the input type.

impl From<Vec<Node>> for Node

fn from(children: Vec<Node>) -> Self

Converts to this type from the input type.

impl From<char> for Node

fn from(c: char) -> Self

Converts to this type from the input type.

impl<N: Into<Node>> FromIterator<N> for Node

Collects nodes into a Node::Fragment, so .collect::<Node>() replaces Node::fragment(iter).

fn from_iter<I: IntoIterator<Item = N>>(iter: I) -> Self

Creates a value from an iterator.

impl Hash for Node

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Node

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

Equality operator ==.

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

Inequality operator !=.

impl Render for Node

fn write_into(&self, out: &mut String, options: &RenderOptions, depth: usize)

Writes this node and its subtree into an existing buffer.

fn render(&self) -> String

Renders as a single line of markup.

fn render_pretty(&self) -> String

Renders with indentation and line breaks.

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

Renders with the given options.