1mod parse;
10mod text;
11
12use core::ops::Range;
13
14pub use parse::read;
15
16#[derive(Clone, Copy, Debug, PartialEq, Eq)]
18pub enum Encoding {
19 Utf8,
21 ShiftJis,
23}
24
25#[derive(Clone, Debug, PartialEq, Eq)]
27pub enum Namespace {
28 Declared(Range<usize>),
30 Xml,
32 Xmlns,
34}
35
36#[derive(Clone, Debug, PartialEq, Eq)]
38pub struct Name {
39 raw: Range<usize>,
40 local: usize,
41 namespace: Option<Namespace>,
42}
43
44impl Name {
45 pub fn raw(&self) -> Range<usize> {
47 self.raw.clone()
48 }
49
50 pub fn prefix(&self) -> Option<Range<usize>> {
52 (self.local > self.raw.start).then(|| self.raw.start..self.local - 1)
53 }
54
55 pub fn local(&self) -> Range<usize> {
57 self.local..self.raw.end
58 }
59
60 pub fn namespace(&self) -> Option<&Namespace> {
62 self.namespace.as_ref()
63 }
64}
65
66#[derive(Clone, Debug, PartialEq, Eq)]
68pub struct Attribute {
69 name: Name,
70 value: Range<usize>,
71}
72
73impl Attribute {
74 pub fn name(&self) -> &Name {
76 &self.name
77 }
78
79 pub fn raw(&self) -> Range<usize> {
81 self.value.clone()
82 }
83}
84
85#[derive(Clone, Debug, PartialEq, Eq)]
87pub enum Node {
88 Element(usize),
90 Text(Range<usize>),
92 CData(Range<usize>),
94}
95
96#[derive(Clone, Debug, PartialEq, Eq)]
98pub struct Element {
99 span: Range<usize>,
100 name: Name,
101 attributes: Vec<Attribute>,
102 children: Vec<Node>,
103 parent: Option<usize>,
104}
105
106impl Element {
107 pub fn span(&self) -> Range<usize> {
109 self.span.clone()
110 }
111
112 pub fn name(&self) -> &Name {
114 &self.name
115 }
116
117 pub fn attributes(&self) -> &[Attribute] {
119 &self.attributes
120 }
121
122 pub fn children(&self) -> &[Node] {
124 &self.children
125 }
126
127 pub fn parent(&self) -> Option<usize> {
129 self.parent
130 }
131}
132
133#[derive(Clone, Debug, PartialEq, Eq)]
135pub struct Document {
136 src: Vec<u8>,
137 encoding: Encoding,
138 elements: Vec<Element>,
139 doctype: Option<Range<usize>>,
140}
141
142impl Document {
143 pub fn encoding(&self) -> Encoding {
145 self.encoding
146 }
147
148 pub fn src(&self) -> &[u8] {
150 &self.src
151 }
152
153 pub fn bytes(&self, range: Range<usize>) -> &[u8] {
155 self.src.get(range).unwrap_or_default()
156 }
157
158 pub fn root(&self) -> usize {
160 0
161 }
162
163 pub fn element(&self, index: usize) -> Option<&Element> {
165 self.elements.get(index)
166 }
167
168 pub fn elements(&self) -> &[Element] {
170 &self.elements
171 }
172
173 pub fn doctype(&self) -> Option<Range<usize>> {
175 self.doctype.clone()
176 }
177
178 pub fn local_name(&self, name: &Name) -> &[u8] {
180 self.bytes(name.local())
181 }
182
183 pub fn namespace(&self, name: &Name) -> Option<String> {
185 match name.namespace()? {
186 Namespace::Declared(range) => Some(self.value_of(range.clone())),
187 Namespace::Xml => Some(String::from("http://www.w3.org/XML/1998/namespace")),
188 Namespace::Xmlns => Some(String::from("http://www.w3.org/2000/xmlns/")),
189 }
190 }
191
192 pub fn is(&self, name: &Name, namespace: Option<&str>, local: &[u8]) -> bool {
194 self.local_name(name) == local && self.namespace(name).as_deref() == namespace
195 }
196
197 pub fn text(&self, range: Range<usize>) -> String {
200 text::decode(self.encoding, self.bytes(range), text::Mode::Text)
201 }
202
203 pub fn cdata(&self, range: Range<usize>) -> String {
205 text::decode(self.encoding, self.bytes(range), text::Mode::CData)
206 }
207
208 pub fn value(&self, attribute: &Attribute) -> String {
210 self.value_of(attribute.raw())
211 }
212
213 fn value_of(&self, range: Range<usize>) -> String {
214 text::decode(self.encoding, self.bytes(range), text::Mode::Attribute)
215 }
216
217 pub fn attribute<'e>(
219 &self,
220 element: &'e Element,
221 namespace: Option<&str>,
222 local: &[u8],
223 ) -> Option<&'e Attribute> {
224 element
225 .attributes
226 .iter()
227 .find(|attribute| self.is(&attribute.name, namespace, local))
228 }
229}