Trabalhando com XML em Rust: bibliotecas para parsing e…

Trabalhando com XML em Rust: visão geral das bibliotecas e exemplos práticos

Rust é uma linguagem de programação de sistemas moderna, cada vez mais usada para criar serviços web de alta carga, ferramentas de linha de comando e sistemas embarcados. Ao trabalhar com dados, surge frequentemente a necessidade de processar documentos XML. Diferente do Python, onde a biblioteca padrão xml.etree.ElementTree cobre a maioria das tarefas, no ecossistema Rust existem várias crates especializadas com abordagens diferentes. Neste artigo, vamos explorar três das ferramentas mais populares para trabalhar com XML em Rust: roxmltree, quick-xml e serde-xml-rs.

1. roxmltree — parser rápido e seguro somente para leitura

roxmltree é uma crate projetada exclusivamente para leitura de XML. Ela não suporta mutação ou criação de documentos, mas oferece um parser muito rápido e confiável com suporte completo a namespaces. A principal vantagem é o trabalho com dados emprestados (zero-copy), o que minimiza a alocação de memória.

// cargo add roxmltreeuse roxmltree::Document;

fn main() -> Result<(), roxmltree::Error> {    let xml = r#"    <root>        <item id="1">Primeiro elemento</item>        <item id="2">Segundo elemento</item>    </root>"#;

    let doc = Document::parse(xml)?;

    // Obtém o elemento raiz    let root = doc.root_element();    println!("Elemento raiz: {}", root.tag_name().name());

    // Procura todos os elementos filhos <item>    for item in root.children().filter(|n| n.has_tag_name("item")) {        let id = item.attribute("id").unwrap_or("unknown");        let text = item.text().unwrap_or("");        println!("ID: {}, Texto: {}", id, text);    }

    Ok(())}

Quando usar: se você precisa apenas ler arquivos XML (configurações, respostas de API, feeds RSS) e a máxima performance é importante. roxmltree é ideal para parsing único.

2. quick-xml — parser universal com suporte a leitura e escrita

quick-xml é a crate mais popular para trabalhar com XML em Rust. Ela suporta tanto parsing (orientado a eventos e estilo DOM) quanto serialização (escrita) de XML. Funciona tanto com streams (Reader) quanto com strings completas. Suporta atributos, CDATA, comentários e sequências de escape.

// cargo add quick-xmluse quick_xml::Reader;use quick_xml::events::Event;

fn main() -> Result<(), quick_xml::Error> {    let xml = r#"<library>    <book genre="rust">Programação em Rust</book>    <book genre="python">Python para iniciantes</book></library>"#;

    let mut reader = Reader::from_str(xml);    reader.trim_text(true);    let mut txt = String::new();    let mut current_genre = String::new();

    loop {        match reader.read_event_into(&mut txt) {            Ok(Event::Start(ref e)) => {                if e.name().as_ref() == b"book" {                    // Obtém o atributo genre                    if let Some(attr) = e.attributes().flatten().find(|a| a.key.as_ref() == b"genre") {                        current_genre = String::from_utf8_lossy(&attr.value).to_string();                    }                }            }            Ok(Event::Text(ref e)) => {                let text = e.unescape()?;                println!("Gênero: {}, Título: {}", current_genre, text);            }            Ok(Event::Eof) => break,            Err(e) => panic!("Erro: {:?}", e),            _ => {}        }        txt.clear();    }    Ok(())}

Quando usar: se você precisa de flexibilidade — ler arquivos grandes de forma streaming, criar novos documentos XML ou