xmloxide

Une réimplémentation pure en Rust de libxml2 — la bibliothèque d'analyse XML/HTML de facto standard dans le monde open-source.

libxml2 est officiellement devenu non maintenu en décembre 2025 avec des problèmes de sécurité connus. xmloxide vise à être un remplacement sûr en mémoire et haute performance qui réussit les mêmes suites de tests de conformité.

Fonctionnalités

• Sécurité mémoire — arbre basé sur un arena avec zéro 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 — analyser du XML mal formé et quand même produire un arbre utilisable, tout comme libxml2
• Plusieurs API d'analyse — arbre DOM, streaming SAX2, pull XmlReader, push/incrémentale
• Analyseur HTML — analyse HTML 4.01 tolérante aux erreurs avec fermeture automatique et éléments vides
• Analyseur HTML5 WHATWG — tokeniseur et constructeur d'arbre complets du HTML Living Standard (8810/8810 tests html5lib-tests réussis)
• Streaming HTML5 — API de rappel de type SAX pour HTML5 (html5::sax) qui encapsule le tokeniseur sans construire d'arbre DOM
• Sélecteurs CSS — interroger des éléments avec une syntaxe CSS familière (css::select) incluant combinateurs, pseudo-classes et recherche rapide par #id
• XPath 1.0+ — analyseur et évaluateur d'expressions complet avec toutes les fonctions de base XPath 1.0 plus des fonctions clés XPath 2.0 (matches(), replace(), tokenize(), upper-case(), lower-case(), abs(), min(), max(), et plus)
• Validation — validation DTD, RelaxNG, Schéma XML (XSD) et Schematron ISO (ISO/IEC 19757-3)
• Intégration Serde — fonctionnalité serde optionnelle pour la (dé)sérialisation XML vers/depuis des types Rust
• Analyse asynchrone — fonctionnalité async optionnelle pour analyser à partir de sources tokio::io::AsyncRead
• XML canonique — sérialisation C14N 1.0 et C14N exclusive
• XInclude — traitement d'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 du XML
• Zéro copie quand c'est 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 — seulement encoding_rs (la bibliothèque n'a aucune autre dépendance ; clap est uniquement CLI)

Démarrage rapide

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!("Element: {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"));

Sélecteurs CSS

use xmloxide::css::select;
use xmloxide::Document;

let doc = Document::parse_str(r#"<div><p class="intro">Hello</p><p>World</p></div>"#).unwrap();
let root = doc.root_element().unwrap();
let intros = select(&doc, root, "p.intro").unwrap();
assert_eq!(intros.len(), 1);
assert_eq!(doc.text_content(intros[0]), "Hello");

Analyse HTML5 (WHATWG)

use xmloxide::html5::parse_html5;

let doc = parse_html5("<p>Hello <b>world</b>").unwrap();
let root = doc.root_element().unwrap();
assert_eq!(doc.node_name(root), Some("html"));

L'analyse de fragments (l'algorithme derrière innerHTML) est également prise en charge :

use xmloxide::html5::{parse_html5_with_options, Html5ParseOptions};

let opts = Html5ParseOptions {
    scripting: false,
    fragment_context: Some("body".to_string()),
};
let doc = parse_html5_with_options("<p>fragment</p>", &opts).unwrap();

Streaming HTML5 (type SAX)

use xmloxide::html5::sax::{Html5SaxHandler, parse_html5_sax};

struct LinkExtractor { hrefs: Vec<String> }
impl Html5SaxHandler for LinkExtractor {
    fn start_element(&mut self, name: &str, attrs: &[(String, String)], _sc: bool) {
        if name == "a" {
            if let Some((_, href)) = attrs.iter().find(|(n, _)| n == "href") {
                self.hrefs.push(href.clone());
            }
        }
    }
}

let mut handler = LinkExtractor { hrefs: Vec::new() };
parse_html5_sax(r#"<a href="https://github.com/jonwiggins/xmloxide/blob/main/page">Link</a>"#, &mut handler);
assert_eq!(handler.hrefs, vec!["/page"]);

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

Outil CLI

# Analyser et afficher avec une mise en forme
xmllint --format document.xml

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

# Requête XPath
xmllint --xpath "//title" document.xml

# XML canonique
xmllint --c14n document.xml

# Analyser HTML
xmllint --html page.html

Aperçu des modules