Struct Text

pub struct Text(/* private fields */);

The HTML text node. This is used inside tags eg

Text

Implementations

impl Text

pub fn create<S>(text: S) -> Text

where S: Into<String>,

Creates a text node. Note: will escape html markup eg <,>,&

Examples found in repository

examples/semantic.rs (line 13)

fn main() {
    let title = Some(Text::create("Title"));
    let styles = vec![];
    let url = Url::absolute_unchecked("http://google.com".into());
    let script = Script::External(url);
    let scripts = vec![script];
    let head = Head {
        title,
        styles,
        scripts,
    };
    let content = vec![Text::create("Hello").into()];
    let body = Body {
        content,
        scripts: vec![],
        id: Some(Id::create("my-id").unwrap()),
        class: vec![
            Class::create("test").unwrap(),
            Class::create("body").unwrap(),
        ],
    };
    let html = Html {
        head,
        body,
        lang: Value::EN,
    };
    let doc = Document { html };
    let string: String = doc.into();

    println!("{}", string);
}

examples/simple.rs (line 12)

fn main() {
    // Create a link
    let link = {
        let label = Text::create("Click Me");
        let url = Value::create("http://google.com").unwrap();
        // Anchor is a helper for the typical case
        Element::anchor(url, label)
    };
    // Create the body. Sugar function takes a list of child nodes
    let body = Element::body(vec![link]);

    // Create a header manually. There isn't a sugar function here
    let header = {
        let mut el = Element::<Vec<Node>>::create(Tag::HEADER);
        let text = Text::create("Hello world");
        let title = Element::title(text);
        el.push(title);
        el
    };
    let html = Element::html(Value::EN, header, body);

    // Convert an element into a node
    let node: Node = html.into();

    // Nodes can be turned into HTML formatted strings
    let string: String = node.into();

    println!("{}", string);
}

Trait Implementations

impl Clone for Text

fn clone(&self) -> Text

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Text

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

Formats the value using the given formatter.

impl<'a> From<Text> for BodyElement

fn from(value: Text) -> Self

Converts to this type from the input type.

impl<'a> From<Text> for Node<'a>

fn from(original: Text) -> Node<'a>

Converts to this type from the input type.

impl From<Text> for String

fn from(original: Text) -> String

Converts to this type from the input type.

impl PartialEq for Text

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Text

impl StructuralPartialEq for Text