Qu'est-ce que Xmloxide ?

Xmloxide est une réimplémentation pure en Rust de libxml2, la bibliothèque C largement utilisée pour analyser, créer et manipuler des documents XML et HTML. Le projet a été créé après que libxml2 est devenu officiellement non maintenu en décembre 2025 avec des problèmes de sécurité connus. Le développeur a utilisé Claude Code pour reproduire la bibliothèque en faisant travailler l'agent d'IA sur les suites de tests existantes jusqu'à ce qu'elles soient réussies.

Fonctionnalités et capacités clés

• Sécurisé en mémoire — arbre basé sur une arène avec zéro code unsafe dans l'API publique
• Conforme — taux de réussite de 100 % sur la suite de tests de conformité XML du W3C (1727/1727 tests applicables)
• Récupération d'erreurs — analyse du XML mal formé et production d'un arbre utilisable, comme libxml2
• Plusieurs API d'analyse — arbre DOM, streaming SAX2, extraction XmlReader, push/incrémental
• Analyseur HTML — analyse HTML 4.01 tolérante aux erreurs avec fermeture automatique et éléments vides
• XPath 1.0 — analyseur d'expressions complet et évaluateur avec toutes les fonctions de base
• Validation — validation DTD, RelaxNG et XML Schema (XSD)
• XML canonique — sérialisation C14N 1.0 et C14N exclusive
• XInclude — traitement de l'inclusion de documents
• Catalogues XML — catalogues XML OASIS pour la résolution d'URI
• CLI xmllint — outil en ligne de commande pour analyser, valider et interroger le XML
• Zéro copie quand possible — internement de chaînes pour des comparaisons rapides
• Aucun état global — chaque Document est autonome et Send + Sync
• FFI C/C++ — API C complète avec fichier d'en-tête (include/xmloxide.h) pour intégration dans des projets C/C++
• Dépendances minimales — uniquement encoding_rs (la bibliothèque n'a aucune autre dépendance ; clap est uniquement pour la CLI)

Performance et compatibilité

Les performances sont similaires à celles de libxml2 pour la plupart des opérations d'analyse et meilleures pour la sérialisation. La bibliothèque réussit la suite de compatibilité ainsi que la suite de tests de conformité XML du W3C.

Exemples de code

Analyse de base :

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");

Sérialisation :

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>");

Requêtes 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!("Élément : {name}");
    }
}
parse_sax("<root><child/></root>", &ParseOptions::default(), &mut MyHandler).unwrap();

Analyse 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"));

Récupération d'erreurs :

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);
}

Utilisation de la CLI

L'outil CLI xmllint fournit :

# Analyser et formater joliment
xmllint --format document.xml

Valider par rapport à un schéma
xmllint --schema schema.xsd document.xml
xmllint --relaxng schema.rng document.xml
xmllint --dtdvalid

Contexte de développement avec agent d'IA

Le développeur a expérimenté la reproduction de Redis et SQLite avec Claude Code avant de cibler libxml2. L'approche consistait à charger l'agent d'IA de travailler sur des projets jusqu'à ce que les suites de tests existantes soient réussies. Cela démontre comment les agents de codage peuvent itérer rapidement avec une suite de tests, potentiellement en abordant les problèmes de maintenance du code hérité.