use crate::workbook::preserved::{
merge_relationships, rewrite_relationship_ids, GeneratedRelationship, PreservedParts,
};
use crate::xml::functions::{fromstring, Element};
use std::collections::BTreeMap;
use std::io::Write;
const FALLBACK_XML_TYPE: &str = "application/xml";
const CONTENT_TYPES_NS: &str = "http://schemas.openxmlformats.org/package/2006/content-types";
const RELATIONSHIPS_NS: &str = "http://schemas.openxmlformats.org/package/2006/relationships";
fn local_name(tag: &str) -> Option<&str> {
tag.rsplit_once('}').map(|(_, local)| local)
}
pub fn merge_content_types(generated: &str, preserved: &PreservedParts) -> String {
if preserved.content_types().is_empty() && preserved.untyped_part_paths().is_empty() {
return generated.to_string();
}
let Ok(mut root) = fromstring(generated.as_bytes()) else {
return generated.to_string();
};
let mut have_extensions: Vec<String> = Vec::new();
let mut have_parts: Vec<String> = Vec::new();
for child in root.children() {
match local_name(&child.tag) {
Some("Default") => {
if let Some(extension) = child.get("Extension") {
have_extensions.push(extension.to_lowercase());
}
}
Some("Override") => {
if let Some(part) = child.get("PartName") {
have_parts.push(part.trim_start_matches('/').to_string());
}
}
_ => {}
}
}
for entry in preserved.content_types() {
if entry.kind == "Default" {
if !have_extensions.contains(&entry.name.to_lowercase()) {
have_extensions.push(entry.name.to_lowercase());
root.append(content_type_element(
"Default",
"Extension",
entry.name.clone(),
entry.content_type.clone(),
));
}
} else {
let part = entry.name.trim_start_matches('/').to_string();
if !have_parts.contains(&part) {
have_parts.push(part);
root.append(content_type_element(
"Override",
"PartName",
entry.name.clone(),
entry.content_type.clone(),
));
}
}
}
for path in preserved.parts().keys() {
if have_parts.iter().any(|part| part == path) {
continue;
}
let extension = path.rsplit('.').next().unwrap_or_default().to_lowercase();
if have_extensions.contains(&extension) {
continue;
}
have_parts.push(path.clone());
root.append(content_type_element(
"Override",
"PartName",
format!("/{path}"),
FALLBACK_XML_TYPE.to_string(),
));
}
root.to_pretty_string()
}
fn content_type_element(
element: &str,
key_attribute: &str,
name: String,
content_type: String,
) -> Element {
Element::with_attributes(
format!("{{{CONTENT_TYPES_NS}}}{element}"),
[("ContentType", content_type), (key_attribute, name)],
)
}
pub fn merge_rels(
generated: &str,
preserved: &PreservedParts,
rels_path: &str,
) -> (String, BTreeMap<String, String>) {
let Some(preserved_rels) = preserved.relationships(rels_path) else {
return (generated.to_string(), BTreeMap::new());
};
let Ok(root) = fromstring(generated.as_bytes()) else {
return (generated.to_string(), BTreeMap::new());
};
let mut own: Vec<GeneratedRelationship> = Vec::new();
for child in root.children() {
if local_name(&child.tag) != Some("Relationship") {
continue;
}
let (Some(id), Some(kind), Some(target)) =
(child.get("Id"), child.get("Type"), child.get("Target"))
else {
continue;
};
own.push(GeneratedRelationship {
id: id.to_string(),
relationship_type: kind.to_string(),
target: target.to_string(),
target_mode: child.get("TargetMode").map(|mode| mode.to_string()),
});
}
let merged = merge_relationships(&own, preserved_rels, rels_path);
(rels_document(&merged.relationships), merged.id_map)
}
pub fn rels_from_preserved(preserved: &PreservedParts, rels_path: &str) -> Option<String> {
let preserved_rels = preserved.relationships(rels_path)?;
if preserved_rels.is_empty() {
return None;
}
let merged = merge_relationships(&[], preserved_rels, rels_path);
Some(rels_document(&merged.relationships))
}
fn rels_document(relationships: &[GeneratedRelationship]) -> String {
let mut root = Element::new(format!("{{{RELATIONSHIPS_NS}}}Relationships"));
for entry in relationships {
root.append(Element::with_attributes(
format!("{{{RELATIONSHIPS_NS}}}Relationship"),
entry.to_attributes(),
));
}
root.to_pretty_string()
}
fn closing_tag_offset(xml: &str, element: &str) -> Option<usize> {
let mut found = None;
let mut at = 0usize;
while let Some(offset) = xml[at..].find("</") {
let start = at + offset;
let end = xml[start..].find('>')? + start + 1;
let name = &xml[start + 2..end - 1];
let name = name
.rsplit_once(':')
.map(|(_, local)| local)
.unwrap_or(name);
let name = name
.rsplit_once('}')
.map(|(_, local)| local)
.unwrap_or(name);
if name == element {
found = Some(start);
}
at = end;
}
found
}
pub fn append_children(
generated: &str,
element: &str,
children: &[Element],
id_map: &BTreeMap<String, String>,
) -> String {
if children.is_empty() {
return generated.to_string();
}
let Some(at) = closing_tag_offset(generated, element) else {
return generated.to_string();
};
let rendered: Vec<String> = children
.iter()
.map(|child| {
let mut owned = child.clone();
rewrite_relationship_ids(&mut owned, id_map);
owned.to_pretty_string()
})
.collect();
format!(
"{}{}{}",
&generated[..at],
rendered.join("\n"),
&generated[at..]
)
}
pub fn write_parts(
archive: &mut zip::ZipWriter<std::io::Cursor<Vec<u8>>>,
preserved: &PreservedParts,
) -> crate::exceptions::Result<()> {
for (path, data) in preserved.parts() {
if path.ends_with(".rels") {
continue;
}
write_entry(archive, path, data)?;
}
write_preserved_rels(archive, preserved)
}
fn write_preserved_rels(
archive: &mut zip::ZipWriter<std::io::Cursor<Vec<u8>>>,
preserved: &PreservedParts,
) -> crate::exceptions::Result<()> {
for rels_path in preserved.all_relationships().keys() {
let owner = crate::reader::preserved::part_for_rels(rels_path);
if preserved.part(&owner).is_none() {
continue;
}
let Some(document) = rels_from_preserved(preserved, rels_path) else {
continue;
};
write_entry(archive, rels_path, document.as_bytes())?;
}
Ok(())
}
fn write_entry(
archive: &mut zip::ZipWriter<std::io::Cursor<Vec<u8>>>,
path: &str,
data: &[u8],
) -> crate::exceptions::Result<()> {
use crate::exceptions::Error;
archive
.start_file(
path,
zip::write::SimpleFileOptions::default()
.compression_method(zip::CompressionMethod::Deflated),
)
.map_err(|error| Error::Io(error.to_string()))?;
archive
.write_all(data)
.map_err(|error| Error::Io(error.to_string()))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::workbook::preserved::{PreservedContentType, PreservedRelationship};
const GENERATED_TYPES: &str = r#"<?xml version="1.0"?>
<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
<Default Extension="xml" ContentType="application/xml"/>
<Override PartName="/xl/styles.xml" ContentType="application/vnd.ms-excel.styles"/>
<Override PartName="/xl/theme/theme1.xml" ContentType="application/vnd.ms-theme"/>
</Types>"#;
fn preserved_with_a_pivot_table() -> PreservedParts {
let mut preserved = PreservedParts::default();
preserved.add_content_type(PreservedContentType {
kind: "Override".to_string(),
name: "/xl/pivotTables/pivotTable1.xml".to_string(),
content_type: "application/vnd.ms-pivotTable".to_string(),
});
preserved.add_part("xl/pivotTables/pivotTable1.xml", b"<p/>".to_vec());
preserved
}
fn declares(merged: &str, part: &str, content_type: &str) -> bool {
let Ok(root) = fromstring(merged.as_bytes()) else {
return false;
};
root.children().iter().any(|child| {
let name = child
.get("PartName")
.or_else(|| child.get("Extension"))
.unwrap_or_default();
name.trim_start_matches('/') == part.trim_start_matches('/')
&& child.get("ContentType") == Some(content_type)
})
}
#[test]
fn a_preserved_part_gets_a_content_type_it_otherwise_would_not_have() {
let merged = merge_content_types(GENERATED_TYPES, &preserved_with_a_pivot_table());
assert!(
declares(
&merged,
"/xl/pivotTables/pivotTable1.xml",
"application/vnd.ms-pivotTable"
),
"the pivot table is now declared: {merged}"
);
}
#[test]
fn the_generated_declarations_are_left_alone() {
let mut preserved = PreservedParts::default();
preserved.add_content_type(PreservedContentType {
kind: "Override".to_string(),
name: "/xl/styles.xml".to_string(),
content_type: "application/wrong".to_string(),
});
let merged = merge_content_types(GENERATED_TYPES, &preserved);
assert!(
!declares(&merged, "/xl/styles.xml", "application/wrong"),
"a second, conflicting declaration was added: {merged}"
);
}
#[test]
fn a_part_with_no_declaration_anywhere_still_gets_one() {
let mut preserved = PreservedParts::default();
preserved.add_part("xl/queryTables/cache1.dat", b"<c/>".to_vec());
let merged = merge_content_types(GENERATED_TYPES, &preserved);
assert!(
declares(&merged, "/xl/queryTables/cache1.dat", FALLBACK_XML_TYPE),
"a part with no declared type is a package Excel refuses: {merged}"
);
}
#[test]
fn a_colliding_relationship_id_is_moved_and_the_reference_rewritten() {
let mut preserved = PreservedParts::default();
preserved.add_relationships(
"xl/_rels/workbook.xml.rels",
vec![PreservedRelationship::internal(
"rId1",
"t/pivotCacheDefinition",
"pivotCache/pivotCacheDefinition1.xml",
)],
);
let generated = r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
<Relationship Id="rId1" Type="t/sheet" Target="worksheets/sheet1.xml"/>
</Relationships>"#;
let (merged, id_map) = merge_rels(generated, &preserved, "xl/_rels/workbook.xml.rels");
assert_eq!(id_map.get("rId1").map(String::as_str), Some("rId2"));
assert!(
merged.contains("pivotCache/pivotCacheDefinition1.xml"),
"{merged}"
);
assert_eq!(
merged.matches("Id=\"rId1\"").count(),
1,
"one rId1, not two: {merged}"
);
}
#[test]
fn a_preserved_child_is_appended_before_a_closing_tag_with_a_prefix() {
let generated = "<ns0:workbook xmlns:ns0=\"urn:x\"><ns0:sheets/></ns0:workbook>";
let child = Element::new("pivotCaches");
let appended = append_children(
generated,
"workbook",
std::slice::from_ref(&child),
&BTreeMap::new(),
);
assert!(
appended.contains("pivotCaches") && appended.trim_end().ends_with("</ns0:workbook>"),
"{appended}"
);
}
#[test]
fn a_preserved_child_is_appended_before_the_closing_tag() {
let generated = "<worksheet><sheetData/></worksheet>";
let child = Element::new("pivotTableParts");
let appended = append_children(
generated,
"worksheet",
std::slice::from_ref(&child),
&BTreeMap::new(),
);
assert_eq!(
appended.trim(),
"<worksheet><sheetData/><pivotTableParts/></worksheet>",
"and it lands inside the element, not after it"
);
}
#[test]
fn a_generated_part_without_its_closing_tag_is_returned_unchanged() {
let generated = "<worksheet><sheetData/>";
let child = Element::new("pivotTableParts");
let appended = append_children(
generated,
"</worksheet>",
std::slice::from_ref(&child),
&BTreeMap::new(),
);
assert_eq!(appended, generated);
}
#[test]
fn a_sheet_whose_only_relationship_is_preserved_still_gets_a_rels_part() {
let mut preserved = PreservedParts::default();
preserved.add_relationships(
"xl/worksheets/_rels/sheet1.xml.rels",
vec![PreservedRelationship::internal(
"rId1",
"t/pivotTable",
"../pivotTables/pivotTable1.xml",
)],
);
let rels = rels_from_preserved(&preserved, "xl/worksheets/_rels/sheet1.xml.rels")
.expect("the relationship still gets a part");
assert!(rels.contains("../pivotTables/pivotTable1.xml"), "{rels}");
}
#[test]
fn nothing_preserved_means_nothing_changes() {
let preserved = PreservedParts::default();
assert_eq!(
merge_content_types(GENERATED_TYPES, &preserved),
GENERATED_TYPES
);
let (merged, map) = merge_rels(GENERATED_TYPES, &preserved, "xl/_rels/workbook.xml.rels");
assert_eq!(merged, GENERATED_TYPES);
assert!(map.is_empty());
}
}