pptx 0.1.0

A Rust library for creating and manipulating PowerPoint (.pptx) files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use crate::opc::constants::content_type as CT;
use crate::opc::constants::relationship_type as RT;
use crate::opc::pack_uri::PackURI;
use crate::opc::part::Part;
use crate::presentation::Presentation;
use crate::repair::*;

#[test]
fn repair_removes_broken_relationship() {
    let mut prs = Presentation::new().unwrap();
    let pres_partname = prs
        .package()
        .part_by_reltype(RT::OFFICE_DOCUMENT)
        .unwrap()
        .partname
        .clone();
    prs.package_mut()
        .part_mut(&pres_partname)
        .unwrap()
        .rels
        .add_relationship(RT::SLIDE, "slides/slideGHOST.xml", false);

    let report = PptxRepairer::repair(&mut prs);
    assert!(!report.issues_found.is_empty());
    let broken_fixed = report
        .issues_fixed
        .iter()
        .filter(|i| i.category == IssueCategory::BrokenRelationship)
        .count();
    assert!(
        broken_fixed >= 1,
        "Expected broken rel fix, got: {:?}",
        report.issues_fixed
    );
}

#[test]
fn repair_removes_orphan_slide_relationship() {
    let mut prs = Presentation::new().unwrap();

    let slide_pn = PackURI::new("/ppt/slides/slide99.xml").unwrap();
    let slide_xml = br#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<p:sld xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main"
       xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
       xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
  <p:cSld><p:spTree><p:nvGrpSpPr><p:cNvPr id="1" name=""/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr/></p:spTree></p:cSld>
</p:sld>"#;
    let slide_part = Part::new(slide_pn, CT::PML_SLIDE, slide_xml.to_vec());
    prs.package_mut().put_part(slide_part);

    let pres_partname = prs
        .package()
        .part_by_reltype(RT::OFFICE_DOCUMENT)
        .unwrap()
        .partname
        .clone();
    prs.package_mut()
        .part_mut(&pres_partname)
        .unwrap()
        .rels
        .add_relationship(RT::SLIDE, "slides/slide99.xml", false);

    let report = PptxRepairer::repair(&mut prs);
    let orphan_fixed = report
        .issues_fixed
        .iter()
        .filter(|i| i.category == IssueCategory::OrphanSlide)
        .count();
    assert!(
        orphan_fixed >= 1,
        "Expected orphan fix, got: {:?}",
        report.issues_fixed
    );
}

#[test]
fn repair_adds_missing_office_document_rel() {
    let mut prs = Presentation::new().unwrap();

    // Remove the officeDocument relationship
    let rid = prs
        .package()
        .pkg_rels
        .iter()
        .find(|r| r.rel_type.as_ref() == RT::OFFICE_DOCUMENT)
        .map(|r| r.r_id.to_string());

    if let Some(rid) = rid {
        prs.package_mut().pkg_rels.remove(&rid);
    }

    let report = PptxRepairer::repair(&mut prs);
    let rel_fixed = report
        .issues_fixed
        .iter()
        .filter(|i| {
            i.category == IssueCategory::BrokenRelationship
                && i.description.contains("officeDocument")
        })
        .count();
    assert!(
        rel_fixed >= 1,
        "Expected officeDocument rel fix, got: {:?}",
        report.issues_fixed
    );
}

#[test]
fn repair_default_presentation_is_noop() {
    let mut prs = Presentation::new().unwrap();
    let report = PptxRepairer::repair(&mut prs);
    assert!(report.issues_found.is_empty());
    assert!(report.issues_fixed.is_empty());
    assert!(report.is_valid);
}

#[test]
fn repair_report_fields_accessible() {
    let report = RepairReport {
        issues_found: vec![],
        issues_fixed: vec![],
        is_valid: true,
    };
    assert!(report.is_valid);
    assert!(report.issues_found.is_empty());
    assert!(report.issues_fixed.is_empty());
}

#[test]
fn repair_after_validate_is_idempotent() {
    let mut prs = Presentation::new().unwrap();

    // Add a broken relationship
    let pres_partname = prs
        .package()
        .part_by_reltype(RT::OFFICE_DOCUMENT)
        .unwrap()
        .partname
        .clone();
    prs.package_mut()
        .part_mut(&pres_partname)
        .unwrap()
        .rels
        .add_relationship(RT::SLIDE, "slides/nonexistent.xml", false);

    // First repair
    let report1 = PptxRepairer::repair(&mut prs);
    assert!(!report1.issues_fixed.is_empty());

    // Second repair should find nothing
    let report2 = PptxRepairer::repair(&mut prs);
    assert!(
        report2.issues_found.is_empty(),
        "Expected clean after first repair, got: {:?}",
        report2.issues_found
    );
    assert!(report2.issues_fixed.is_empty());
    assert!(report2.is_valid);
}