HTML Tag

HTML Tag, the enigmatic way to write HTML in your Rust code.

What is it?

HTML Tag is a wrapper struct that allows you to write HTML in your Rust code. It essentially removes the use of raw strings or the need to use macros such as the html! macro from the html crate to return a String of HTML.

Why?

When I was experimenting with the HTMX library, I found that I was writing a lot of raw HTML strings in my Rust code.

Stuff like this

find_files(&search.q).iter().for_each(|x| {
        html += format!("<p><a class='link' href='/assets/{}'>{}</a></p>", x, x).as_str();
});

was not very readable and was prone to errors. Hence I wanted to find a way to write HTML in my Rust code in a more readable and debug-able way.

Enter HTML Tag.

Using HTML Tag, the above code can be written as

html = HtmlTag::new("div");
find_files(&search.q).iter().for_each(|x| {
    let mut tag = HtmlTag::new("p")
        .add_child(HtmlTag::new("a")
        .add_class("link")
        .set_href(format!("/assets/{}", x))
        .set_body(x));
    html += tag.to_string();
});

How to use it?

HTML Tag is very simple to use. Basically, you create a new HtmlTag struct with the tag name as the argument. Then you can add attributes to the tag using the add_attribute method. However, for the common attributes and classes, there are methods that you can use to add them.

You can go through the documentation for more information.

When to use it?

First up, html_tag is not a replacement for the html! macro from the html crate. It is more of a wrapper struct that allows you to write HTML in your Rust code.

You can use it when you want to write HTML in your Rust code, especially when you are dealing with HATEOAS APIs.

If you want full HTML generation you are better off using something like html_builder

Moreover, this also means that you can have modular control of the html string that you are generating.

Hence, you can do something like this for example

let mut html = HtmlTag::new("div");
let interested = true
if interested {
    html.with_child(HtmlTag::new("p").with_body("I am interested"));
} else {
    html.with_child(HtmlTag::new("p").with_body("I am not interested"));
}

This is a very simple example, but you can see how you can have modular control over the HTML string that you are generating.

How to contribute?

If you have any ideas on how to improve this crate, feel free to open an issue or a pull request.

I am a complete noob when it comes to Rust and especially when it comes to writing crates that are well optimised and well documented. So any help is appreciated.

Some areas that I would like to improve on are

• Make the crate more memory efficient
• Make the crate more performant
• Improve the documentation
• Add more examples

Any of the above or any other improvements are welcome.

License

This crate is licensed under the MIT License. You can read the license here.