mod name;
mod parse;
mod text;
mod utf16;
mod write;
use core::ops::Range;
use std::borrow::Cow;
pub use parse::read;
pub use write::{Edit, NewElement, write};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum Encoding {
Utf8,
ShiftJis,
Utf16Le,
Utf16Be,
}
#[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,
prefix_end: Option<usize>,
namespace: Option<Namespace>,
}
impl Name {
pub fn raw(&self) -> Range<usize> {
self.raw.clone()
}
pub fn prefix(&self) -> Option<Range<usize>> {
self.prefix_end.map(|end| self.raw.start..end)
}
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>>,
decoded: Option<utf16::Decoded>,
}
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 parsed_local_name(&self, name: &Name) -> &[u8] {
match &self.decoded {
Some(decoded) => decoded
.bytes
.get(decoded.decoded_range(name.local()))
.unwrap_or_default(),
None => self.local_name(name),
}
}
pub fn local_name_text(&self, name: &Name) -> Cow<'_, str> {
if let Some(decoded) = &self.decoded {
return String::from_utf8_lossy(
decoded
.bytes
.get(decoded.decoded_range(name.local()))
.unwrap_or_default(),
);
}
match self.encoding {
Encoding::Utf8 => String::from_utf8_lossy(self.local_name(name)),
Encoding::ShiftJis => {
encoding_rs::SHIFT_JIS
.decode_without_bom_handling(self.local_name(name))
.0
}
Encoding::Utf16Le | Encoding::Utf16Be => Cow::Owned(self.text(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.parsed_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))
}
}