presentation.rs

//! pptx を作って読み戻すところ

use folio::paragraph::{Align, Run};
use folio::presentation::{Presentation, Writer};
use folio::slide::{INCH, Paragraph, Shape, Slide};
use std::path::PathBuf;


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


#[test]
fn shapes_come_back_as_they_were_written() {
    let path = place("shape");
    let mut writer = Writer::create(&path, 1).unwrap();

    writer.slide(0, &Slide::new(vec![
        Shape {
            name: "題".to_string(),
            place: String::new(),
            x: INCH,
            y: INCH * 2,
            width: INCH * 11,
            height: INCH,
            paragraph: vec![Paragraph {
                level: 0,
                align: Align::Center,
                run: vec![
                    Run::new("ふつう"),
                    Run::bold("太字"),
                    Run {text: "斜体".to_string(), italic: true, ..Run::default()},
                    Run {text: "下線".to_string(), underline: true, ..Run::default()},
                    Run {text: "取り消し".to_string(), strike: true, ..Run::default()},
                    Run {text: "大きい".to_string(), size: 24.0, ..Run::default()},
                    Run {text: "赤".to_string(), color: "FF0000".to_string(), ..Run::default()},
                ],
            }],
        },
    ])).unwrap();

    writer.finish().unwrap();

    let mut file = Presentation::open(&path).unwrap();
    assert_eq!(file.count(), 1);

    let one = file.read(0).unwrap();
    assert_eq!(one.shape.len(), 1);

    let shape = &one.shape[0];
    assert_eq!(shape.name, "題");
    assert_eq!((shape.x, shape.y), (INCH, INCH * 2));
    assert_eq!((shape.width, shape.height), (INCH * 11, INCH));

    let line = &shape.paragraph[0];
    assert_eq!(line.align, Align::Center);
    assert_eq!(line.run.len(), 7);
    assert!(line.run[1].bold);
    assert!(line.run[2].italic);
    assert!(line.run[3].underline);
    assert!(line.run[4].strike);
    assert_eq!(line.run[5].size, 24.0);
    assert_eq!(line.run[6].color, "FF0000");
    assert_eq!(line.text(), "ふつう太字斜体下線取り消し大きい赤");
}


#[test]
fn marks_and_breaks_survive_the_trip() {
    let path = place("mark");
    let mut writer = Writer::create(&path, 1).unwrap();

    writer.slide(0, &Slide::new(vec![Shape::text(
        "本文",
        INCH,
        INCH,
        INCH * 8,
        INCH * 3,
        &["記号 <&>\"' です", "改行\nあり"],
    )])).unwrap();

    writer.finish().unwrap();

    let mut file = Presentation::open(&path).unwrap();
    let one = file.read(0).unwrap();
    assert_eq!(one.shape[0].paragraph[0].text(), "記号 <&>\"' です");
    assert_eq!(one.shape[0].paragraph[1].text(), "改行\nあり");
}


#[test]
fn bullet_levels_are_kept() {
    let path = place("level");
    let mut writer = Writer::create(&path, 1).unwrap();

    writer.slide(0, &Slide::new(vec![Shape {
        name: "箇条書き".to_string(),
        place: String::new(),
        x: INCH,
        y: INCH,
        width: INCH * 8,
        height: INCH * 4,
        paragraph: vec![
            Paragraph::new("浅い"),
            Paragraph::nested("ひとつ深い", 1),
            Paragraph::nested("ふたつ深い", 2),
        ],
    }])).unwrap();

    writer.finish().unwrap();

    let mut file = Presentation::open(&path).unwrap();
    let one = file.read(0).unwrap();
    let line = &one.shape[0].paragraph;
    assert_eq!(line.iter().map(|value| value.level).collect::<Vec<_>>(), vec![0, 1, 2]);
    assert_eq!(line[2].text(), "ふたつ深い");
}


#[test]
fn several_slides_keep_their_order() {
    let path = place("order");
    let mut writer = Writer::create(&path, 3).unwrap();

    for index in 0..3 {
        writer.slide(index, &Slide::new(vec![Shape::text(
            "本文",
            INCH,
            INCH,
            INCH * 8,
            INCH,
            &[&format!("{} 枚目", index + 1)],
        )])).unwrap();
    }

    writer.finish().unwrap();

    let mut file = Presentation::open(&path).unwrap();
    assert_eq!(file.count(), 3);

    for index in 0..3 {
        assert_eq!(file.read(index).unwrap().text(), format!("{} 枚目", index + 1));
    }

    let whole = file.text().unwrap();
    assert!(whole.contains("1 枚目") && whole.contains("3 枚目"));
}


#[test]
fn a_slide_that_was_never_written_is_still_there() {
    let path = place("untouched");
    let mut writer = Writer::create(&path, 2).unwrap();
    writer.slide(0, &Slide::new(vec![Shape::text("本文", INCH, INCH, INCH * 8, INCH, &["ある"])])).unwrap();
    writer.finish().unwrap();

    let mut file = Presentation::open(&path).unwrap();
    assert_eq!(file.count(), 2);
    assert_eq!(file.read(0).unwrap().text(), "ある");
    assert_eq!(file.read(1).unwrap().text(), "");
}


#[test]
fn editing_replaces_only_the_slides_that_were_named() {
    let source_path = place("source");
    let target_path = place("edited");

    let mut writer = Writer::create(&source_path, 3).unwrap();

    for index in 0..3 {
        writer.slide(index, &Slide::new(vec![Shape::text(
            "本文",
            INCH,
            INCH,
            INCH * 8,
            INCH,
            &[&format!("もとの {} 枚目", index + 1)],
        )])).unwrap();
    }

    writer.finish().unwrap();

    let source = Presentation::open(&source_path).unwrap();
    let mut writer = Writer::edit(source, &target_path, &[1]).unwrap();
    writer.slide(0, &Slide::new(vec![Shape::text(
        "入れ替え",
        INCH,
        INCH,
        INCH * 8,
        INCH,
        &["書き直しました"],
    )])).unwrap();
    writer.finish().unwrap();

    let mut file = Presentation::open(&target_path).unwrap();
    assert_eq!(file.count(), 3);
    assert_eq!(file.read(0).unwrap().text(), "もとの 1 枚目");
    assert_eq!(file.read(1).unwrap().text(), "書き直しました");
    assert_eq!(file.read(2).unwrap().text(), "もとの 3 枚目");
}


#[test]
fn a_slide_marked_for_editing_but_left_alone_keeps_its_shapes() {
    let source_path = place("left-source");
    let target_path = place("left-target");

    let mut writer = Writer::create(&source_path, 1).unwrap();
    writer.slide(0, &Slide::new(vec![Shape::text("本文", INCH, INCH, INCH * 8, INCH, &["そのまま"])])).unwrap();
    writer.finish().unwrap();

    let source = Presentation::open(&source_path).unwrap();
    let writer = Writer::edit(source, &target_path, &[0]).unwrap();
    writer.finish().unwrap();

    let mut file = Presentation::open(&target_path).unwrap();
    assert_eq!(file.read(0).unwrap().text(), "そのまま");
}


#[test]
fn a_slide_outside_the_count_is_an_error() {
    let path = place("range");
    let mut writer = Writer::create(&path, 1).unwrap();
    assert!(writer.slide(3, &Slide::default()).is_err());
    writer.slide(0, &Slide::default()).unwrap();
    assert!(writer.slide(0, &Slide::default()).is_err());
    writer.finish().unwrap();

    let mut file = Presentation::open(&path).unwrap();
    assert!(file.read(5).is_err());
}


#[test]
fn a_deck_with_no_slides_is_an_error() {
    assert!(Writer::create(&place("none"), 0).is_err());
}


#[test]
fn a_file_that_is_not_a_deck_is_an_error() {
    let path = place("broken");
    std::fs::write(&path, "これは pptx ではありません").unwrap();
    assert!(Presentation::open(&path).is_err());
}