Conservez une sécurité 100% Rust tout en débloquant XPath 1.0, les mutations du DOM, la validation XSD et un écosystème d'outils unifié.

Pourquoi évoluer ?

roxmltree est un analyseur XML en lecture seule très apprécié dans la communauté Rust pour son strict respect de #![forbid(unsafe_code)]. Cependant, de nombreux projets se heurtent à ses limites fonctionnelles :

La Limite du Lecture-Seule : roxmltree ne permet pas de modifier des nœuds, d'insérer des éléments enfants, de mettre à jour des attributs ou de sérialiser du XML. oxml propose un DOM en arène générationnelle entièrement mutable.
Absence de XPath 1.0 : roxmltree impose un parcours d'arbre récursif manuel. oxml inclut un moteur XPath 1.0 complet avec fonctions standard et raccourci entier $O(1)$.
Zéro Validation de Schéma : roxmltree vérifie uniquement la bonne formation syntaxique. L'écosystème oxml intègre xmlschema avec 95,2 % de conformité W3C XSD.
Un Véritable Écosystème : oxml propose un binaire CLI (oxml-cli), des liaisons WebAssembly (oxml-wasm), un serveur de langage (oxml-lsp) et un serveur Model Context Protocol pour agents IA (oxml-mcp).

Comparatif des Capacités

Fonctionnalité	`roxmltree`	Écosystème `oxml`	Avantage
Sécurité (`#![forbid(unsafe_code)]`)	Oui	Oui	Garantie identique : zéro bloc unsafe
Mutation de l'Arbre DOM	Non (Lecture seule)	Oui	Arène à recyclage générationnel d'emplacements
Sérialisation et Formatage XML	Non	Oui	Contrôle fin de l'indentation et des balises vides
Moteur XPath 1.0	Non	Oui	13 axes de navigation + fonctions standard
Conformité W3C XML Schema (XSD)	Non	Oui	95,2 % de réussite sur 35 942 tests
Streaming Zéro-Copie	Emprunt de tranches	BorrowedEvent	`Reader::next_borrowed()` sans allocation
Outil en Ligne de Commande (CLI)	Non	Oui	Traitement en flux via `oxml-cli`
Outils pour Agents IA (MCP)	Non	Oui	5 outils MCP pour Claude et Cursor

Migration du Code

1. Analyse du Document et Accès aux Nœuds

Avec roxmltree :

use roxmltree::Document;

let text = "<book id='b1'>Dune</book></library>";
let doc = Document::parse(text)?;

// Parcours manuel obligatoire
for node in doc.descendants() {
    if node.tag_name().name() == "book" {
        assert_eq!(node.attribute("id"), Some("b1"));
        assert_eq!(node.text(), Some("Dune"));
    }
}

Avec oxml :

use oxml::parse;

let text = "<book id='b1'>Dune</book></library>";
let doc = parse(text)?;

// Parcours direct ou requête XPath déclarative
let root = doc.root_element().unwrap();
let book = doc.children(root)[0];

assert_eq!(doc.attribute(book, "id"), Some("b1"));
assert_eq!(doc.text(book), "Dune");

// Ou directement avec XPath 1.0 :
let titles = doc.select("//book[@id='b1']/text()")?;
assert_eq!(titles[0].to_str(&doc), "Dune");

2. Modification de Nœuds et Sérialisation (Impossible avec roxmltree)

roxmltree ne permet aucune modification. Avec oxml :

use oxml::{Document, parse};

let mut doc = parse("")?;
let root = doc.root_element().unwrap();

// Création et ajout d'un élément livre
let book = doc.create_element("book");
doc.set_attribute(book, "id", "b2");
doc.append_child(root, book);

// Ajout du contenu textuel
let text = doc.create_text("Neuromancien");
doc.append_child(book, text);

// Sérialisation du résultat formaté
let output = doc.serialize();
assert!(output.contains("<book id=\"b2\">Neuromancien</book>"));

3. Emprunt en Flux Zéro-Copie

Les deux bibliothèques supportent l'analyse sans allocation. Avec oxml, Reader::next_borrowed() produit des BorrowedEvent<'a> empruntant directement les chaînes depuis le tampon :

use oxml::stream::{BorrowedEvent, Reader};

let mut reader = Reader::new("<items><item id='1'>Data</item></items>")?;
while let Some(event) = reader.next_borrowed()? {
    if let BorrowedEvent::StartElement { name, attributes } = event {
        println!("Élément : {}", name.local);
    }
}

Migration depuis roxmltree vers oxml