use crate::alloc_prelude::*;
use crate::error::{Result, XmlError};
use crate::node::{NodeData, NodeId, NodeKind};
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct Document {
nodes: Vec<NodeData>,
root_id: Option<NodeId>,
prolog_id: Option<NodeId>,
declaration_id: Option<NodeId>,
dtd_id: Option<NodeId>,
}
impl Document {
pub fn new() -> Self {
let mut doc = Self {
nodes: Vec::new(),
root_id: None,
prolog_id: None,
declaration_id: None,
dtd_id: None,
};
let prolog_id = doc.add_node(NodeKind::Prolog);
doc.prolog_id = Some(prolog_id);
let root_id = doc.add_node(NodeKind::Root);
doc.root_id = Some(root_id);
doc
}
pub fn parse_str(xml: &str) -> Result<Self> {
crate::parse(xml)
}
pub fn parse_source(source: &mut dyn babbel_core::io::traits::ISource) -> Result<Self> {
crate::parse_source(source)
}
pub fn stringify_to(&self, dest: &mut dyn babbel_core::io::traits::IDestination) {
crate::stringify_to(self, dest);
}
pub fn get_root_element_name(&self) -> Option<&str> {
self.root_element_id()
.and_then(|id| self.get_node(id))
.map(|n| n.kind.name())
}
pub fn add_node(&mut self, kind: NodeKind) -> NodeId {
assert!(
self.nodes.len() < (NodeId::MAX as usize),
"Document arena capacity exceeded for configured NodeId size"
);
let id = self.nodes.len() as NodeId;
self.nodes.push(NodeData::new(id, kind));
id
}
fn validate_hierarchy(&self, parent_id: NodeId, child_id: NodeId) -> Result<()> {
if parent_id == child_id {
return Err(XmlError::NodeError(
"HierarchyRequestError: Cannot insert a node into itself".into(),
));
}
let mut curr = Some(parent_id);
while let Some(ancestor_id) = curr {
if ancestor_id == child_id {
return Err(XmlError::NodeError(
"HierarchyRequestError: Cannot insert an ancestor node as a child of its descendant".into(),
));
}
curr = self.nodes.get(ancestor_id as usize).and_then(|n| n.parent);
}
Ok(())
}
pub fn append_child(&mut self, parent_id: NodeId, child_id: NodeId) -> Result<()> {
let p_idx = parent_id as usize;
let c_idx = child_id as usize;
if p_idx >= self.nodes.len() || c_idx >= self.nodes.len() {
return Err(XmlError::NodeError("Invalid Node ID".into()));
}
self.validate_hierarchy(parent_id, child_id)?;
if let Some(old_parent) = self.nodes[c_idx].parent {
if old_parent != parent_id {
self.remove_child(old_parent, child_id)?;
}
}
self.nodes[c_idx].parent = Some(parent_id);
if !self.nodes[p_idx].children.contains(&child_id) {
self.nodes[p_idx].children.push(child_id);
}
Ok(())
}
pub fn remove_child(&mut self, parent_id: NodeId, child_id: NodeId) -> Result<NodeId> {
let p_idx = parent_id as usize;
let c_idx = child_id as usize;
if p_idx >= self.nodes.len() || c_idx >= self.nodes.len() {
return Err(XmlError::NodeError("Invalid Node ID".into()));
}
let pos = self.nodes[p_idx]
.children
.iter()
.position(|&id| id == child_id)
.ok_or_else(|| {
XmlError::NodeError(format!(
"Child node {} not found on parent {}",
child_id, parent_id
))
})?;
self.nodes[p_idx].children.remove(pos);
self.nodes[c_idx].parent = None;
Ok(child_id)
}
pub fn insert_before(
&mut self,
parent_id: NodeId,
new_child_id: NodeId,
ref_child_id: NodeId,
) -> Result<()> {
let p_idx = parent_id as usize;
let n_idx = new_child_id as usize;
let r_idx = ref_child_id as usize;
if p_idx >= self.nodes.len() || n_idx >= self.nodes.len() || r_idx >= self.nodes.len() {
return Err(XmlError::NodeError("Invalid Node ID".into()));
}
self.validate_hierarchy(parent_id, new_child_id)?;
if let Some(old_parent) = self.nodes[n_idx].parent {
self.remove_child(old_parent, new_child_id)?;
}
let pos = self.nodes[p_idx]
.children
.iter()
.position(|&id| id == ref_child_id)
.ok_or_else(|| {
XmlError::NodeError(format!(
"Reference child {} not found on parent {}",
ref_child_id, parent_id
))
})?;
self.nodes[p_idx].children.insert(pos, new_child_id);
self.nodes[n_idx].parent = Some(parent_id);
Ok(())
}
pub fn replace_child(
&mut self,
parent_id: NodeId,
new_child_id: NodeId,
old_child_id: NodeId,
) -> Result<NodeId> {
let p_idx = parent_id as usize;
let n_idx = new_child_id as usize;
let o_idx = old_child_id as usize;
if p_idx >= self.nodes.len() || n_idx >= self.nodes.len() || o_idx >= self.nodes.len() {
return Err(XmlError::NodeError("Invalid Node ID".into()));
}
self.validate_hierarchy(parent_id, new_child_id)?;
if let Some(old_parent) = self.nodes[n_idx].parent {
self.remove_child(old_parent, new_child_id)?;
}
let pos = self.nodes[p_idx]
.children
.iter()
.position(|&id| id == old_child_id)
.ok_or_else(|| {
XmlError::NodeError(format!(
"Old child {} not found on parent {}",
old_child_id, parent_id
))
})?;
self.nodes[p_idx].children[pos] = new_child_id;
self.nodes[o_idx].parent = None;
self.nodes[n_idx].parent = Some(parent_id);
Ok(old_child_id)
}
pub fn detach(&mut self, node_id: NodeId) -> Result<()> {
let n_idx = node_id as usize;
if n_idx >= self.nodes.len() {
return Err(XmlError::NodeError("Invalid Node ID".into()));
}
if let Some(parent_id) = self.nodes[n_idx].parent {
self.remove_child(parent_id, node_id)?;
}
Ok(())
}
pub fn remove_node(&mut self, node_id: NodeId) -> Result<()> {
self.detach(node_id)
}
pub fn create_element(&mut self, name: impl Into<Box<str>>) -> NodeId {
self.add_node(NodeKind::Element {
name: name.into(),
attributes: Vec::new(),
})
}
pub fn create_text_node(&mut self, text: impl Into<Box<str>>) -> NodeId {
self.add_node(NodeKind::Text(text.into()))
}
pub fn set_attribute(
&mut self,
elem_id: NodeId,
name: impl Into<Box<str>>,
value: impl Into<Box<str>>,
) -> Result<()> {
let idx = elem_id as usize;
if idx >= self.nodes.len() {
return Err(XmlError::NodeError("Invalid Node ID".into()));
}
if !self.nodes[idx].kind.set_attribute(name, value) {
return Err(XmlError::NodeError(format!(
"Node {} is not an Element",
elem_id
)));
}
Ok(())
}
pub fn remove_attribute(&mut self, elem_id: NodeId, name: &str) -> bool {
let idx = elem_id as usize;
if idx >= self.nodes.len() {
return false;
}
self.nodes[idx].kind.remove_attribute(name)
}
pub fn has_attribute(&self, elem_id: NodeId, name: &str) -> bool {
self.get_attribute(elem_id, name).is_some()
}
pub fn set_text_content(&mut self, node_id: NodeId, text: impl Into<Box<str>>) -> Result<()> {
let idx = node_id as usize;
if idx >= self.nodes.len() {
return Err(XmlError::NodeError("Invalid Node ID".into()));
}
let text_box = text.into();
match &mut self.nodes[idx].kind {
NodeKind::Text(t) | NodeKind::CData(t) | NodeKind::Comment(t) => {
*t = text_box;
Ok(())
}
NodeKind::Element { .. } => {
let old_children = self.nodes[idx].children.clone();
for child_id in old_children {
self.nodes[child_id as usize].parent = None;
}
self.nodes[idx].children.clear();
let text_node_id = self.add_node(NodeKind::Text(text_box));
self.append_child(node_id, text_node_id)?;
Ok(())
}
_ => Err(XmlError::NodeError(
"Cannot set text content on this node type".into(),
)),
}
}
pub fn first_child(&self, id: NodeId) -> Option<NodeId> {
self.get_node(id)?.children.first().copied()
}
pub fn last_child(&self, id: NodeId) -> Option<NodeId> {
self.get_node(id)?.children.last().copied()
}
pub fn next_sibling(&self, id: NodeId) -> Option<NodeId> {
let parent_id = self.parent_id(id)?;
let parent = self.get_node(parent_id)?;
let pos = parent.children.iter().position(|&child| child == id)?;
parent.children.get(pos + 1).copied()
}
pub fn previous_sibling(&self, id: NodeId) -> Option<NodeId> {
let parent_id = self.parent_id(id)?;
let parent = self.get_node(parent_id)?;
let pos = parent.children.iter().position(|&child| child == id)?;
if pos > 0 {
parent.children.get(pos - 1).copied()
} else {
None
}
}
pub fn first_element_child(&self, id: NodeId) -> Option<NodeId> {
self.get_node(id)?
.children
.iter()
.copied()
.find(|&c_id| self.get_node(c_id).map_or(false, |c| c.kind.is_element()))
}
pub fn last_element_child(&self, id: NodeId) -> Option<NodeId> {
self.get_node(id)?
.children
.iter()
.copied()
.rfind(|&c_id| self.get_node(c_id).map_or(false, |c| c.kind.is_element()))
}
pub fn clone_node(&mut self, node_id: NodeId, deep: bool) -> Result<NodeId> {
let idx = node_id as usize;
if idx >= self.nodes.len() {
return Err(XmlError::NodeError("Invalid Node ID".into()));
}
let kind = self.nodes[idx].kind.clone();
let new_id = self.add_node(kind);
if deep {
let children = self.nodes[idx].children.clone();
for child_id in children {
let cloned_child = self.clone_node(child_id, true)?;
self.append_child(new_id, cloned_child)?;
}
}
Ok(new_id)
}
pub fn get_elements_by_tag_name(&self, name: &str) -> Vec<NodeId> {
let mut results = Vec::new();
let match_all = name == "*";
for node in &self.nodes {
if let NodeKind::Element {
name: elem_name, ..
} = &node.kind
{
if match_all || &**elem_name == name {
results.push(node.id);
}
}
}
results
}
pub fn get_element_by_id(&self, id: &str) -> Option<NodeId> {
self.nodes.iter().find_map(|node| {
if node.kind.is_element() && node.kind.get_attribute("id") == Some(id) {
Some(node.id)
} else {
None
}
})
}
pub fn get_prefix(&self, id: NodeId) -> Option<&str> {
let node = self.get_node(id)?;
crate::namespace::QName::split_prefix(node.kind.name()).0
}
pub fn get_local_name(&self, id: NodeId) -> &str {
if let Some(node) = self.get_node(id) {
crate::namespace::QName::split_prefix(node.kind.name()).1
} else {
""
}
}
pub fn get_namespace_uri(&self, id: NodeId) -> Option<String> {
let prefix = self.get_prefix(id);
if let Some(p) = prefix {
if p == "xml" {
return Some("http://www.w3.org/XML/1998/namespace".to_string());
}
if p == "xmlns" {
return Some("http://www.w3.org/2000/xmlns/".to_string());
}
self.lookup_namespace_uri(id, p)
} else {
self.lookup_namespace_uri(id, "")
}
}
pub fn lookup_prefix(&self, id: NodeId, uri: &str) -> Option<String> {
let mut curr = Some(id);
while let Some(nid) = curr {
if let Some(node) = self.get_node(nid) {
if let NodeKind::Element { attributes, .. } = &node.kind {
for attr in attributes {
if &*attr.value == uri {
if let Some(prefix) = attr.name.strip_prefix("xmlns:") {
return Some(prefix.to_string());
} else if &*attr.name == "xmlns" {
return Some(String::new());
}
}
}
}
}
curr = self.parent_id(nid);
}
None
}
pub fn lookup_namespace_uri(&self, id: NodeId, prefix: &str) -> Option<String> {
let mut curr = Some(id);
let target_attr = if prefix.is_empty() {
"xmlns".to_string()
} else {
format!("xmlns:{}", prefix)
};
while let Some(nid) = curr {
if let Some(node) = self.get_node(nid) {
if let NodeKind::Element { attributes, .. } = &node.kind {
for attr in attributes {
if &*attr.name == target_attr {
if attr.value.is_empty() {
return None;
}
return Some(attr.value.to_string());
}
}
}
}
curr = self.parent_id(nid);
}
None
}
pub fn get_elements_by_tag_name_ns(&self, uri: &str, local_name: &str) -> Vec<NodeId> {
let mut results = Vec::new();
let match_any_uri = uri == "*";
let match_any_local = local_name == "*";
for node in &self.nodes {
if node.kind.is_element() {
let elem_local = self.get_local_name(node.id);
let local_matches = match_any_local || elem_local == local_name;
if local_matches {
let elem_uri = self.get_namespace_uri(node.id);
let uri_matches = match_any_uri
|| match (uri, elem_uri.as_deref()) {
("", None) => true,
(u, Some(eu)) => u == eu,
_ => false,
};
if uri_matches {
results.push(node.id);
}
}
}
}
results
}
pub fn compact(&mut self) -> Result<()> {
let mut reachable = vec![false; self.nodes.len()];
let mut stack = Vec::new();
if let Some(r) = self.root_id {
stack.push(r);
}
if let Some(p) = self.prolog_id {
stack.push(p);
}
while let Some(nid) = stack.pop() {
let idx = nid as usize;
if idx < self.nodes.len() && !reachable[idx] {
reachable[idx] = true;
if let Some(node) = self.nodes.get(idx) {
for &child in &node.children {
stack.push(child);
}
}
}
}
let mut id_map = vec![None; self.nodes.len()];
let mut new_nodes = Vec::new();
for (old_idx, &is_reachable) in reachable.iter().enumerate() {
if is_reachable {
if new_nodes.len() >= (NodeId::MAX as usize) {
return Err(XmlError::NodeError(
"Compacted arena exceeds NodeId capacity".into(),
));
}
let new_id = new_nodes.len() as NodeId;
id_map[old_idx] = Some(new_id);
new_nodes.push(self.nodes[old_idx].clone());
}
}
for node in &mut new_nodes {
let old_id = node.id as usize;
if let Some(Some(remapped)) = id_map.get(old_id) {
node.id = *remapped;
}
node.parent = node
.parent
.and_then(|p| id_map.get(p as usize).copied().flatten());
node.children = node
.children
.iter()
.filter_map(|&c| id_map.get(c as usize).copied().flatten())
.collect();
}
self.root_id = self
.root_id
.and_then(|r| id_map.get(r as usize).copied().flatten());
self.prolog_id = self
.prolog_id
.and_then(|p| id_map.get(p as usize).copied().flatten());
self.declaration_id = self
.declaration_id
.and_then(|d| id_map.get(d as usize).copied().flatten());
self.dtd_id = self
.dtd_id
.and_then(|d| id_map.get(d as usize).copied().flatten());
self.nodes = new_nodes;
Ok(())
}
pub fn get_node(&self, id: NodeId) -> Option<&NodeData> {
self.nodes.get(id as usize)
}
pub fn get_node_mut(&mut self, id: NodeId) -> Option<&mut NodeData> {
self.nodes.get_mut(id as usize)
}
pub fn root_id(&self) -> Option<NodeId> {
self.root_id
}
pub fn prolog_id(&self) -> Option<NodeId> {
self.prolog_id
}
pub fn declaration_id(&self) -> Option<NodeId> {
self.declaration_id
}
pub fn set_declaration_id(&mut self, id: NodeId) {
self.declaration_id = Some(id);
}
pub fn dtd_id(&self) -> Option<NodeId> {
self.dtd_id
}
pub fn set_dtd_id(&mut self, id: NodeId) {
self.dtd_id = Some(id);
}
pub fn root_element_id(&self) -> Option<NodeId> {
let root_id = self.root_id?;
let root_node = self.get_node(root_id)?;
for &child_id in &root_node.children {
if let Some(child) = self.get_node(child_id) {
if matches!(child.kind, NodeKind::Element { .. }) {
return Some(child_id);
}
}
}
None
}
pub fn get_children(&self, id: NodeId) -> Vec<NodeId> {
self.get_node(id)
.map(|n| n.children.clone())
.unwrap_or_default()
}
pub fn get_element_children(&self, id: NodeId) -> Vec<NodeId> {
self.get_children(id)
.into_iter()
.filter(|&c_id| {
self.get_node(c_id)
.map_or(false, |c| matches!(c.kind, NodeKind::Element { .. }))
})
.collect()
}
pub fn get_attribute<'a>(&'a self, id: NodeId, attr_name: &str) -> Option<&'a str> {
self.get_node(id)
.and_then(|node| node.kind.get_attribute(attr_name))
}
pub fn parent_id(&self, id: NodeId) -> Option<NodeId> {
self.get_node(id).and_then(|n| n.parent)
}
pub fn get_text_content(&self, id: NodeId) -> String {
let mut text = String::new();
if let Some(node) = self.get_node(id) {
match &node.kind {
NodeKind::Text(t) => text.push_str(t),
_ => {
for &child_id in &node.children {
if let Some(child) = self.get_node(child_id) {
match &child.kind {
NodeKind::Text(t) => text.push_str(t),
NodeKind::Element { .. } => {
text.push_str(&self.get_text_content(child_id))
}
_ => {}
}
}
}
}
}
}
text
}
pub fn nodes(&self) -> &[NodeData] {
&self.nodes
}
pub fn len(&self) -> usize {
self.nodes.len()
}
pub fn is_empty(&self) -> bool {
self.nodes.is_empty()
}
pub fn to_value(&self) -> babbel_core::Value {
if let Some(root_id) = self.root_element_id() {
let name = self
.get_node(root_id)
.map(|n| n.kind.name().to_string())
.unwrap_or_else(|| "xml".into());
let val = self.element_to_value(root_id);
babbel_core::Value::Object(alloc::vec![(name, val)])
} else {
babbel_core::Value::Null
}
}
fn element_to_value(&self, id: NodeId) -> babbel_core::Value {
if let Some(node) = self.get_node(id) {
if let NodeKind::Element { attributes, .. } = &node.kind {
let mut entries = Vec::new();
for attr in attributes {
entries.push((
alloc::format!("@{}", attr.name),
babbel_core::Value::String(attr.value.to_string()),
));
}
let child_elements = self.get_element_children(id);
if child_elements.is_empty() {
let text = self.get_text_content(id);
if !text.is_empty() {
if entries.is_empty() {
return babbel_core::Value::String(text);
} else {
entries.push(("#text".into(), babbel_core::Value::String(text)));
}
}
} else {
for child_id in child_elements {
if let Some(child_node) = self.get_node(child_id) {
let child_val = self.element_to_value(child_id);
entries.push((child_node.kind.name().into(), child_val));
}
}
}
return babbel_core::Value::Object(entries);
}
}
babbel_core::Value::Null
}
#[cfg(feature = "format-converters")]
pub fn to_json(&self, dest: &mut dyn babbel_core::io::IDestination) -> Result<()> {
crate::stringify::converters::to_json(self, dest)
}
#[cfg(feature = "format-converters")]
pub fn to_json_string(&self) -> Result<String> {
crate::stringify::converters::to_json_string(self)
}
#[cfg(feature = "format-converters")]
pub fn to_yaml(&self, dest: &mut dyn babbel_core::io::IDestination) -> Result<()> {
crate::stringify::converters::to_yaml(self, dest)
}
#[cfg(feature = "format-converters")]
pub fn to_yaml_string(&self) -> Result<String> {
crate::stringify::converters::to_yaml_string(self)
}
#[cfg(feature = "format-converters")]
pub fn to_toml(&self, dest: &mut dyn babbel_core::io::IDestination) -> Result<()> {
crate::stringify::converters::to_toml(self, dest)
}
#[cfg(feature = "format-converters")]
pub fn to_toml_string(&self) -> Result<String> {
crate::stringify::converters::to_toml_string(self)
}
#[cfg(feature = "format-converters")]
pub fn to_bencode(&self, dest: &mut dyn babbel_core::io::IDestination) -> Result<()> {
crate::stringify::converters::to_bencode(self, dest)
}
#[cfg(feature = "format-converters")]
pub fn to_bencode_bytes(&self) -> Result<Vec<u8>> {
crate::stringify::converters::to_bencode_bytes(self)
}
}
impl From<&Document> for babbel_core::Value {
fn from(doc: &Document) -> Self {
doc.to_value()
}
}
impl From<Document> for babbel_core::Value {
fn from(doc: Document) -> Self {
doc.to_value()
}
}