use core::ops::Range;
use crate::{
helpers::{extract_tag_name, find_bytes, skip_whitespace},
xml_declaration::XmlDeclaration,
xml_doctype::XmlDoctype,
};
pub enum PrologNode<'xml> {
Declaration(XmlDeclaration<'xml>),
Doctype(XmlDoctype<'xml>),
Comment(PrologComment<'xml>),
PI(PrologPI<'xml>),
}
#[derive(Clone)]
pub struct PrologComment<'xml> {
xml_text: &'xml str,
range: Range<usize>,
}
impl<'xml> PrologComment<'xml> {
pub fn text(&self) -> &'xml str {
let s = &self.xml_text[self.range.clone()];
s.strip_prefix("<!--")
.and_then(|r| r.strip_suffix("-->"))
.unwrap_or(s)
}
pub fn range(&self) -> Range<usize> {
self.range.clone()
}
}
#[derive(Clone)]
pub struct PrologPI<'xml> {
xml_text: &'xml str,
range: Range<usize>,
}
impl<'xml> PrologPI<'xml> {
pub fn target(&self) -> &'xml str {
extract_tag_name(self.xml_text, self.range.start + 2)
}
pub fn content(&self) -> &'xml str {
let start = self.range.start + 2;
let target = extract_tag_name(self.xml_text, start);
let after_target = start + target.len();
let end = self.range.end.saturating_sub(2); self.xml_text[after_target..end].trim_start_matches(|c: char| c.is_ascii_whitespace())
}
pub fn range(&self) -> Range<usize> {
self.range.clone()
}
}
pub struct XmlProlog<'xml> {
pub(crate) xml_text: &'xml str,
pub(crate) pos: usize,
}
impl<'xml> Iterator for XmlProlog<'xml> {
type Item = PrologNode<'xml>;
fn next(&mut self) -> Option<Self::Item> {
let b = self.xml_text.as_bytes();
self.pos = skip_whitespace(self.xml_text, self.pos);
if self.pos >= b.len() {
return None;
}
if b[self.pos] != b'<' {
return None; }
if b.get(self.pos + 1) == Some(&b'?') {
let end = find_bytes(b, self.pos + 2, b"?>")? + 2;
let range = self.pos..end;
self.pos = end;
let after_q = range.start + 2;
let is_decl = matches!(
b.get(after_q..after_q + 4),
Some([
b'x',
b'm',
b'l',
b' ' | b'\t' | b'\n' | b'\r' | b'?'
])
);
if is_decl {
return Some(PrologNode::Declaration(XmlDeclaration {
xml_text: self.xml_text,
range,
}));
}
return Some(PrologNode::PI(PrologPI {
xml_text: self.xml_text,
range,
}));
}
if b.get(self.pos + 1..self.pos + 4) == Some(b"!--") {
let end = find_bytes(b, self.pos + 4, b"-->")? + 3;
let range = self.pos..end;
self.pos = end;
return Some(PrologNode::Comment(PrologComment {
xml_text: self.xml_text,
range,
}));
}
if b.get(self.pos + 1..self.pos + 9) == Some(b"!DOCTYPE") || b.get(self.pos + 1..self.pos + 9) == Some(b"!doctype") {
let rel = b[self.pos..].iter().position(|&c| c == b'>')?;
let end = self.pos + rel + 1;
let range = self.pos..end;
self.pos = end;
return Some(PrologNode::Doctype(XmlDoctype {
xml_text: self.xml_text,
range,
}));
}
None
}
}
#[cfg(test)]
mod tests {
use super::*;
const fn is_normal<T: Sized + Send + Sync>() {}
#[test]
const fn normal_types() {
is_normal::<PrologComment>();
is_normal::<&PrologComment>();
is_normal::<PrologPI>();
is_normal::<&PrologPI>();
is_normal::<XmlProlog>();
is_normal::<&XmlProlog>();
}
#[test]
fn comment_text_strips_markers() {
let src = "<!-- hello --><root/>";
let c = PrologComment {
xml_text: src,
range: 0..14,
};
assert_eq!(c.text(), " hello ");
assert_eq!(c.range(), 0..14);
}
#[test]
fn pi_target_and_content() {
let src = "<?target some content?><root/>";
let pi = PrologPI {
xml_text: src,
range: 0..23,
};
assert_eq!(pi.target(), "target");
assert_eq!(pi.content(), "some content");
assert_eq!(pi.range(), 0..23);
}
#[test]
fn prolog_empty_when_no_prolog() {
let xml = "<root/>";
let mut iter = XmlProlog { xml_text: xml, pos: 0 };
assert!(iter.next().is_none());
}
#[test]
fn prolog_stops_on_malformed_pi() {
let xml = "<?unclosed<root/>";
let mut iter = XmlProlog { xml_text: xml, pos: 0 };
assert!(iter.next().is_none()); }
}