Xml-like formatting

Fast, minimal, feature-rich, xml-like formatting syntax for Rust!

We say xml-like because due to limitations and flexibility some concessions had to be made; see the examples below.

Features include:

• Arbitrary expressions inside the formatting braces
• Generates optimized Rust code at compiletime
• Supports rust-analyzer auto complete, refactoring and more!
• Supports Rust's standard formatting specifiers
• Control flow allows conditional and repeated formatting
• Capture variables by value or by reference
• Escape hatch to inject custom formatting code

In your Cargo.toml, add:

text [dependencies] format_xml = "0.2"

Examples

Basic usage

```rust let point = (20, 30); let name = "World";

let string = format_xml::format! { };

assert_eq!(string, r#""#); ```

The value arguments can be arbitrary expressions. They are inlined in the formatting braces and are outside the string literals.

The values inside formatting braces are escaped by default, the text literals are not. Use the escape hatch to bypass the automatic escaping.

Formatting specifiers

```rust let value = 42;

let string = format_xml::format! { };

assert_eq!(string, r#"0x2a"#); ```

The rules for the specifiers are exactly the same as the standard library of Rust.

Escaping

```rust let value = ""quote""; let text = "";

let string = format_xml::format! {

};

assert_eq!(string, r#"

<script>&</script>

The values inside formatting braces are escaped by default, the text literals are not.

• Text elements escape <, &, >.
• Attribute values escape <, &, >, ', ".
• Comment nodes escape -- by removing it altogether.
• CDATA sections escape ]]>.

Escaping is not implemented in some HTML contexts: inside <script>, <style> tags or their respective attribute equivalents (event lers and inline styles), do not format user controlled values in these locations!

Supported syntax

```rust let string = format_xml::format! {

assert_eq!(string, r#"

Examples of element naming and namespace syntax support:

```rust let string = formatxml::format! { <"t-0.z"> };

assert_eq!(string, r#"<_t-0.z>"#); ```

There are no restrictions on matching open/close tags or reject tags which cannot be self-closing.

Unfinished implementation:

• Document type definitions (DTD) are not correctly implemented. The <!doctype> tag is barely functional.
• Processing instructions are not correctly implemented. The <?xml?> tag is barely functional.

Control flow

```rust let switch = true; let opt = Some("World");

let string = format_xml::format! { if let Some(name) = (opt) {

"Hello "{name}

"Hello User"

assert_eq!(string, "

Hello World

```rust let string: Result = Err(13);

let string = format_xml::format! { match string { Ok(f) => {f}, Err(i) => {i}, } };

assert_eq!(string, "13"); ```

```rust let string = formatxml::format! {

for i in (1..=5) { let timesfive = i * 5;
• {i}"*5="{times_five}
}

assert_eq!(string, "

• 15=5
• 25=10
• 35=15
• 45=20
• 5*5=25

Control flow is only supported outside tags, not in attributes.

Escape hatch

```rust fn compose(f: &mut std::fmt::Formatter, a: i32) -> std::fmt::Result { format_xml::write!(f, {a}) }

let string = format_xml::format! {

|f| compose(f, 42)?;

assert_eq!(string, r#"

42

Closure syntax provides an escape hatch to inject code if needed. The argument's type is &mut Formatter.

Important! Anything written to the formatter f is not escaped. This makes it useful to compose different components wich is not possible with {}.

License

Licensed under MIT License, see license.txt.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, shall be licensed as above, without any additional terms or conditions.