Struct lol_html::html_content::TextChunk

pub struct TextChunk<'i> { /* fields omitted */ }

An HTML text node chunk.

Since the rewriter operates on a streaming input with minimal internal buffering, HTML text node can be represented by multiple text chunks. The size of a chunk depends on multiple parameters, such as decoding buffer size and input chunk size.

It is up to a user of the rewriter to buffer content of chunks to get whole text node content where desired. Last chunk in a text node can be determined by calling last_in_text_node method of the chunk.

Note that the last chunk in a text node can have empty textual content.

Example

use lol_html::{HtmlRewriter, Settings, text};

let mut greeting = String::new();

{
    let mut rewriter = HtmlRewriter::try_new(
        Settings {
           element_content_handlers: vec![
               text!("div", |t| {
                 greeting += t.as_str();

                 if t.last_in_text_node() {
                        greeting += "!";
                    }

                    Ok(())
                })
            ],
            ..Settings::default()
        },
        |_:&[u8]| {}
    ).unwrap();

    rewriter.write(b"<div>He").unwrap();
    rewriter.write(b"llo w").unwrap();
    rewriter.write(b"orld</div>").unwrap();
    rewriter.end().unwrap();
}

assert_eq!(greeting, "Hello world!");

Methods

impl<'i> TextChunk<'i>

pub fn as_str(&self) -> &str

Returns the textual content of the chunk.

pub fn text_type(&self) -> TextType

Returns the type of the text in the chunk.

The type of the text depends on the surrounding context of the text. E.g. regular visible text and text inside a <script> element will have different types. Refer to TextType for more information about possible text types.

Example

use lol_html::{rewrite_str, text, RewriteStrSettings};
use lol_html::html_content::TextType;

let html = rewrite_str(
    r#"<div>Hello</div><script>"use strict";</script>"#,
    RewriteStrSettings {
        element_content_handlers: vec![
            text!("div", |t| {
                assert_eq!(t.text_type(), TextType::Data);

                Ok(())
            }),
            text!("script", |t| {
                assert_eq!(t.text_type(), TextType::ScriptData);

                Ok(())
            })
        ],
        ..RewriteStrSettings::default()
    }
).unwrap();

pub fn last_in_text_node(&self) -> bool

Returns true if the chunk is last in a HTML text node.

Note that last chunk can have empty textual content.

pub fn before(&mut self, content: &str, content_type: ContentType)

Inserts content before the text chunk.

Consequent calls to the method append content to the previously inserted content.

Example

use lol_html::{rewrite_str, text, RewriteStrSettings};
use lol_html::html_content::ContentType;

let html = rewrite_str(
    r#"<div>world</div>"#,
    RewriteStrSettings {
        element_content_handlers: vec![
            text!("div", |t| {
                if !t.last_in_text_node(){
                    t.before("<!-- 42 -->", ContentType::Html);
                    t.before("Hello ", ContentType::Text);
                }

                Ok(())
            })
        ],
        ..RewriteStrSettings::default()
    }
).unwrap();

assert_eq!(html, r#"<div><!-- 42 -->Hello world</div>"#);

pub fn after(&mut self, content: &str, content_type: ContentType)

Inserts content after the text chunk.

Consequent calls to the method prepend content to the previously inserted content.

Example

use lol_html::{rewrite_str, text, RewriteStrSettings};
use lol_html::html_content::ContentType;

let html = rewrite_str(
    r#"<div>Foo</div>"#,
    RewriteStrSettings {
        element_content_handlers: vec![
            text!("div", |t| {
                if t.last_in_text_node(){
                    t.after("Bar", ContentType::Text);
                    t.after("Qux", ContentType::Text);
                }

                Ok(())
            })
        ],
        ..RewriteStrSettings::default()
    }
).unwrap();

assert_eq!(html, r#"<div>FooQuxBar</div>"#);

pub fn replace(&mut self, content: &str, content_type: ContentType)

Replaces the text chunk with the content.

Consequent calls to the method overwrite previous replacement content.

Example

use lol_html::{rewrite_str, text, RewriteStrSettings};
use lol_html::html_content::ContentType;

let html = rewrite_str(
    r#"<div>Foo</div>"#,
    RewriteStrSettings {
        element_content_handlers: vec![
            text!("div", |t| {
                if !t.last_in_text_node(){
                    t.replace("Bar", ContentType::Text);
                    t.replace("Qux", ContentType::Text);
                }

                Ok(())
            })
        ],
        ..RewriteStrSettings::default()
    }
).unwrap();

assert_eq!(html, r#"<div>Qux</div>"#);

pub fn remove(&mut self)

Removes the text chunk.

pub fn removed(&self) -> bool

Returns true if the text chunk has been replaced or removed.

Trait Implementations

impl<'_> Debug for TextChunk<'_>

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

Formats the value using the given formatter.

impl<'_> UserData for TextChunk<'_>

fn user_data(&self) -> &dyn Any

Returns a reference to the attached user data.

fn user_data_mut(&mut self) -> &mut dyn Any

Returns a mutable reference to the attached user data.

fn set_user_data(&mut self, data: impl Any)

Attaches user data to a rewritable unit.