Function parse_document_bytes 

pub fn parse_document_bytes(bytes: &[u8]) -> Result<OoxmlPackage, String>

Parses either a DOCX (OOXML zip) or a legacy Word 97-2003 binary .doc file, detected by magic bytes, into the same in-memory package shape.

Examples found in repository

examples/dump_doc_text.rs (line 5)

fn main() {
    let path = std::env::args().nth(1).expect("path");
    let bytes = std::fs::read(&path).expect("read");
    let pkg = if path.ends_with(".doc") {
        rust_docx::parse_document_bytes(&bytes).expect("parse")
    } else {
        rust_docx::parse_docx(&bytes).expect("parse_docx")
    };
    let model = rust_docx::build_doc_model(&pkg);
    print!("{}", text(&model));
}

examples/dump_doc_meta.rs (line 5)

fn main() {
    let path = std::env::args().nth(1).expect("path");
    let bytes = std::fs::read(&path).expect("read");
    let pkg = if path.ends_with(".doc") {
        rust_docx::parse_document_bytes(&bytes).expect("parse")
    } else {
        rust_docx::parse_docx(&bytes).expect("parse_docx")
    };
    let model = rust_docx::build_doc_model(&pkg);
    println!("parts: {}", pkg.parts.len());
    println!("binary assets: {:?}", pkg.binary_assets.keys().collect::<Vec<_>>());
    println!("headers: {}", model.metadata.header_sections.len());
    println!("footers: {}", model.metadata.footer_sections.len());
    println!("numbering: {}", model.metadata.numbering_definitions.is_some());
    println!("footnotes: {:?}", model.metadata.footnotes.as_ref().map(|n| n.len()));
    for h in &model.metadata.header_sections {
        println!("  header {} type={:?} nodes={}", h.part_name, h.reference_type, h.nodes.len());
    }
    println!("warnings: {:?}", &model.metadata.warnings);
}

examples/dump_doc_structure.rs (line 5)

fn main() {
    let path = std::env::args().nth(1).expect("path");
    let bytes = std::fs::read(&path).expect("read");
    let pkg = if path.ends_with(".doc") {
        rust_docx::parse_document_bytes(&bytes).expect("parse")
    } else {
        rust_docx::parse_docx(&bytes).expect("parse_docx")
    };
    let model = rust_docx::build_doc_model(&pkg);
    for (i, node) in model.nodes.iter().enumerate() {
        match node {
            rust_docx::DocNode::Paragraph(p) => {
                let text: String = p.children.iter().filter_map(|c| match c {
                    rust_docx::ParagraphChildNode::Text(r) => Some(r.text.clone()),
                    _ => None,
                }).collect();
                println!("{i:3} P {:?}", &text.chars().take(60).collect::<String>());
            }
            rust_docx::DocNode::Table(t) => {
                println!("{i:3} T rows={} cols(first)={}", t.rows.len(),
                    t.rows.first().map(|r| r.cells.len()).unwrap_or(0));
            }
        }
    }
}

examples/sweep_doc_corpus.rs (line 25)

fn main() {
    let dir = std::env::args().nth(1).expect("dir");
    let mut ok = 0usize;
    let mut failed: Vec<(String, String)> = Vec::new();
    let mut empty: Vec<String> = Vec::new();
    let mut entries: Vec<_> = fs::read_dir(&dir)
        .expect("read dir")
        .filter_map(Result::ok)
        .map(|entry| entry.path())
        .filter(|path| path.extension().map(|ext| ext == "doc").unwrap_or(false))
        .collect();
    entries.sort();
    for path in entries {
        let name = path.file_name().unwrap().to_string_lossy().to_string();
        let bytes = match fs::read(&path) {
            Ok(bytes) => bytes,
            Err(error) => {
                failed.push((name, format!("io: {error}")));
                continue;
            }
        };
        let result = std::panic::catch_unwind(|| {
            let pkg = rust_docx::parse_document_bytes(&bytes)?;
            let model = rust_docx::build_doc_model(&pkg);
            let mut text_len = 0usize;
            let mut tables = 0usize;
            for node in &model.nodes {
                match node {
                    rust_docx::DocNode::Table(_) => tables += 1,
                    rust_docx::DocNode::Paragraph(p) => {
                        for c in &p.children {
                            if let rust_docx::ParagraphChildNode::Text(r) = c {
                                text_len += r.text.len();
                            }
                        }
                    }
                }
            }
            Ok::<(usize, usize, usize), String>((model.nodes.len(), text_len, tables))
        });
        match result {
            Ok(Ok((nodes, text_len, tables))) => {
                ok += 1;
                if text_len == 0 && tables == 0 {
                    empty.push(name.clone());
                }
                println!("OK {name}: nodes={nodes} text={text_len} tables={tables}");
            }
            Ok(Err(error)) => failed.push((name, error)),
            Err(_) => failed.push((name, "PANIC".to_string())),
        }
    }
    println!("\n=== {ok} ok, {} failed, {} empty ===", failed.len(), empty.len());
    for (name, error) in &failed {
        println!("FAIL {name}: {error}");
    }
    for name in &empty {
        println!("EMPTY {name}");
    }
}