mod parse;
mod text;
use core::ops::Range;
pub use parse::read;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Encoding {
Utf8,
ShiftJis,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Namespace {
Declared(Range<usize>),
Xml,
Xmlns,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Name {
raw: Range<usize>,
local: usize,
namespace: Option<Namespace>,
}
impl Name {
pub fn raw(&self) -> Range<usize> {
self.raw.clone()
}
pub fn prefix(&self) -> Option<Range<usize>> {
(self.local > self.raw.start).then(|| self.raw.start..self.local - 1)
}
pub fn local(&self) -> Range<usize> {
self.local..self.raw.end
}
pub fn namespace(&self) -> Option<&Namespace> {
self.namespace.as_ref()
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Attribute {
name: Name,
value: Range<usize>,
}
impl Attribute {
pub fn name(&self) -> &Name {
&self.name
}
pub fn raw(&self) -> Range<usize> {
self.value.clone()
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Node {
Element(usize),
Text(Range<usize>),
CData(Range<usize>),
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Element {
span: Range<usize>,
name: Name,
attributes: Vec<Attribute>,
children: Vec<Node>,
parent: Option<usize>,
}
impl Element {
pub fn span(&self) -> Range<usize> {
self.span.clone()
}
pub fn name(&self) -> &Name {
&self.name
}
pub fn attributes(&self) -> &[Attribute] {
&self.attributes
}
pub fn children(&self) -> &[Node] {
&self.children
}
pub fn parent(&self) -> Option<usize> {
self.parent
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Document {
src: Vec<u8>,
encoding: Encoding,
elements: Vec<Element>,
doctype: Option<Range<usize>>,
}
impl Document {
pub fn encoding(&self) -> Encoding {
self.encoding
}
pub fn src(&self) -> &[u8] {
&self.src
}
pub fn bytes(&self, range: Range<usize>) -> &[u8] {
self.src.get(range).unwrap_or_default()
}
pub fn root(&self) -> usize {
0
}
pub fn element(&self, index: usize) -> Option<&Element> {
self.elements.get(index)
}
pub fn elements(&self) -> &[Element] {
&self.elements
}
pub fn doctype(&self) -> Option<Range<usize>> {
self.doctype.clone()
}
pub fn local_name(&self, name: &Name) -> &[u8] {
self.bytes(name.local())
}
pub fn namespace(&self, name: &Name) -> Option<String> {
match name.namespace()? {
Namespace::Declared(range) => Some(self.value_of(range.clone())),
Namespace::Xml => Some(String::from("http://www.w3.org/XML/1998/namespace")),
Namespace::Xmlns => Some(String::from("http://www.w3.org/2000/xmlns/")),
}
}
pub fn is(&self, name: &Name, namespace: Option<&str>, local: &[u8]) -> bool {
self.local_name(name) == local && self.namespace(name).as_deref() == namespace
}
pub fn text(&self, range: Range<usize>) -> String {
text::decode(self.encoding, self.bytes(range), text::Mode::Text)
}
pub fn cdata(&self, range: Range<usize>) -> String {
text::decode(self.encoding, self.bytes(range), text::Mode::CData)
}
pub fn value(&self, attribute: &Attribute) -> String {
self.value_of(attribute.raw())
}
fn value_of(&self, range: Range<usize>) -> String {
text::decode(self.encoding, self.bytes(range), text::Mode::Attribute)
}
pub fn attribute<'e>(
&self,
element: &'e Element,
namespace: Option<&str>,
local: &[u8],
) -> Option<&'e Attribute> {
element
.attributes
.iter()
.find(|attribute| self.is(&attribute.name, namespace, local))
}
}