O que é Xmloxide?

Xmloxide é uma reimplementação pura em Rust da libxml2, a biblioteca C amplamente usada para analisar, criar e manipular documentos XML e HTML. O projeto foi criado após a libxml2 se tornar oficialmente não mantida em dezembro de 2025, com problemas de segurança conhecidos. O desenvolvedor usou Claude Code para reproduzir a biblioteca, fazendo o agente de IA trabalhar contra suítes de testes existentes até que passassem.

Recursos e Capacidades Principais

• Seguro para memória — árvore baseada em arena sem código inseguro na API pública
• Conforme — taxa de aprovação de 100% na Suíte de Testes de Conformidade XML do W3C (1727/1727 testes aplicáveis)
• Recuperação de erros — analisa XML malformado e ainda produz uma árvore utilizável, assim como a libxml2
• Múltiplas APIs de análise — árvore DOM, streaming SAX2, pull XmlReader, push/incremental
• Analisador HTML — análise tolerante a erros de HTML 4.01 com fechamento automático e elementos vazios
• XPath 1.0 — analisador e avaliador de expressões completo com todas as funções principais
• Validação — validação DTD, RelaxNG e Esquema XML (XSD)
• XML Canônico — serialização C14N 1.0 e C14N Exclusiva
• XInclude — processamento de inclusão de documentos
• Catálogos XML — Catálogos XML OASIS para resolução de URI
• CLI xmllint — ferramenta de linha de comando para analisar, validar e consultar XML
• Zero-cópia sempre que possível — interning de strings para comparações rápidas
• Sem estado global — cada Documento é autônomo e Send + Sync
• FFI C/C++ — API C completa com arquivo de cabeçalho (include/xmloxide.h) para incorporação em projetos C/C++
• Dependências mínimas — apenas encoding_rs (a biblioteca não tem outras dependências; clap é apenas para CLI)

Desempenho e Compatibilidade

O desempenho é semelhante ao da libxml2 na maioria das operações de análise e melhor na serialização. A biblioteca passa na suíte de compatibilidade, bem como na Suíte de Testes de Conformidade XML do W3C.

Exemplos de Código

Análise básica:

use xmloxide::Document;

let doc = Document::parse_str("<root><child>Hello</child></root>").unwrap();
let root = doc.root_element().unwrap();
assert_eq!(doc.node_name(root), Some("root"));
assert_eq!(doc.text_content(root), "Hello");

Serialização:

use xmloxide::Document;
use xmloxide::serial::serialize;

let doc = Document::parse_str("<root><child>Hello</child></root>").unwrap();
let xml = serialize(&doc);
assert_eq!(xml, "<root><child>Hello</child></root>");

Consultas XPath:

use xmloxide::Document;
use xmloxide::xpath::{evaluate, XPathValue};

let doc = Document::parse_str("<library><book><title>Rust</title></book></library>").unwrap();
let root = doc.root_element().unwrap();
let result = evaluate(&doc, root, "count(book)").unwrap();
assert_eq!(result.to_number(), 1.0);

Streaming SAX2:

use xmloxide::sax::{parse_sax, SaxHandler, DefaultHandler};
use xmloxide::parser::ParseOptions;

struct MyHandler;
impl SaxHandler for MyHandler {
    fn start_element(&mut self, name: &str, _: Option<&str>, _: Option<&str>, _: &[(String, String, Option<String>, Option<String>)]) {
        println!("Element: {name}");
    }
}
parse_sax("<root><child/></root>", &ParseOptions::default(), &mut MyHandler).unwrap();

Análise HTML:

use xmloxide::html::parse_html;

let doc = parse_html("<p>Hello <br> World").unwrap();
let root = doc.root_element().unwrap();
assert_eq!(doc.node_name(root), Some("html"));

Recuperação de erros:

use xmloxide::parser::{parse_str_with_options, ParseOptions};

let opts = ParseOptions::default().recover(true);
let doc = parse_str_with_options("<root><unclosed>", &opts).unwrap();
for diag in &doc.diagnostics {
    eprintln!("{}", diag);
}

Uso da CLI

A ferramenta CLI xmllint fornece:

# Analisar e formatar
xmllint --format document.xml

Validar contra um esquema
xmllint --schema schema.xsd document.xml
xmllint --relaxng schema.rng document.xml
xmllint --dtdvalid

Contexto de Desenvolvimento com Agente de IA

O desenvolvedor experimentou fazer o Claude Code reproduzir Redis e SQLite antes de mirar na libxml2. A abordagem envolvia designar ao agente de IA trabalhar em projetos até que as suítes de testes existentes fossem aprovadas. Isso demonstra como agentes de codificação podem iterar rapidamente, dada uma suíte de testes, potencialmente abordando problemas de manutenção de código legado.