legacy.rs

//! 旧形式 (.xls、.doc、.ppt) を読むところ
//!
//! 試すファイルは、複合ファイルの容れ物ごとこの中で組み立てる。
//! 出来合いのバイナリを持ち込まずに済み、どんな中身を試しているかも読んで分かる。

use folio::book::Book;
use folio::cell::Value;
use folio::document::Document;
use folio::presentation::Presentation;
use std::path::PathBuf;


/// セクタの大きさ
const SECTOR: usize = 512;

/// これより小さいストリームはミニストリームに入る
const CUTOFF: usize = 4096;

/// ミニストリームの 1 かたまり
const MINI: usize = 64;

/// つながりの終わり
const END: u32 = 0xfffffffe;

/// 使っていないセクタ
const FREE: u32 = 0xffffffff;

/// 表そのものが載っているセクタ
const TABLE: u32 = 0xfffffffd;


/// 試しに使うファイルの置き場。target の下なので消えても差し支えない
fn place(name: &str) -> PathBuf {
    let mut path = PathBuf::from("target");
    path.push(format!("legacy-{name}"));
    path
}


/// 複合ファイルを組み立てる
///
/// 4096 バイトに満たないストリームはミニストリームへ入れる。実物と同じ置き方にして、
/// 読む側のミニ FAT の道も試す。
fn compound(stream: &[(&str, Vec<u8>)]) -> Vec<u8> {
    let mut mini_body = Vec::new();
    let mut mini_at = Vec::new();

    for (name, data) in stream {
        if data.len() < CUTOFF {
            mini_at.push((*name, mini_body.len() / MINI, data.len()));
            mini_body.extend_from_slice(data);
            mini_body.resize(mini_body.len().div_ceil(MINI) * MINI, 0);
        }
    }

    let mut mini_fat = vec![FREE; mini_body.len() / MINI];

    for (_, start, size) in &mini_at {
        let count = (size.div_ceil(MINI)).max(1);

        for index in 0..count {
            mini_fat[start + index] = if index + 1 == count {END} else {(start + index + 1) as u32};
        }
    }

    let mut plan: Vec<(String, Vec<u8>)> = Vec::new();

    if !mini_body.is_empty() {
        plan.push(("mini".to_string(), pad(mini_body.clone())));
    }

    if !mini_fat.is_empty() {
        let raw = mini_fat.iter().flat_map(|one| one.to_le_bytes()).collect();
        plan.push(("minifat".to_string(), pad(raw)));
    }

    for (name, data) in stream {
        if data.len() >= CUTOFF {
            plan.push((name.to_string(), pad(data.clone())));
        }
    }

    let directory_size = pad_length((stream.len() + 1) * 128);
    let data_sectors: usize = plan.iter().map(|(_, data)| data.len() / SECTOR).sum::<usize>()
        + directory_size / SECTOR;
    let mut fat_sectors = 1;

    loop {
        let need = (data_sectors + fat_sectors).div_ceil(SECTOR / 4);

        if need <= fat_sectors {
            break;
        }

        fat_sectors = need;
    }

    let mut fat = vec![TABLE; fat_sectors];
    let mut at = fat_sectors;
    let mut where_at = Vec::new();

    for (name, data) in &plan {
        let count = data.len() / SECTOR;
        where_at.push((name.clone(), at));

        for index in 0..count {
            fat.push(if index + 1 == count {END} else {(at + index + 1) as u32});
        }

        at += count;
    }

    let directory_start = at;
    let count = directory_size / SECTOR;

    for index in 0..count {
        fat.push(if index + 1 == count {END} else {(at + index + 1) as u32});
    }

    fat.resize(fat_sectors * (SECTOR / 4), FREE);
    let find = |want: &str| where_at.iter().find(|(name, _)| name == want).map(|(_, at)| *at);

    let mut directory = entry("Root Entry", 5, find("mini").unwrap_or(0) as u32, mini_body.len() as u64, FREE, 1);

    for (index, (name, data)) in stream.iter().enumerate() {
        let right = if index + 1 < stream.len() {(index + 2) as u32} else {FREE};

        let start = match mini_at.iter().find(|(one, _, _)| one == name) {
            Some((_, at, _)) => *at as u32,
            None => find(name).unwrap_or(0) as u32,
        };

        directory.extend_from_slice(&entry(name, 2, start, data.len() as u64, right, FREE));
    }

    directory.resize(directory_size, 0);

    let mut header = vec![0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
    header.resize(24, 0);
    header.extend_from_slice(&0x003eu16.to_le_bytes());
    header.extend_from_slice(&3u16.to_le_bytes());
    header.extend_from_slice(&0xfffeu16.to_le_bytes());
    header.extend_from_slice(&9u16.to_le_bytes());
    header.extend_from_slice(&6u16.to_le_bytes());
    header.resize(40, 0);
    header.extend_from_slice(&0u32.to_le_bytes());
    header.extend_from_slice(&(fat_sectors as u32).to_le_bytes());
    header.extend_from_slice(&(directory_start as u32).to_le_bytes());
    header.extend_from_slice(&0u32.to_le_bytes());
    header.extend_from_slice(&(CUTOFF as u32).to_le_bytes());
    header.extend_from_slice(&(find("minifat").map(|one| one as u32).unwrap_or(END)).to_le_bytes());
    header.extend_from_slice(&(if mini_fat.is_empty() {0u32} else {1}).to_le_bytes());
    header.extend_from_slice(&END.to_le_bytes());
    header.extend_from_slice(&0u32.to_le_bytes());

    for index in 0..109 {
        header.extend_from_slice(&(if index < fat_sectors {index as u32} else {FREE}).to_le_bytes());
    }

    let mut result = header;

    for one in &fat {
        result.extend_from_slice(&one.to_le_bytes());
    }

    for (_, data) in &plan {
        result.extend_from_slice(data);
    }

    result.extend_from_slice(&directory);
    result
}


/// ディレクトリの 1 項目
fn entry(name: &str, kind: u8, start: u32, size: u64, right: u32, child: u32) -> Vec<u8> {
    let mut raw: Vec<u8> = name.encode_utf16().flat_map(|one| one.to_le_bytes()).collect();
    raw.extend_from_slice(&[0, 0]);
    let length = raw.len();
    raw.resize(64, 0);
    raw.extend_from_slice(&(length as u16).to_le_bytes());
    raw.push(kind);
    raw.push(1);
    raw.extend_from_slice(&FREE.to_le_bytes());
    raw.extend_from_slice(&right.to_le_bytes());
    raw.extend_from_slice(&child.to_le_bytes());
    raw.resize(116, 0);
    raw.extend_from_slice(&start.to_le_bytes());
    raw.extend_from_slice(&size.to_le_bytes());
    raw
}


/// セクタの大きさにそろえる
fn pad(mut data: Vec<u8>) -> Vec<u8> {
    let size = pad_length(data.len());
    data.resize(size, 0);
    data
}


/// セクタの大きさにそろえた長さ
fn pad_length(size: usize) -> usize {
    size.div_ceil(SECTOR) * SECTOR
}


/// BIFF のレコード
fn biff(kind: u16, payload: &[u8]) -> Vec<u8> {
    let mut result = kind.to_le_bytes().to_vec();
    result.extend_from_slice(&(payload.len() as u16).to_le_bytes());
    result.extend_from_slice(payload);
    result
}


/// BIFF の 2 バイト長の文字列
fn biff_text(text: &str) -> Vec<u8> {
    let unit: Vec<u16> = text.encode_utf16().collect();
    let mut result = (unit.len() as u16).to_le_bytes().to_vec();
    result.push(1);

    for one in unit {
        result.extend_from_slice(&one.to_le_bytes());
    }

    result
}


/// BIFF の 1 バイト長の文字列
fn biff_short(text: &str) -> Vec<u8> {
    let unit: Vec<u16> = text.encode_utf16().collect();
    let mut result = vec![unit.len() as u8, 1];

    for one in unit {
        result.extend_from_slice(&one.to_le_bytes());
    }

    result
}


/// セルのレコードの頭
fn at(row: u16, column: u16, style: u16) -> Vec<u8> {
    let mut result = row.to_le_bytes().to_vec();
    result.extend_from_slice(&column.to_le_bytes());
    result.extend_from_slice(&style.to_le_bytes());
    result
}


#[test]
fn a_legacy_book_comes_back_with_its_values() {
    let path = place("book.xls");

    let mut shared = 0u32.to_le_bytes().to_vec();
    shared.extend_from_slice(&3u32.to_le_bytes());
    shared[0..4].copy_from_slice(&3u32.to_le_bytes());
    shared.extend_from_slice(&biff_text("名前"));
    shared.extend_from_slice(&biff_text("記号 <&>\"'"));
    shared.extend_from_slice(&biff_text("あ"));

    let mut sheet = biff(0x0809, &[0x00, 0x06, 0x10, 0x00]);
    // 1 行目。共有文字列と数
    sheet.extend_from_slice(&biff(0x00fd, &[at(0, 0, 0), 0u32.to_le_bytes().to_vec()].concat()));
    sheet.extend_from_slice(&biff(0x0203, &[at(0, 1, 0), 3.5f64.to_le_bytes().to_vec()].concat()));
    // 2 行目。縮めた数と真偽とエラー
    sheet.extend_from_slice(&biff(0x027e, &[at(1, 0, 0), ((100i32 << 2) | 2).to_le_bytes().to_vec()].concat()));
    sheet.extend_from_slice(&biff(0x0205, &[at(1, 1, 0), vec![1, 0]].concat()));
    sheet.extend_from_slice(&biff(0x0205, &[at(1, 2, 0), vec![0x2a, 1]].concat()));
    // 3 行目。並んだ数と、日付の書式を付けた数
    let mut multi = at(2, 0, 0)[..4].to_vec();
    multi.extend_from_slice(&1u16.to_le_bytes());
    multi.extend_from_slice(&(((5i32 << 2) | 2) as u32).to_le_bytes());
    multi.extend_from_slice(&1u16.to_le_bytes());
    multi.extend_from_slice(&(((7i32 << 2) | 2) as u32).to_le_bytes());
    multi.extend_from_slice(&1u16.to_le_bytes());
    sheet.extend_from_slice(&biff(0x00bd, &multi));
    sheet.extend_from_slice(&biff(0x0203, &[at(3, 0, 1), 45000.0f64.to_le_bytes().to_vec()].concat()));
    // 中にグラフの区画がある。ここのセルらしいレコードは拾ってはいけない
    let mut chart = biff(0x0809, &[0x00, 0x06, 0x20, 0x00]);
    chart.extend_from_slice(&biff(0x0203, &[at(9, 9, 0), 999.0f64.to_le_bytes().to_vec()].concat()));
    chart.extend_from_slice(&biff(0x000a, &[]));
    sheet.extend_from_slice(&chart);
    sheet.extend_from_slice(&biff(0x000a, &[]));

    let mut head = biff(0x0809, &[0x00, 0x06, 0x05, 0x00]);
    head.extend_from_slice(&biff(0x0022, &0u16.to_le_bytes()));
    head.extend_from_slice(&biff(0x00e0, &[0u16.to_le_bytes().to_vec(), 0u16.to_le_bytes().to_vec(), vec![0; 16]].concat()));
    head.extend_from_slice(&biff(0x00e0, &[0u16.to_le_bytes().to_vec(), 164u16.to_le_bytes().to_vec(), vec![0; 16]].concat()));
    head.extend_from_slice(&biff(0x041e, &[164u16.to_le_bytes().to_vec(), biff_text("yyyy-mm-dd")].concat()));
    head.extend_from_slice(&biff(0x00fc, &shared));

    // BOUNDSHEET はシートの区画の位置を持つので、頭の長さが決まってから書く
    let boundsheet = |offset: u32, name: &str, hidden: u8| {
        let mut body = offset.to_le_bytes().to_vec();
        body.push(hidden);
        body.push(0);
        body.extend_from_slice(&biff_short(name));
        biff(0x0085, &body)
    };

    let sample = boundsheet(0, "データ", 0).len() + boundsheet(0, "かくし", 1).len();
    let start = head.len() + sample + biff(0x000a, &[]).len();
    let mut whole = head;
    whole.extend_from_slice(&boundsheet(start as u32, "データ", 0));
    whole.extend_from_slice(&boundsheet((start + sheet.len()) as u32, "かくし", 1));
    whole.extend_from_slice(&biff(0x000a, &[]));
    whole.extend_from_slice(&sheet);
    whole.extend_from_slice(&sheet);

    std::fs::write(&path, compound(&[("Workbook", whole)])).unwrap();

    let mut book = Book::open(&path).unwrap();
    assert!(book.is_record());
    assert_eq!(book.sheet().len(), 2);
    assert_eq!(book.sheet()[0].name, "データ");
    assert!(book.sheet()[0].visible);
    assert!(!book.sheet()[1].visible);

    let mut reader = book.read("データ").unwrap();
    let style = reader.style();
    let mut row = Vec::new();

    while let Some(one) = reader.read().unwrap() {
        row.push((one.number, one.cell.clone()));
    }

    assert_eq!(row.len(), 4, "グラフの区画のセルを拾っていないこと");
    assert_eq!(row[0].1[0].value, Value::Text("名前".to_string()));
    assert_eq!(row[0].1[1].value, Value::Number(3.5));
    assert_eq!(row[1].1[0].value, Value::Number(100.0));
    assert_eq!(row[1].1[1].value, Value::Boolean(true));
    assert_eq!(row[1].1[2].value, Value::Error("#N/A".to_string()));
    assert_eq!(row[2].0, 3);
    assert_eq!(row[2].1.len(), 2);
    assert_eq!(row[2].1[1].value, Value::Number(7.0));
    assert!(style.is_date(row[3].1[0].style), "164 番の書式が日付として読めること");
}


#[test]
fn a_legacy_book_cannot_be_edited() {
    let path = place("noedit.xls");
    let mut head = biff(0x0809, &[0x00, 0x06, 0x05, 0x00]);
    head.extend_from_slice(&biff(0x0085, &[0u32.to_le_bytes().to_vec(), vec![0, 0], biff_short("一")].concat()));
    head.extend_from_slice(&biff(0x000a, &[]));
    std::fs::write(&path, compound(&[("Workbook", head)])).unwrap();

    let book = Book::open(&path).unwrap();
    assert!(folio::book::Writer::edit(book, &place("out.xlsx"), &["一"]).is_err());
}


#[test]
fn an_old_excel_format_is_refused() {
    let path = place("old.xls");
    let head = biff(0x0809, &[0x00, 0x05, 0x05, 0x00]);
    std::fs::write(&path, compound(&[("Workbook", head)])).unwrap();
    assert!(Book::open(&path).is_err());
}


#[test]
fn a_legacy_document_comes_back_as_paragraphs() {
    let path = place("word.doc");
    let narrow = "ASCII part.\rsecond line.\r";
    let wide = "日本語の段落\r記号 <&>\"'\rセル1\u{7}セル2\u{7}\r";
    let hidden = "\u{13} HYPERLINK \"http://example.com\" \u{14}見える文字\u{15}\r";

    // WordDocument ストリーム。FIB のあとに本文を置く
    let mut main = vec![0u8; 1024];
    main[0..2].copy_from_slice(&0xa5ecu16.to_le_bytes());
    main[2..4].copy_from_slice(&193u16.to_le_bytes());
    main[10..12].copy_from_slice(&0x0200u16.to_le_bytes());

    let narrow_at = main.len();
    main.extend(narrow.chars().map(|one| one as u8));
    let wide_at = main.len();

    for one in wide.chars().chain(hidden.chars()) {
        main.extend_from_slice(&(one as u16).to_le_bytes());
    }

    let count = narrow.chars().count() + wide.chars().count() + hidden.chars().count();
    main[76..80].copy_from_slice(&(count as u32).to_le_bytes());

    // ピーステーブル。1 バイト文字の断片と 2 バイト文字の断片
    let mut plc = Vec::new();

    for value in [0u32, narrow.chars().count() as u32, count as u32] {
        plc.extend_from_slice(&value.to_le_bytes());
    }

    for (offset, narrow_kind) in [(narrow_at, true), (wide_at, false)] {
        plc.extend_from_slice(&0u16.to_le_bytes());
        let value = if narrow_kind {(offset as u32 * 2) | 0x40000000} else {offset as u32};
        plc.extend_from_slice(&value.to_le_bytes());
        plc.extend_from_slice(&0u16.to_le_bytes());
    }

    let mut clx = vec![0x02];
    clx.extend_from_slice(&(plc.len() as u32).to_le_bytes());
    clx.extend_from_slice(&plc);

    let mut table = vec![0u8; 16];
    let clx_at = table.len();
    table.extend_from_slice(&clx);
    main[418..422].copy_from_slice(&(clx_at as u32).to_le_bytes());
    main[422..426].copy_from_slice(&(clx.len() as u32).to_le_bytes());

    std::fs::write(&path, compound(&[("WordDocument", main), ("1Table", table)])).unwrap();

    let mut document = Document::open(&path).unwrap();
    assert!(document.is_record());
    let mut body = document.read().unwrap();
    let mut line = Vec::new();

    while let Some(block) = body.read().unwrap() {
        line.push(block.text());
    }

    assert_eq!(line[0], "ASCII part.");
    assert_eq!(line[1], "second line.");
    assert_eq!(line[2], "日本語の段落");
    assert_eq!(line[3], "記号 <&>\"'");
    assert_eq!(line[4], "セル1", "表のセルは 1 つずつ段落になる");
    assert_eq!(line[5], "セル2");
    assert_eq!(line[7], "見える文字", "差し込みの指示は落ちて、結果だけが残る");
}


#[test]
fn a_legacy_document_cannot_be_edited() {
    let path = place("noedit.doc");
    let mut main = vec![0u8; 1024];
    main[0..2].copy_from_slice(&0xa5ecu16.to_le_bytes());
    main[2..4].copy_from_slice(&193u16.to_le_bytes());
    let mut plc = 0u32.to_le_bytes().to_vec();
    plc.extend_from_slice(&0u32.to_le_bytes());
    plc.extend_from_slice(&[0, 0]);
    plc.extend_from_slice(&0x40000000u32.to_le_bytes());
    plc.extend_from_slice(&[0, 0]);
    let mut clx = vec![0x02];
    clx.extend_from_slice(&(plc.len() as u32).to_le_bytes());
    clx.extend_from_slice(&plc);
    main[418..422].copy_from_slice(&0u32.to_le_bytes());
    main[422..426].copy_from_slice(&(clx.len() as u32).to_le_bytes());

    std::fs::write(&path, compound(&[("WordDocument", main), ("0Table", clx)])).unwrap();
    let document = Document::open(&path).unwrap();
    assert!(folio::document::Writer::edit(document, &place("out.docx")).is_err());
}


/// PowerPoint のレコード
fn ppt(kind: u16, version: u16, payload: &[u8]) -> Vec<u8> {
    let mut result = version.to_le_bytes().to_vec();
    result.extend_from_slice(&kind.to_le_bytes());
    result.extend_from_slice(&(payload.len() as u32).to_le_bytes());
    result.extend_from_slice(payload);
    result
}


/// UTF-16 の文字を持つレコード
fn ppt_wide(text: &str) -> Vec<u8> {
    let raw: Vec<u8> = text.encode_utf16().flat_map(|one| one.to_le_bytes()).collect();
    ppt(0x0fa0, 0, &raw)
}


#[test]
fn a_legacy_deck_comes_back_in_order() {
    let path = place("deck.ppt");

    // 並びの中の文字を使う図形
    let reference = |index: u32| {
        let inner = ppt(0x0f9e, 0, &index.to_le_bytes());
        ppt(0xf004, 0xf, &ppt(0xf00d, 0xf, &inner))
    };

    // 図形の中に文字を直に持つもの
    let direct = |kind: u32, text: &str| {
        let mut inner = ppt(0x0f9f, 0, &kind.to_le_bytes());
        inner.extend_from_slice(&ppt_wide(text));
        ppt(0xf004, 0xf, &ppt(0xf00d, 0xf, &inner))
    };

    let slide = |shape: Vec<u8>| {
        let mut body = ppt(0x03ef, 0, &[0u8; 24]);
        body.extend_from_slice(&ppt(0x040c, 0xf, &ppt(0xf002, 0xf, &ppt(0xf003, 0xf, &shape))));
        ppt(0x03ee, 0xf, &body)
    };

    let listed = |kind: u32, text: &str| {
        let mut one = ppt(0x0f9f, 0, &kind.to_le_bytes());
        one.extend_from_slice(&ppt_wide(text));
        one
    };

    let old = slide(direct(0, "消したスライド"));
    let first = slide([reference(0), reference(1)].concat());
    let second = slide([reference(0), direct(3, "図形に直に置いた文字")].concat());

    let mut listing = ppt(0x03f3, 0, &[2u32.to_le_bytes(), [0; 4], [0; 4], [0; 4]].concat());
    listing.extend_from_slice(&listed(0, "はじめの題"));
    listing.extend_from_slice(&listed(1, "本文の一行目\r本文の二行目"));
    listing.extend_from_slice(&ppt(0x03f3, 0, &[3u32.to_le_bytes(), [0; 4], [0; 4], [0; 4]].concat()));
    listing.extend_from_slice(&listed(0, "つぎの題"));

    let document = ppt(0x03e8, 0xf, &ppt(0x0ff0, 0xf, &listing));
    let mut main = old;
    let at_document = main.len();
    main.extend_from_slice(&document);
    let at_first = main.len();
    main.extend_from_slice(&first);
    let at_second = main.len();
    main.extend_from_slice(&second);

    let mut directory = ((3u32 << 20) | 1).to_le_bytes().to_vec();

    for value in [at_document, at_first, at_second] {
        directory.extend_from_slice(&(value as u32).to_le_bytes());
    }

    let at_directory = main.len();
    main.extend_from_slice(&ppt(0x1772, 0, &directory));

    let at_edit = main.len();
    let mut edit = 3u32.to_le_bytes().to_vec();
    edit.extend_from_slice(&0x0c00u16.to_le_bytes());
    edit.extend_from_slice(&[0, 8]);
    edit.extend_from_slice(&0u32.to_le_bytes());
    edit.extend_from_slice(&(at_directory as u32).to_le_bytes());
    edit.extend_from_slice(&1u32.to_le_bytes());
    edit.extend_from_slice(&4u32.to_le_bytes());
    edit.extend_from_slice(&0u32.to_le_bytes());
    main.extend_from_slice(&ppt(0x0ff5, 0, &edit));

    let mut user = 0x14u32.to_le_bytes().to_vec();
    user.extend_from_slice(&0xe391c05fu32.to_le_bytes());
    user.extend_from_slice(&(at_edit as u32).to_le_bytes());
    user.extend_from_slice(&[0; 8]);

    std::fs::write(
        &path,
        compound(&[("PowerPoint Document", main), ("Current User", ppt(0x0ff6, 0, &user))]),
    )
    .unwrap();

    let mut file = Presentation::open(&path).unwrap();
    assert!(file.is_record());
    assert_eq!(file.count(), 2, "消したスライドを拾っていないこと");

    let one = file.read(0).unwrap();
    assert_eq!(one.shape.len(), 2);
    assert_eq!(one.shape[0].place, "title");
    assert_eq!(one.shape[0].body(), "はじめの題");
    assert_eq!(one.shape[1].place, "body");
    assert_eq!(one.shape[1].body(), "本文の一行目\n本文の二行目");

    let two = file.read(1).unwrap();
    assert_eq!(two.shape[0].body(), "つぎの題");
    assert_eq!(two.shape[1].body(), "図形に直に置いた文字");
    assert!(!file.text().unwrap().contains("消したスライド"));
}


#[test]
fn a_legacy_deck_cannot_be_edited() {
    let path = place("noedit.ppt");
    let main = ppt(0x03ee, 0xf, &ppt(0x03ef, 0, &[0u8; 24]));
    std::fs::write(&path, compound(&[("PowerPoint Document", main)])).unwrap();
    let file = Presentation::open(&path).unwrap();
    assert!(folio::presentation::Writer::edit(file, &place("out.pptx"), &[0]).is_err());
}


#[test]
fn a_file_that_is_not_a_compound_file_is_an_error() {
    let path = place("broken.xls");
    std::fs::write(&path, "これは複合ファイルではありません").unwrap();
    assert!(Book::open(&path).is_err());
}