Build Html

https://docs.rs/build_html/2.6.0/
Admin
A Rust library that provides a simple builder pattern to generate HTML strings and documents from...
Tokens:99,827
Snippets:452
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### HtmlPage Example: with_version()

Source: https://docs.rs/build_html/2.6.0/build_html/struct.HtmlPage

Example demonstrating the usage of `with_version` to create an HTML4 page and verifying its output string.

```rust
assert_eq!(
    HtmlPage::with_version(HtmlVersion::HTML4).to_html_string(),
    concat!(
        r#"<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "#,
        r#"http://www.w3.org/TR/html4/loose.dtd">"#,
        "<html><head></head><body></body></html>",
    ),
)
```

--------------------------------

### HtmlPage Example: add_head_link_attr()

Source: https://docs.rs/build_html/2.6.0/build_html/struct.HtmlPage

Example showing how to add a stylesheet link with a 'media' attribute using `add_head_link_attr`.

```rust
let mut page = HtmlPage::new();
page.add_head_link_attr("print.css", "stylesheet", [("media", "print")]);

assert_eq!(page.to_html_string(), concat!(
    "<!DOCTYPE html><html><head>",
    r#"<link href=\"print.css\" rel=\"stylesheet\" media=\"print\">"#,
    "</head><body></body></html>"
));
```

--------------------------------

### HtmlPage new Constructor

Source: https://docs.rs/build_html/2.6.0/src/build_html/html_page/mod.rs

Creates a new `HtmlPage` instance with the default HTML5 version. This is the primary way to start building a new HTML page.

```rust
pub fn new() -> Self {
    Self::with_version(HtmlVersion::HTML5)
}
```

--------------------------------

### HtmlPage Example: with_head_link()

Source: https://docs.rs/build_html/2.6.0/build_html/struct.HtmlPage

Example demonstrating the use of `with_head_link` in a chain to add a favicon link and then convert the page to a string.

```rust
let page = HtmlPage::new()
    .with_head_link("favicon.ico", "icon")
    .to_html_string();

assert_eq!(page, concat!(
    "<!DOCTYPE html><html><head>",
    r#"<link href=\"favicon.ico\" rel=\"icon\">"#,
    "</head><body></body></html>"
));
```

--------------------------------

### Container Usage Example

Source: https://docs.rs/build_html/2.6.0/build_html/struct.Container

Demonstrates how to create and populate a Container with nested elements like headers, articles, and paragraphs, then convert it to an HTML string.

```Rust
let text = Container::new(ContainerType::Main)
    .with_header(1, "My Container")
    .with_container(
        Container::new(ContainerType::Article)
            .with_container(
                Container::new(ContainerType::Div)
                    .with_paragraph("Inner Text")
            )
    )
    .to_html_string();

assert_eq!(
    text,
    "<main><h1>My Container</h1><article><div><p>Inner Text</p></div></article></main>"
);
```

--------------------------------

### HtmlPage API: new()

Source: https://docs.rs/build_html/2.6.0/build_html/struct.HtmlPage

Creates a new, empty HTML page instance. This is the starting point for building any HTML content.

```APIDOC
HtmlPage::new()
  - Creates a new HTML page with no content.
  - Returns: Self (a new HtmlPage instance)
```

--------------------------------

### Rust with_raw Example

Source: https://docs.rs/build_html/2.6.0/build_html/trait.HtmlContainer

An example demonstrating the usage of the `with_raw` method to insert a raw HTML video tag into an `HtmlElement` and then convert the element to its HTML string representation.

```rust
let content = HtmlElement::new(HtmlTag::Div)
    .with_raw(r#"<video width=\"250\"><source src=\"video.mp4\" type=\"video/mp4\"></video>"#)
    .to_html_string();

assert_eq!(
    content,
    r#"<div><video width=\"250\"><source src=\"video.mp4\" type=\"video/mp4\"></video></div>"#
);
```

--------------------------------

### HtmlPage Example: add_head_link()

Source: https://docs.rs/build_html/2.6.0/build_html/struct.HtmlPage

Example showing how to use `add_head_link` to add a favicon link to the HTML head and then convert the page to a string.

```rust
let mut page = HtmlPage::new();
page.add_head_link("favicon.ico", "icon");

assert_eq!(page.to_html_string(), concat!(
    "<!DOCTYPE html><html><head>",
    r#"<link href=\"favicon.ico\" rel=\"icon\">"#,
    "</head><body></body></html>"
));
```

--------------------------------

### HtmlElement::new Function

Source: https://docs.rs/build_html/2.6.0/build_html/struct.HtmlElement

Illustrates how to create a new, empty HtmlElement instance with a specified HTML tag. This is the starting point for building an element.

```rust
assert_eq!(HtmlElement::new(HtmlTag::Div).to_html_string(), "<div/>");
```

--------------------------------

### TableRow Struct Example

Source: https://docs.rs/build_html/2.6.0/build_html/struct.TableRow

Demonstrates how to create and configure a TableRow using the build_html crate, including adding attributes and cells, and converting it to an HTML string.

```Rust
let row = TableRow::new()
    .with_attributes([("id", "my-row")])
    .with_cell(TableCell::new(TableCellType::Header).with_raw("Header"))
    .with_cell(TableCell::default().with_raw(1))
    .to_html_string();

assert_eq!(row, r#"<tr id="my-row"><th>Header</th><td>1</td></tr>"#);
```

--------------------------------

### Container Struct Usage Example

Source: https://docs.rs/build_html/2.6.0/src/build_html/container.rs

Demonstrates how to create and build nested HTML structures using the `Container` struct, including adding headers, paragraphs, and other containers. Shows the builder pattern for chaining methods.

```Rust
/// A container for HTML elements.
///
/// As the name would suggest, a `Container` contains other HTML elements. This struct guarantees
/// that the elements added will be converted to HTML strings in the same order as they were
/// added.
///
/// Supported container types are provided by the [`ContainerType`] enum.
///
/// Note that `Container` elements can be nested inside of each other.
/// ```rust
/// # use build_html::*
/// let text = Container::new(ContainerType::Main)
///     .with_header(1, "My Container")
///     .with_container(
///         Container::new(ContainerType::Article)
///             .with_container(
///                 Container::new(ContainerType::Div)
///                     .with_paragraph("Inner Text")
///             )
///     )
///     .to_html_string();
///
/// assert_eq!(
///     text,
///     "<main><h1>My Container</h1><article><div><p>Inner Text</p></div></article></main>"
/// );
/// ```
```

--------------------------------

### Html Trait to_html_string Example

Source: https://docs.rs/build_html/2.6.0/build_html/trait.Html

An example demonstrating the usage of the `to_html_string` method on an `HtmlElement` to convert it into an HTML string representation.

```rust
let html = HtmlElement::new(HtmlTag::Div)
    .with_paragraph("My p element")
    .to_html_string();

assert_eq!(html, "<div><p>My p element</p></div>");
```

--------------------------------

### HtmlVersion Enum Example Usage

Source: https://docs.rs/build_html/2.6.0/build_html/enum.HtmlVersion

Demonstrates how to use the HtmlVersion enum to create HTML pages with specific doctypes and attributes. It shows examples for HTML5 and XHTML1.0.

```rust
assert_eq!(
    HtmlPage::with_version(HtmlVersion::HTML5).to_html_string(),
    "<!DOCTYPE html><html><head></head><body></body></html>"
);

assert_eq!(
    HtmlPage::with_version(HtmlVersion::XHTML1_0).to_html_string(),
    concat!(
        r#"<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "#,
        r#" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">"#,
        r#"<html xmlns=\"http://www.w3.org/1999/xhtml">"#,
        r#"<head></head><body></body></html>"#,
    ),
)
```

--------------------------------

### Initialize New Table

Source: https://docs.rs/build_html/2.6.0/build_html/struct.Table

Creates a new, empty `Table` instance. This is the starting point for building a table programmatically, allowing subsequent addition of headers, body rows, and attributes.

```rust
let mut table = Table::new();
```

--------------------------------

### HtmlElement Builder Pattern Example

Source: https://docs.rs/build_html/2.6.0/build_html/struct.HtmlElement

Demonstrates the usage of the HtmlElement builder pattern to construct a complex HTML structure. It shows chaining methods like `new`, `with_attribute`, and `with_child` to create nested elements and apply attributes.

```rust
let output = HtmlElement::new(HtmlTag::Div)
    .with_child(
        HtmlElement::new(HtmlTag::Heading1)
            .with_attribute("class", "big-text")
            .with_child("Header Text".into())
            .into(),
    )
    .with_child(
        HtmlElement::new(HtmlTag::ParagraphText)
            .with_child("Paragraph Text".into())
            .with_child(HtmlElement::new(HtmlTag::LineBreak).into())
            .with_child("Paragraph Text Line 2".into())
            .into(),
    )
    .to_html_string();

assert_eq!(output, r##"<div><h1 class="big-text">Header Text</h1><p>Paragraph Text<br/>Paragraph Text Line 2</p></div>"##);
```

--------------------------------

### Using add_ vs with_ Methods

Source: https://docs.rs/build_html/2.6.0/src/build_html/lib.rs

Explains the difference between `add_` (mutates reference) and `with_` (consumes self) methods in the library. This example shows how to use `add_child` with a `with_` method internally to build a structure with dynamic content, demonstrating flexibility in mutation and consumption patterns.

```Rust
# use build_html::{HtmlElement, HtmlTag, Html, HtmlContainer};
let mut root = HtmlElement::new(HtmlTag::Div)
    .with_child(HtmlElement::new(HtmlTag::Heading1).with_child("Counts".into()).into());

for x in 1..=3 {
    // Here, we're adding by reference using an `add` method while also building
    // our inner element with a `with` method.
    root.add_child(HtmlElement::new(HtmlTag::Div).with_paragraph(x).into());
}

assert_eq!(root.to_html_string(), concat!(
    "<div><h1>Counts</h1>",
    "<div><p>1</p></div>",
    "<div><p>2</p></div>",
    "<div><p>3</p></div>",
    "</div>"
));

```

--------------------------------

### Build HTML Ordered List with Elements in Rust

Source: https://docs.rs/build_html/2.6.0/src/build_html/container.rs

Illustrates the creation of an HTML ordered list (`<ol>`) containing various child elements. This example shows how to add list items that include headers, images, links, paragraphs with classes, and preformatted text, demonstrating the API's flexibility for list content.

```rust
#[test]
fn test_list() {
    // Expected HTML output for an ordered list
    let content = concat!(
        r#"<li><h1 id=\"main-header\">header</h1></li>"#,
        r#"<li><img src=\"myimage.png\" alt=\"test image"/></li>"#,
        r#"<li><a href=\"rust-lang.org\">Rust Home</a></li>"#,
        r#"<li><p class=\"red-text\">Sample Text</p></li>"#,
        r#"<li><pre class=\"code\">Text</pre></li>"#
    );

    // Act: Construct an ordered list container with multiple elements
    let sut = Container::new(ContainerType::OrderedList)
        .with_header_attr(1, "header", [("id", "main-header")])
        .with_image("myimage.png", "test image")
        .with_link("rust-lang.org", "Rust Home")
        .with_paragraph_attr("Sample Text", [("class", "red-text")])
        .with_preformatted_attr("Text", [("class", "code")]);

    // Assert: Compare the generated HTML with the expected string
    assert_eq!(
        sut.to_html_string(),
        format!(
            "<{tag}>{content}</{tag}>",
            tag = ContainerType::OrderedList,
            content = content
        )
    )
}
```

--------------------------------

### HtmlElement Table Integration in Rust

Source: https://docs.rs/build_html/2.6.0/build_html/trait.HtmlContainer

Demonstrates creating a `Table` with header rows and adding it to an `HtmlElement` container using both `add_table` and the builder pattern `with_table`. The examples show the resulting HTML output.

```Rust
let table = Table::from([
    [1, 2, 3],
    [4, 5, 6]
]).with_header_row(['A', 'B', 'C']);
let mut container = HtmlElement::new(HtmlTag::Div);
container.add_table(table);

assert_eq!(
    container.to_html_string(),
    concat!(
        "<div><table><thead>",
        "<tr><th>A</th><th>B</th><th>C</th></tr>",
        "</thead><tbody>",
        "<tr><td>1</td><td>2</td><td>3</td></tr>",
        "<tr><td>4</td><td>5</td><td>6</td></tr>",
        "</tbody></table></div>"
    )
);
```

```Rust
let content = HtmlElement::new(HtmlTag::Div)
    .with_table(
        Table::from(&[
            [1, 2, 3],
            [4, 5, 6]
        ])
        .with_header_row(&['A', 'B', 'C'])
    )
    .to_html_string();

assert_eq!(
    content,
    concat!(
        "<div><table><thead>",
        "<tr><th>A</th><th>B</th><th>C</th></tr>",
        "</thead><tbody>",
        "<tr><td>1</td><td>2</td><td>3</td></tr>",
        "<tr><td>4</td><td>5</td><td>6</td></tr>",
        "</tbody></table></div>"
    )
);
```

--------------------------------

### HtmlChild Usage Example

Source: https://docs.rs/build_html/2.6.0/build_html/enum.HtmlChild

Demonstrates how to use the HtmlChild enum, specifically converting strings and HtmlElements into HtmlChild variants using `.into()` for building HTML structures.

```rust
let html = HtmlElement::new(HtmlTag::Div)
    .with_child(
        HtmlElement::new(HtmlTag::ParagraphText)
            .with_child(
                "raw text".into() // Convert this `&str` into an `HtmlChild::Raw`
            )
            .into() // Convert this `HtmlElement` into an `HtmlChild::Element`
    )
    .to_html_string();

assert_eq!(html, "<div><p>raw text</p></div>")
```

--------------------------------

### Rust HtmlContainer with_paragraph Example

Source: https://docs.rs/build_html/2.6.0/build_html/trait.HtmlContainer

Demonstrates using the `with_paragraph` method of the HtmlContainer trait. It shows how to chain methods and pass a type implementing ToString (like Ipv4Addr) directly to create HTML content.

```rust
let content = HtmlElement::new(HtmlTag::Div)
    .with_paragraph(Ipv4Addr::new(127, 0, 0, 1))
    .to_html_string();
assert_eq!(content, "<div><p>127.0.0.1</p></div>")
```

--------------------------------

### HtmlPage Initialization and Basic Usage

Source: https://docs.rs/build_html/2.6.0/build_html/struct.HtmlPage

Demonstrates how to create a new HtmlPage, set its title, add a header, and convert it to an HTML string. This showcases the builder pattern for constructing HTML content.

```rust
let page: String = HtmlPage::new()
    .with_title("My Page")
    .with_header(1, "Header Text")
    .to_html_string();

assert_eq!(page, concat!(
    "<!DOCTYPE html><html><head><title>My Page</title></head>",
    "<body><h1>Header Text</h1></body></html>"
));
```

--------------------------------

### Using `add_` vs `with_` Methods

Source: https://docs.rs/build_html/2.6.0/build_html/index

Explains the difference between `add_` methods (side-effecting, mutable reference) and `with_` methods (self-consuming) in the `build_html` library. Demonstrates building complex structures by mixing these patterns.

```rust
let mut root = HtmlElement::new(HtmlTag::Div)
    .with_child(HtmlElement::new(HtmlTag::Heading1).with_child("Counts".into()).into());

for x in 1..=3 {
    // Here, we're adding by reference using an `add` method while also building
    // our inner element with a `with` method.
    root.add_child(HtmlElement::new(HtmlTag::Div).with_paragraph(x).into());
}

assert_eq!(root.to_html_string(), concat!(
    "<div><h1>Counts</h1>",
    "<div><p>1</p></div>",
    "<div><p>2</p></div>",
    "<div><p>3</p></div>",
    "</div>"
));
```

--------------------------------

### build_html Crate Overview

Source: https://docs.rs/build_html/2.6.0/build_html/enum.HtmlTag

Provides essential information about the build_html Rust crate, including its version, license, repository links, and crates.io page. It also highlights the crate's documentation status and platform support.

```APIDOC
Project: build_html 2.6.0

Crate Information:
  Version: 2.6.0
  License: MIT
  Repository: https://github.com/skubalj/build_html
  Crates.io: https://crates.io/crates/build_html
  Docs.rs: /crate/build_html/2.6.0

Platform Support:
  - i686-pc-windows-msvc
  - i686-unknown-linux-gnu
  - x86_64-apple-darwin
  - x86_64-pc-windows-msvc
  - x86_64-unknown-linux-gnu

Features:
  - Browse available feature flags: /crate/build_html/2.6.0/features

Documentation Status:
  - 100% of the crate is documented.
```

--------------------------------

### Container with Attributes Example

Source: https://docs.rs/build_html/2.6.0/src/build_html/container.rs

Illustrates how to apply attributes to a `Container` element using the `with_attributes` method. This method overrides any previously set attributes.

```Rust
/// Associates the specified map of attributes with this Container.
///
/// Note that this operation overrides all previous `with_attribute` calls on
/// this `Container`
///
/// # Example
/// ```
/// # use build_html::*
/// let container = Container::default()
///     .with_attributes(vec![("class", "defaults")])
///     .with_paragraph("text")
///     .to_html_string();
///
/// assert_eq!(container, r"<div class=\"defaults\"><p>text</p></div>")
/// ```
```

--------------------------------

### Using `add_` vs `with_` Methods

Source: https://docs.rs/build_html/2.6.0/build_html

Explains the difference between `add_` methods (side-effecting, mutable reference) and `with_` methods (self-consuming) in the `build_html` library. Demonstrates building complex structures by mixing these patterns.

```rust
let mut root = HtmlElement::new(HtmlTag::Div)
    .with_child(HtmlElement::new(HtmlTag::Heading1).with_child("Counts".into()).into());

for x in 1..=3 {
    // Here, we're adding by reference using an `add` method while also building
    // our inner element with a `with` method.
    root.add_child(HtmlElement::new(HtmlTag::Div).with_paragraph(x).into());
}

assert_eq!(root.to_html_string(), concat!(
    "<div><h1>Counts</h1>",
    "<div><p>1</p></div>",
    "<div><p>2</p></div>",
    "<div><p>3</p></div>",
    "</div>"
));
```

--------------------------------

### Rust Blanket Implementation: Any for T

Source: https://docs.rs/build_html/2.6.0/build_html/enum.ContainerType

This is a blanket implementation of the Any trait for any type T that is 'static and not Sized. It provides a method to get the unique type identifier of an instance.

```rust
impl<T> Any for T where T: 'static + ?Sized
// Blanket implementation of Any trait.

fn type_id(&self) -> TypeId
// Gets the TypeId of `self`.
```

--------------------------------

### ToString Trait Method

Source: https://docs.rs/build_html/2.6.0/build_html/struct.HtmlElement

Allows converting a value into a `String` if the type implements the `Display` trait. This is a common way to get a string representation of an object.

```APIDOC
trait ToString {
    fn to_string(&self) -> String;
}

// Requires: T: Display

// Example usage (conceptual):
// let number: i32 = 123;
// let string_representation: String = number.to_string(); // "123"
```

--------------------------------

### Container API Documentation

Source: https://docs.rs/build_html/2.6.0/build_html/struct.Container

Provides details on the methods available for the Container struct in the build_html crate, including constructors and methods for adding content.

```APIDOC
Container:
  __new__(tag: ContainerType) -> Self
    Creates a new container with the specified tag.
    Parameters:
      tag: The HTML tag type for the container (e.g., Main, Article, Div).
    Returns: A new Container instance.

  __with_attributes__(attributes: Vec<(String, String)>) -> Self
    Adds HTML attributes to the container.
    Parameters:
      attributes: A vector of key-value pairs representing HTML attributes.
    Returns: The modified Container instance.

  __with_header__(level: u8, text: &str) -> Self
    Adds a header element (h1-h6) to the container.
    Parameters:
      level: The header level (1-6).
      text: The content of the header.
    Returns: The modified Container instance.

  __with_paragraph__(text: &str) -> Self
    Adds a paragraph element to the container.
    Parameters:
      text: The content of the paragraph.
    Returns: The modified Container instance.

  __with_container__(container: Container) -> Self
    Adds a nested container element to the current container.
    Parameters:
      container: The Container instance to add.
    Returns: The modified Container instance.

  __to_html_string__() -> String
    Converts the container and its contents into an HTML string.
    Returns: A String representing the generated HTML.
```

--------------------------------

### Add Cell to TableRow (Rust)

Source: https://docs.rs/build_html/2.6.0/build_html/struct.TableRow

Shows how to add a `TableCell` to an existing `TableRow` using the `add_cell` method. The `TableCell` can contain other HTML elements, such as a paragraph in this example.

```Rust
let mut out = TableRow::new();
out.add_cell(TableCell::default().with_paragraph("Hello, World!"));
assert_eq!(out.to_html_string(), "<tr><td><p>Hello, World!</p></td></tr>");
```

--------------------------------

### Build HTML Elements with HtmlElement

Source: https://docs.rs/build_html/2.6.0/src/build_html/lib.rs

Demonstrates creating nested HTML elements like `<div>`, `<p>`, and `<pre>` using the `HtmlElement` builder pattern. It shows how to chain `with_child` calls and convert the structure to an HTML string using `to_html_string`. Requires the `build_html` crate.

```Rust
use build_html::{HtmlElement, HtmlTag, Html};

let element = HtmlElement::new(HtmlTag::Div)
    .with_child(
        HtmlElement::new(HtmlTag::ParagraphText)
            .with_child("Paragraph Text".into())
            .into()
    )
    .with_child(
        HtmlElement::new(HtmlTag::PreformattedText)
            .with_child("Preformatted Text".into())
            .into()
    )
    .to_html_string();

assert_eq!(element, "<div><p>Paragraph Text</p><pre>Preformatted Text</pre></div>");

```

--------------------------------

### HtmlPage API Documentation

Source: https://docs.rs/build_html/2.6.0/build_html/struct.HtmlPage

Comprehensive API documentation for the HtmlPage struct in the build_html crate. This includes methods for adding various HTML elements like head links, meta tags, scripts, styles, and setting the page title. It also covers the constructor 'new' and builder-style methods prefixed with 'with_'. These methods allow for programmatic construction and modification of HTML page structures.

```APIDOC
HtmlPage:
  // Constructor
  new() -> HtmlPage
    Creates a new, empty HtmlPage.

  // Methods for adding elements (mutable):
  add_head_link(&mut self, href: &str, attrs: &[(&str, &str)])
    Adds a link tag to the page's head section with specified attributes.
    Parameters:
      href: The URL for the link.
      attrs: A slice of key-value pairs for HTML attributes (e.g., rel="stylesheet").

  add_head_link_attr(&mut self, attr_name: &str, attr_value: &str)
    Adds a single attribute to all existing head link tags.
    Parameters:
      attr_name: The name of the attribute to add.
      attr_value: The value of the attribute.

  add_meta(&mut self, name: &str, content: &str)
    Adds a meta tag to the page's head section.
    Parameters:
      name: The name attribute of the meta tag.
      content: The content attribute of the meta tag.

  add_script_link(&mut self, src: &str, attrs: &[(&str, &str)])
    Adds a script tag with a source URL to the page's head or body.
    Parameters:
      src: The URL of the script.
      attrs: A slice of key-value pairs for HTML attributes (e.g., defer="true").

  add_script_link_attr(&mut self, attr_name: &str, attr_value: &str)
    Adds a single attribute to all existing script link tags.
    Parameters:
      attr_name: The name of the attribute to add.
      attr_value: The value of the attribute.

  add_script_literal(&mut self, script_content: &str)
    Adds a script tag containing inline JavaScript code.
    Parameters:
      script_content: The JavaScript code to embed.

  add_style(&mut self, style_content: &str)
    Adds a style tag containing inline CSS code.
    Parameters:
      style_content: The CSS code to embed.

  add_style_attr(&mut self, attr_name: &str, attr_value: &str)
    Adds a single attribute to all existing style tags.
    Parameters:
      attr_name: The name of the attribute to add.
      attr_value: The value of the attribute.

  add_stylesheet(&mut self, href: &str, attrs: &[(&str, &str)])
    Adds a stylesheet link tag to the page's head section.
    Parameters:
      href: The URL of the stylesheet.
      attrs: A slice of key-value pairs for HTML attributes (e.g., media="screen").

  add_title(&mut self, title: &str)
    Adds or sets the title tag for the HTML page.
    Parameters:
      title: The text content for the title tag.

  // Builder-style methods (return new HtmlPage):
  with_head_link(self, href: &str, attrs: &[(&str, &str)]) -> HtmlPage
    Returns a new HtmlPage with an added head link.

  with_head_link_attr(self, attr_name: &str, attr_value: &str) -> HtmlPage
    Returns a new HtmlPage with an attribute added to all head links.

  with_meta(self, name: &str, content: &str) -> HtmlPage
    Returns a new HtmlPage with an added meta tag.

  with_script_link(self, src: &str, attrs: &[(&str, &str)]) -> HtmlPage
    Returns a new HtmlPage with an added script link.

  with_script_link_attr(self, attr_name: &str, attr_value: &str) -> HtmlPage
    Returns a new HtmlPage with an attribute added to all script links.

  with_script_literal(self, script_content: &str) -> HtmlPage
    Returns a new HtmlPage with an added literal script block.

  with_style(self, style_content: &str) -> HtmlPage
    Returns a new HtmlPage with an added style block.

  with_style_attr(self, attr_name: &str, attr_value: &str) -> HtmlPage
    Returns a new HtmlPage with an attribute added to all style blocks.

  with_stylesheet(self, href: &str, attrs: &[(&str, &str)]) -> HtmlPage
    Returns a new HtmlPage with an added stylesheet link.

  with_title(self, title: &str) -> HtmlPage
    Returns a new HtmlPage with the title set.

  with_version(self, version: &str) -> HtmlPage
    Adds version information, potentially to links or other elements.
    Parameters:
      version: The version string to incorporate.

// Trait Implementations:
// Debug, Default, Html, HtmlContainer
// Auto Trait Implementations:
// Freeze, RefUnwindSafe, Send, Sync, Unpin, UnwindSafe
// Blanket Implementations:
// Any, Borrow<T>, BorrowMut<T>, From<T>, Into<U>, TryFrom<U>, TryInto<U>
```

--------------------------------

### Rust HtmlContainer with_paragraph_attr Example

Source: https://docs.rs/build_html/2.6.0/build_html/trait.HtmlContainer

Illustrates using the `with_paragraph_attr` method to add attributes to an HTML paragraph. It shows how to pass attributes as an array of tuples, where each tuple contains string slices for the attribute name and value.

```rust
let content = HtmlElement::new(HtmlTag::Div)
    .with_paragraph_attr("123", [("id", "paragraph"), ("class", "action")])
    .to_html_string();
assert_eq!(content, r"<div><p id=\"paragraph\" class=\"action\">123</p></div>")
```

--------------------------------

### Build Dynamic HTML Elements with HtmlElement

Source: https://docs.rs/build_html/2.6.0/build_html/index

Demonstrates creating nested HTML elements like divs and paragraphs using the `HtmlElement` and `HtmlTag` types from the `build_html` library. Shows how to chain methods for building complex structures.

```rust
use build_html::{HtmlElement, HtmlTag, Html};

let element = HtmlElement::new(HtmlTag::Div)
    .with_child(
        HtmlElement::new(HtmlTag::ParagraphText)
            .with_child("Paragraph Text".into())
            .into()
    )
    .with_child(
        HtmlElement::new(HtmlTag::PreformattedText)
            .with_child("Preformatted Text".into())
            .into()
    )
    .to_html_string();

assert_eq!(element, "<div><p>Paragraph Text</p><pre>Preformatted Text</pre></div>");
```

--------------------------------

### HtmlPage with_version Constructor

Source: https://docs.rs/build_html/2.6.0/src/build_html/html_page/mod.rs

Creates a new `HtmlPage` instance with a specified HTML version (e.g., HTML4, HTML5). This allows for flexibility in defining the document's doctype and attributes.

```rust
pub fn with_version(version: HtmlVersion) -> Self {
    HtmlPage {
        version,
        head: String::new(),
        body: String::new(),
    }
}
```

--------------------------------

### Imperatively Add HTML Elements in Rust

Source: https://docs.rs/build_html/2.6.0/build_html/trait.HtmlContainer

Illustrates building HTML using mutable references and the `add_` methods, suitable for imperative programming and conditional logic. This example shows adding optional content and iterating to add multiple paragraphs.

```Rust
let mut container = HtmlElement::new(HtmlTag::Div);
if true {
    container.add_paragraph("optional content");
}
for i in 0..3 {
    container.add_paragraph(format!("Item: {}", i));
}
assert_eq!(
    container.to_html_string(),
    concat!(
        "<div><p>optional content</p>",
        "<p>Item: 0</p><p>Item: 1</p>",
        "<p>Item: 2</p></div>"
    )
);
```

--------------------------------

### Create Image (Rust)

Source: https://docs.rs/build_html/2.6.0/build_html/struct.HtmlPage

Returns a new HTML container with an `<img>` tag added, including the source URL and alternative text. The `with_image` method is chainable and returns a modified copy of the container. It takes the image source (ToString) and alt text (ToString).

```rust
fn with_image(self, src: impl ToString, alt: impl ToString) -> Self
```

--------------------------------

### Create HtmlElement with Link (Rust)

Source: https://docs.rs/build_html/2.6.0/build_html/trait.HtmlContainer

Demonstrates the fluent API for creating an HTML element and adding an <a> tag using the `with_link` method. This allows for chaining link additions to an HTML element, making HTML string construction more readable and concise.

```Rust
let content = HtmlElement::new(HtmlTag::Div)
    .with_link("https://rust-lang.org/", "Rust Homepage")
    .to_html_string();

assert_eq!(content, r#"<div><a href="https://rust-lang.org/">Rust Homepage</a></div>"#)
```

--------------------------------

### Build Dynamic HTML Elements with HtmlElement

Source: https://docs.rs/build_html/2.6.0/build_html

Demonstrates creating nested HTML elements like divs and paragraphs using the `HtmlElement` and `HtmlTag` types from the `build_html` library. Shows how to chain methods for building complex structures.

```rust
use build_html::{HtmlElement, HtmlTag, Html};

let element = HtmlElement::new(HtmlTag::Div)
    .with_child(
        HtmlElement::new(HtmlTag::ParagraphText)
            .with_child("Paragraph Text".into())
            .into()
    )
    .with_child(
        HtmlElement::new(HtmlTag::PreformattedText)
            .with_child("Preformatted Text".into())
            .into()
    )
    .to_html_string();

assert_eq!(element, "<div><p>Paragraph Text</p><pre>Preformatted Text</pre></div>");
```

--------------------------------

### Create HtmlElement with Image (Rust)

Source: https://docs.rs/build_html/2.6.0/build_html/trait.HtmlContainer

Shows how to create an HTML element and chain the `with_image` method to add an <img> tag. This fluent API approach allows for building HTML structures concisely. It returns the modified HtmlElement.

```Rust
let content = HtmlElement::new(HtmlTag::Div)
    .with_image("myimage.png", "a test image")
    .to_html_string();

assert_eq!(content, r#"<div><img src="myimage.png" alt="a test image"/></div>"#);
```

--------------------------------

### Build HTML Strings with Builder Pattern (Rust)

Source: https://docs.rs/build_html/2.6.0/build_html/index

This snippet demonstrates the core functionality of the build_html crate, which uses a builder pattern to construct HTML strings. It explains how to use HtmlElement for structured creation and HtmlContainer for a more concise, function-based approach. The Html::to_html_string method is used to render the built HTML.

```rust
use build_html::{HtmlElement, HtmlContainer, Html};

// Example using HtmlElement (more flexible)
let mut element = HtmlElement::new("div");
element.add_attribute("class", "container");
let mut paragraph = HtmlElement::new("p");
paragraph.add_text("Hello, world!");
element.add_child(paragraph);

let html_string_element = element.to_html_string();
// html_string_element will be "<div class=\"container\"><p>Hello, world!</p></div>"

// Example using HtmlContainer (less verbose for simple cases)
let html_string_container = HtmlContainer::new("p")
    .add_text("Another paragraph.")
    .to_html_string();
// html_string_container will be "<p>Another paragraph.</p>"

// Escaping untrusted text is important
let untrusted_text = "<script>alert('XSS')</script>";
let escaped_text = build_html::escape_html(untrusted_text);
// escaped_text will be "&lt;script&gt;alert(&#39;XSS&#39;)&lt;/script&gt;"

```

--------------------------------

### Build Full HTML Page with HtmlPage

Source: https://docs.rs/build_html/2.6.0/src/build_html/lib.rs

Illustrates creating a complete HTML page structure including title and body content using the `HtmlPage` struct. It leverages the `HtmlContainer` trait for adding elements like paragraphs and converts the page to an HTML string via `to_html_string`. Requires the `build_html` crate.

```Rust
use build_html::{HtmlPage, Html, HtmlContainer};

let page = HtmlPage::new()
    .with_title("TITLE")
    .with_paragraph("PARAGRAPH")
    .to_html_string();

assert_eq!(page, concat!(
    "<!DOCTYPE html><html>",
    "<head><title>TITLE</title></head>",
    "<body><p>PARAGRAPH</p></body>",
    "</html>"
));

```

--------------------------------

### build_html Crate API Reference

Source: https://docs.rs/build_html/2.6.0/build_html/index

This entry provides an overview of the build_html crate's API, focusing on its primary components and methods for HTML generation. It covers the HtmlElement struct for detailed element construction, the HtmlContainer trait for simpler interfaces, and the Html trait's to_html_string method for rendering. It also mentions the escape_html function for security.

```APIDOC
Crate: build_html
Version: 2.6.0

Core Components:

1.  HtmlElement
    -   Represents an HTML element with attributes and children.
    -   Methods:
        -   `new(tag_name: &str) -> HtmlElement`: Creates a new HTML element with the specified tag name.
        -   `add_attribute(name: &str, value: &str)`: Adds or updates an attribute for the element.
        -   `add_child(child: impl Into<HtmlElement>)`: Adds a child element or text node.
        -   `add_text(text: &str)`: Adds a text node as a child.
        -   `to_html_string() -> String`: Renders the element and its children to an HTML string.

2.  HtmlContainer (Trait)
    -   Provides a less verbose, function-based interface for building HTML.
    -   Implemented by types that can act as HTML containers.
    -   Methods:
        -   `to_html_string() -> String`: Renders the container's content to an HTML string.

3.  Html (Trait)
    -   Defines the common interface for rendering HTML content.
    -   Methods:
        -   `to_html_string() -> String`: The primary method to convert an HTML structure into a String.

Utility Functions:

-   `escape_html(text: &str) -> String`
    -   Escapes special HTML characters (e.g., `<`, `>`, `&`, `'`, `"`) to prevent XSS attacks and ensure correct rendering of user-provided text.
    -   Usage: Recommended for displaying untrusted text within HTML content.

Limitations:

-   Generated strings are unformatted; whitespace is generally preserved.
-   String escaping is not automatic; `escape_html` must be used explicitly for untrusted input.
```

--------------------------------

### HtmlElement Struct and Methods (build_html)

Source: https://docs.rs/build_html/2.6.0/build_html/struct.HtmlElement

Documentation for the HtmlElement struct in the build_html Rust crate. It covers the struct's fields (attributes, children, tag) and its core methods for creating and manipulating HTML elements, including adding attributes and children.

```APIDOC
HtmlElement:
  Represents an HTML element with attributes, children, and a tag.

  Fields:
    attributes: Stores key-value pairs for HTML attributes.
    children: A collection of child elements or text nodes.
    tag: The HTML tag name (e.g., "div", "p").

  Methods:
    new(tag: &str) -> HtmlElement
      Creates a new HtmlElement with the specified tag.

    add_attribute(key: &str, value: &str) -> &mut Self
      Adds or updates an attribute on the element.

    add_child(child: HtmlChild) -> &mut Self
      Appends a child element or text node to the element.

    with_attribute(key: &str, value: &str) -> Self
      Returns a new HtmlElement with the added attribute (immutable style).

    with_child(child: HtmlChild) -> Self
      Returns a new HtmlElement with the appended child (immutable style).

  Trait Implementations:
    Clone: Allows creating copies of HtmlElement.
    Debug: Enables debugging output.
    Display: Allows formatting HtmlElement into a string (HTML output).
    From<HtmlElement> for HtmlChild: Enables conversion for nested elements.
    Html: Provides methods for HTML rendering.
    HtmlContainer: Provides methods for managing child elements.
```

--------------------------------

### build_html Crate API Reference

Source: https://docs.rs/build_html/2.6.0/build_html

This entry provides an overview of the build_html crate's API, focusing on its primary components and methods for HTML generation. It covers the HtmlElement struct for detailed element construction, the HtmlContainer trait for simpler interfaces, and the Html trait's to_html_string method for rendering. It also mentions the escape_html function for security.

```APIDOC
Crate: build_html
Version: 2.6.0

Core Components:

1.  HtmlElement
    -   Represents an HTML element with attributes and children.
    -   Methods:
        -   `new(tag_name: &str) -> HtmlElement`: Creates a new HTML element with the specified tag name.
        -   `add_attribute(name: &str, value: &str)`: Adds or updates an attribute for the element.
        -   `add_child(child: impl Into<HtmlElement>)`: Adds a child element or text node.
        -   `add_text(text: &str)`: Adds a text node as a child.
        -   `to_html_string() -> String`: Renders the element and its children to an HTML string.

2.  HtmlContainer (Trait)
    -   Provides a less verbose, function-based interface for building HTML.
    -   Implemented by types that can act as HTML containers.
    -   Methods:
        -   `to_html_string() -> String`: Renders the container's content to an HTML string.

3.  Html (Trait)
    -   Defines the common interface for rendering HTML content.
    -   Methods:
        -   `to_html_string() -> String`: The primary method to convert an HTML structure into a String.

Utility Functions:

-   `escape_html(text: &str) -> String`
    -   Escapes special HTML characters (e.g., `<`, `>`, `&`, `'`, `"`) to prevent XSS attacks and ensure correct rendering of user-provided text.
    -   Usage: Recommended for displaying untrusted text within HTML content.

Limitations:

-   Generated strings are unformatted; whitespace is generally preserved.
-   String escaping is not automatic; `escape_html` must be used explicitly for untrusted input.
```

--------------------------------

### HtmlContainer: Chaining 'with' Methods and Iterators

Source: https://docs.rs/build_html/2.6.0/src/build_html/html_container.rs

Shows the power of the 'with' API for chaining operations and building content from iterators. It demonstrates creating an ordered list with paragraphs generated from a range.

```rust
use build_html::*;

// Aggregating content
let list_items = (0..3)
    .map(|x| format!("List item {}", x))
    .fold(Container::new(ContainerType::OrderedList), |a, n| a.with_paragraph(n));

// Defining content literally
let content = HtmlElement::new(HtmlTag::Div)
    .with_paragraph("paragraph text")
    .with_container(list_items)
    .to_html_string();

assert_eq!(
    content,
    concat!(
        "<div><p>paragraph text</p><ol>",
        "<li><p>List item 0</p></li>",
        "<li><p>List item 1</p></li>",
        "<li><p>List item 2</p></li></ol></div>"
    )
)
```

--------------------------------

### Build HTML Strings with Builder Pattern (Rust)

Source: https://docs.rs/build_html/2.6.0/build_html

This snippet demonstrates the core functionality of the build_html crate, which uses a builder pattern to construct HTML strings. It explains how to use HtmlElement for structured creation and HtmlContainer for a more concise, function-based approach. The Html::to_html_string method is used to render the built HTML.

```rust
use build_html::{HtmlElement, HtmlContainer, Html};

// Example using HtmlElement (more flexible)
let mut element = HtmlElement::new("div");
element.add_attribute("class", "container");
let mut paragraph = HtmlElement::new("p");
paragraph.add_text("Hello, world!");
element.add_child(paragraph);

let html_string_element = element.to_html_string();
// html_string_element will be "<div class=\"container\"><p>Hello, world!</p></div>"

// Example using HtmlContainer (less verbose for simple cases)
let html_string_container = HtmlContainer::new("p")
    .add_text("Another paragraph.")
    .to_html_string();
// html_string_container will be "<p>Another paragraph.</p>"

// Escaping untrusted text is important
let untrusted_text = "<script>alert('XSS')</script>";
let escaped_text = build_html::escape_html(untrusted_text);
// escaped_text will be "&lt;script&gt;alert(&#39;XSS&#39;)&lt;/script&gt;"

```

--------------------------------

### HtmlPage to_html_string Method

Source: https://docs.rs/build_html/2.6.0/src/build_html/html_page/mod.rs

Implements the `to_html_string` method for `HtmlPage` to render the complete HTML page as a string. It includes the doctype, HTML attributes, head, and body content.

```rust
impl Html for HtmlPage {
    fn to_html_string(&self) -> String {
        format!(
            "{}<html{}><head>{}</head><body>{}</body></html>",
            self.version.doctype(),
            self.version.html_attrs(),
            self.head,
            self.body,
        )
    }
}
```
Tokens:
Raw