xmloxide

libxml2 का एक शुद्ध Rust पुनःकार्यान्वयन — जो ओपन-सोर्स दुनिया में डी-फैक्टो मानक XML/HTML पार्सिंग लाइब्रेरी है।

libxml2 दिसंबर 2025 में आधिकारिक रूप से अनुरक्षित नहीं रह गया था, जिसमें ज्ञात सुरक्षा समस्याएँ हैं। xmloxide एक मेमोरी-सुरक्षित, उच्च-प्रदर्शन वाला प्रतिस्थापन बनने का लक्ष्य रखता है जो समान अनुरूपता परीक्षण सूट पास करता है।

विशेषताएँ

• मेमोरी-सुरक्षित — सार्वजनिक API में शून्य unsafe के साथ एरेना-आधारित ट्री
• अनुरूप — W3C XML अनुरूपता परीक्षण सूट पर 100% पास दर (1727/1727 लागू परीक्षण)
• त्रुटि पुनर्प्राप्ति — libxml2 की तरह ही दूषित XML को पार्स करें और उपयोगी ट्री प्राप्त करें
• एकाधिक पार्सिंग API — DOM ट्री, SAX2 स्ट्रीमिंग, XmlReader पुल, पुश/इंक्रीमेंटल
• HTML पार्सर — ऑटो-क्लोज़िंग और वॉयड एलिमेंट के साथ त्रुटि-सहिष्णु HTML 4.01 पार्सिंग
• WHATWG HTML5 पार्सर — पूर्ण HTML लिविंग स्टैंडर्ड टोकनाइज़र और ट्री बिल्डर (8810/8810 html5lib-tests पास)
• HTML5 स्ट्रीमिंग — HTML5 (html5::sax) के लिए SAX-जैसी कॉलबैक API जो DOM ट्री बनाए बिना टोकनाइज़र को लपेटती है
• CSS सेलेक्टर — कॉम्बिनेटर, स्यूडो-क्लास और तेज़ #id लुकअप सहित परिचित CSS सिंटैक्स (css::select) से एलिमेंट क्वेरी करें
• XPath 1.0+ — सभी XPath 1.0 कोर फंक्शन और प्रमुख XPath 2.0 फंक्शन (matches(), replace(), tokenize(), upper-case(), lower-case(), abs(), min(), max(), और अधिक) के साथ पूर्ण एक्सप्रेशन पार्सर और मूल्यांकक
• सत्यापन — DTD, RelaxNG, XML स्कीमा (XSD), और ISO Schematron (ISO/IEC 19757-3) सत्यापन
• Serde एकीकरण — वैकल्पिक serde फीचर XML के Rust टाइपों में (डी)सीरियलाइज़ेशन के लिए
• एसिंक पार्सिंग — वैकल्पिक async फीचर tokio::io::AsyncRead स्रोतों से पार्सिंग के लिए
• कैननिकल XML — C14N 1.0 और Exclusive C14N सीरियलाइज़ेशन
• XInclude — दस्तावेज़ समावेशन प्रसंस्करण
• XML कैटलॉग — URI रिज़ॉल्यूशन के लिए OASIS XML कैटलॉग
• xmllint CLI — XML को पार्स करने, सत्यापित करने और क्वेरी करने के लिए कमांड-लाइन टूल
• जहाँ संभव हो जीरो-कॉपी — तेज़ तुलना के लिए स्ट्रिंग इंटर्निंग
• कोई वैश्विक स्थिति नहीं — प्रत्येक Document स्व-निहित और Send + Sync है
• C/C++ FFI — C/C++ प्रोजेक्ट्स में एम्बेड करने के लिए हेडर फ़ाइल (include/xmloxide.h) के साथ पूर्ण C API
• न्यूनतम निर्भरताएँ — केवल encoding_rs (लाइब्रेरी में शून्य अन्य निर्भरताएँ; clap केवल CLI के लिए)

त्वरित प्रारंभ

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

सीरियलाइज़ेशन

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

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

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

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

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

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

फ़्रैगमेंट पार्सिंग (innerHTML के पीछे का एल्गोरिदम) भी समर्थित है:

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

HTML5 स्ट्रीमिंग (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"]);

त्रुटि पुनर्प्राप्ति

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

CLI टूल

# पार्स करें और सुंदर-प्रिंट करें
xmllint --format document.xml

# स्कीमा के विरुद्ध सत्यापित करें
xmllint --schema schema.xsd document.xml
xmllint --relaxng schema.rng document.xml
xmllint --schematron schema.sch document.xml
xmllint --dtdvalid schema.dtd document.xml

# XPath क्वेरी
xmllint --xpath "//title" document.xml

# कैननिकल XML
xmllint --c14n document.xml

# HTML पार्स करें
xmllint --html page.html

मॉड्यूल अवलोकन

मॉड्यूल	विवरण
tree	एरेना-आधारित DOM ट्री (Document, NodeId, NodeKind)
parser	XML 1.0 रिकर्सिव डिसेंट पार्सर त्रुटि पुनर्प्राप्ति के साथ
parser::push	चंक्ड इनपुट के लिए पुश/इंक्रीमेंटल पार्सर
html	त्रुटि-सहिष्णु HTML 4.01 पार्सर
html5	WHATWG HTML लिविंग स्टैंडर्ड पार्सर (टोकनाइज़र + ट्री बिल्डर)
html5::sax	HTML5 के लिए स्ट्रीमिंग SAX-जैसी API (कोई DOM ट्री नहीं बनता)
css	दस्तावेज़ ट्री क्वेरी करने के लिए CSS सेलेक्टर इंजन
sax	SAX2 स्ट्रीमिंग ईवेंट-चालित पार्सर
reader	XmlReader पुल-आधारित पार्सिंग API
serial	XML, HTML, और HTML5 सीरियलाइज़र, साथ ही कैननिकल XML (C14N)
xpath	XPath 1.0+ एक्सप्रेशन पार्सर और मूल्यांकक
validation::dtd	DTD पार्सिंग और सत्यापन
validation::relaxng	RelaxNG स्कीमा सत्यापन
validation::xsd	XML स्कीमा (XSD) सत्यापन
validation::schematron	ISO Schematron नियम-आधारित सत्यापन
serde_xml	Serde XML (डी)सीरियलाइज़ेशन (वैकल्पिक serde फीचर)
async_xml	tokio::io::AsyncRead के माध्यम से एसिंक पार्सिंग (वैकल्पिक async फीचर)
xinclude	XInclude 1.0 दस्तावेज़ समावेशन
catalog	URI रिज़ॉल्यूशन के लिए OASIS XML कैटलॉग
encoding	कैरेक्टर एन्कोडिंग का पता लगाना और ट्रांसकोडिंग
ffi	C/C++ FFI बाइंडिंग (include/xmloxide.h)