GitCorner

Code

ossartcraftwordcraft🌐
6ef13b2cc8a6
use super::*;

fn doc() -> Session {
    Session::new(wordcraft_doc::Document::from_text("one\ntwo\nthree"))
}

fn with_section(f: impl Fn(&mut Value)) -> Value {
    let mut v = serde_json::to_value(SectionProps::default()).unwrap();
    f(&mut v);
    json!({"section": v})
}

/// `layout.pageSetup {section}` checks the values like the dedicated commands do.
#[test]
fn page_setup_section_is_validated() {
    let mut s = doc();
    let before = sect(&s);
    // Refused with an error, nothing changes: non-finite (overflowing), margins that leave no text room.
    for (what, p) in [
        ("inf width", with_section(|v| v["pageW"] = json!(1e300))),
        ("inf margin", with_section(|v| v["marginTop"] = json!(1e300))),
        ("inf header", with_section(|v| v["header"] = json!(1e300))),
        ("inf column space", with_section(|v| v["columns"]["space"] = json!(1e300))),
        ("inf column width", with_section(|v| v["columns"]["widths"] = json!([[1e300, 0.0], [100.0, 0.0]]))),
        ("inf line number distance", with_section(|v| v["lineNumbers"] = json!({"distance": 1e300}))),
        ("inf grid pitch", with_section(|v| v["docGrid"] = json!({"type": "lines", "linePitch": 1e300, "charSpace": 0}))),
        ("inf border space", with_section(|v| v["pageBorders"] = json!({"top": {"style": "single", "width": 1.0, "space": 1e300}}))),
        ("inf border width", with_section(|v| v["pageBorders"] = json!({"top": {"style": "single", "width": 1e300, "space": 1.0}}))),
        ("margins > page", with_section(|v| v["marginLeft"] = json!(5000.0))),
        ("margins eat the height", with_section(|v| v["marginTop"] = json!(700.0))),
        ("gutter eats the width", with_section(|v| v["gutter"] = json!(600.0))),
        ("negative page", with_section(|v| v["pageW"] = json!(-5.0))),
        ("zero page height", with_section(|v| v["pageH"] = json!(0.0))),
    ] {
        assert!(s.run("layout.pageSetup", &p).is_err(), "{what}");
        assert_eq!(sect(&s), before, "{what}");
    }
    // Clamped.
    s.run(
        "layout.pageSetup",
        &with_section(|v| {
            v["pageW"] = json!(100.0);
            v["pageH"] = json!(100.0);
            v["marginTop"] = json!(-10.0);
            v["marginBottom"] = json!(0.0);
            v["marginLeft"] = json!(0.0);
            v["marginRight"] = json!(0.0);
            v["header"] = json!(-3.0);
            v["footer"] = json!(1e6);
            v["columns"]["count"] = json!(1000);
            v["columns"]["space"] = json!(-4.0);
            v["lineNumbers"] = json!({"countBy": 0, "start": 0, "distance": 1e6, "restart": "page"});
            v["docGrid"] = json!({"type": "lines", "linePitch": 1e9, "charSpace": 2_000_000_000});
            v["pageNumStart"] = json!(4_000_000_000u64);
            v["footnotePr"] = json!({"numStart": 4_000_000_000u64});
            v["endnotePr"] = json!({"numStart": 0});
            v["pageBorders"] =
                json!({"top": {"style": "single", "width": 1e6, "space": -5.0}, "left": {"style": "single", "width": 0.0, "space": 1e6}});
        }),
    )
    .unwrap();
    let x = sect(&s);
    assert_eq!((x.page_w, x.page_h), (100.0, 100.0));
    assert_eq!(x.margin_top, 0.0);
    assert_eq!(x.header, 0.0);
    assert_eq!(x.footer, x.page_h, "a footer distance stays on the page");
    assert_eq!(x.columns.count, 12);
    assert_eq!(x.columns.space, 0.0);
    let l = x.line_numbers.unwrap();
    assert_eq!((l.count_by, l.start, l.distance), (1, 1, 1584.0));
    let g = x.doc_grid.unwrap();
    assert_eq!((g.line_pitch, g.char_space), (wordcraft_doc::section::MAX_GRID_PITCH, wordcraft_doc::section::MAX_CHAR_SPACE));
    assert_eq!(x.page_num_start, Some(100_000));
    assert_eq!(x.footnote_pr.num_start, Some(wordcraft_doc::section::MAX_NOTE_START));
    assert_eq!(x.endnote_pr.num_start, Some(1));
    let b = x.page_borders.unwrap();
    let (t, lf) = (b.top.unwrap(), b.left.unwrap());
    assert_eq!((t.width, t.space), (6.0, 0.0));
    assert_eq!((lf.width, lf.space), (0.25, 31.0));
    // Huge pages clamp; columns and widths agree; orientation follows the sides.
    let mut s = doc();
    s.run(
        "layout.pageSetup",
        &with_section(|v| {
            v["pageW"] = json!(1e5);
            v["pageH"] = json!(792.0);
            v["landscape"] = json!(false);
            v["columns"]["count"] = json!(3);
            v["columns"]["widths"] = json!(vec![json!([1.0, 1e5]); 40]);
        }),
    )
    .unwrap();
    let x = sect(&s);
    assert_eq!(x.page_w, 1584.0);
    assert!(x.landscape, "wider than tall is landscape");
    assert_eq!(x.columns.widths.len(), 12);
    assert_eq!(x.columns.count, 12, "the count follows the widths");
    assert!(x.columns.widths.iter().all(|(w, sp)| *w >= 18.0 && (0.0..=300.0).contains(sp)));
    // One width is no custom layout: equal columns.
    s.run("layout.pageSetup", &with_section(|v| v["columns"]["widths"] = json!([[200.0, 0.0]]))).unwrap();
    assert!(sect(&s).columns.widths.is_empty());
}

/// A valid section still applies as given.
#[test]
fn page_setup_section_applies_a_valid_one() {
    let mut s = doc();
    s.run(
        "layout.pageSetup",
        &with_section(|v| {
            v["pageW"] = json!(595.0);
            v["pageH"] = json!(842.0);
            v["marginLeft"] = json!(50.0);
            v["columns"]["count"] = json!(2);
        }),
    )
    .unwrap();
    let x = sect(&s);
    assert_eq!((x.page_w, x.page_h, x.margin_left, x.columns.count), (595.0, 842.0, 50.0, 2));
}

/// A page smaller than the usual 36 pt of text room is fine with no margins; any margin or
/// gutter on it is refused.
#[test]
fn page_setup_section_allows_a_tiny_page_without_margins() {
    let tiny = |m: f32, g: f32| {
        with_section(|v| {
            v["pageW"] = json!(7.2);
            v["pageH"] = json!(20.0);
            for k in ["marginTop", "marginBottom", "marginLeft", "marginRight"] {
                v[k] = json!(m);
            }
            v["gutter"] = json!(g);
        })
    };
    let mut s = doc();
    let before = sect(&s);
    assert!(s.run("layout.pageSetup", &tiny(1.0, 0.0)).is_err(), "a margin on a tiny page");
    assert!(s.run("layout.pageSetup", &tiny(0.0, 1.0)).is_err(), "a gutter on a tiny page");
    assert_eq!(sect(&s), before);
    s.run("layout.pageSetup", &tiny(0.0, 0.0)).unwrap();
    assert_eq!((sect(&s).page_w, sect(&s).page_h), (7.2, 20.0));
}

/// Layout › Text Direction turns the section, or the table cell the caret is in; one undo step.
#[test]
fn text_direction_turns_the_section_or_the_cell() {
    use wordcraft_doc::props::TextDirection;
    let mut s = doc();
    s.run("layout.textDirection", &json!({"value": "down"})).unwrap();
    assert_eq!(sect(&s).text_direction, TextDirection::Down);
    assert_eq!(text_direction_at(&s), TextDirection::Down);
    // Without a value: the next one, like Word's button.
    s.run("layout.textDirection", &json!({})).unwrap();
    assert_eq!(sect(&s).text_direction, TextDirection::Up);
    s.run("edit.undo", &json!({})).unwrap();
    assert_eq!(sect(&s).text_direction, TextDirection::Down);
    assert!(s.run("layout.textDirection", &json!({"value": "diagonal"})).is_err());
    assert_eq!(sect(&s).text_direction, TextDirection::Down);
    // In a table cell it turns the cell, not the section.
    s.run("insert.table", &json!({"rows": 1, "cols": 2})).unwrap();
    assert!(s.sel.focus.path.cell().is_some());
    s.run("layout.textDirection", &json!({"value": "btLr"})).unwrap();
    assert_eq!(text_direction_at(&s), TextDirection::Up);
    assert_eq!(sect(&s).text_direction, TextDirection::Down);
}

/// #1206: each Margins and Columns preset is recognised after it's applied (Mirrored and
/// Office 2003 share three margins; mirror margins tell them apart), and a value no preset
/// gives is none of them.
#[test]
fn page_setup_presets_are_recognised() {
    let mut s = doc();
    for (id, _) in MARGIN_PRESETS {
        s.run("layout.margins", &json!({"preset": id})).unwrap();
        assert_eq!(margins_preset_at(&s), Some(id));
    }
    s.run("layout.margins", &json!({"left": 80.0})).unwrap();
    assert_eq!(margins_preset_at(&s), None);
    for (params, id) in [
        (json!({"count": 2}), "two"),
        (json!({"preset": "left"}), "left"),
        (json!({"count": 3}), "three"),
        (json!({"preset": "right"}), "right"),
        (json!({"count": 1}), "one"),
    ] {
        s.run("layout.columns", &params).unwrap();
        assert_eq!(columns_preset_at(&s), Some(id), "{params}");
    }
    s.run("layout.columns", &json!({"count": 4})).unwrap();
    assert_eq!(columns_preset_at(&s), None);
}

/// #852: a continuous section break with text selected goes before the selection and keeps
/// it, as in Word; it used to delete the text, so the first section came out empty. Saved and
/// opened again, both sections' text lays out on page 1, the second below the first.
#[test]
fn section_break_keeps_the_selected_text() {
    let mut s = Session::new(wordcraft_doc::Document::from_text("one\ntwo"));
    s.run("select.text", &json!({"text": "one"})).unwrap();
    s.run("layout.break", &json!({"kind": "continuous"})).unwrap();
    assert_eq!(s.selected_text(), "one");
    assert_eq!(s.doc.sections().len(), 2);
    let texts = |d: &wordcraft_doc::Document| -> Vec<String> {
        d.body.iter().filter_map(|b| if let Block::Para(p) = &**b { Some(p.plain_text().to_string()) } else { None }).collect()
    };
    assert_eq!(texts(&s.doc), ["", "one", "two"]);
    // A backward selection in the middle of a paragraph keeps its text and direction too.
    let mut s = Session::new(wordcraft_doc::Document::from_text("alpha beta\ngamma"));
    let p = |off| Pos { story: StoryRef::Body, path: wordcraft_doc::Path::top(0), off };
    s.sel = Selection { anchor: p(10), focus: p(6) };
    s.run("layout.break", &json!({"kind": "continuous"})).unwrap();
    assert_eq!(s.selected_text(), "beta");
    assert!(s.sel.anchor > s.sel.focus);
    assert_eq!(texts(&s.doc), ["alpha ", "beta", "gamma"]);

    // The issue's document: "one", a continuous break, "two" — both on page 1 after a round trip.
    let mut s = Session::new(wordcraft_doc::Document::from_text("one\ntwo"));
    s.run("select.text", &json!({"text": "one"})).unwrap();
    s.run("caret.end", &json!({})).unwrap();
    s.run("layout.break", &json!({"kind": "continuous"})).unwrap();
    let back = wordcraft_docx::read(&wordcraft_docx::write(&s.doc).unwrap()).unwrap();
    assert_eq!(back.sections().len(), 2);
    assert_eq!(back.last_section.start, SectionStart::Continuous);
    let mut s = Session::new(back);
    let l = s.layout();
    assert_eq!(l.pages.len(), 1);
    let mut lines: Vec<(String, f32)> = l.pages[0]
        .items
        .iter()
        .filter_map(|it| match it {
            crate::layout::Placed::Lines { path, y, .. } => {
                let Some(Block::Para(p)) = s.doc.body.get(path.last()).map(|b| &**b) else { return None };
                (!p.plain_text().is_empty()).then(|| (p.plain_text().to_string(), *y))
            }
            _ => None,
        })
        .collect();
    lines.sort_by(|a, b| a.1.total_cmp(&b.1));
    let order: Vec<&str> = lines.iter().map(|(t, _)| t.as_str()).collect();
    assert_eq!(order, ["one", "two"]);
}

/// More Columns: unequal widths with a line between, as one undo step.
#[test]
fn unequal_columns_with_a_line_between() {
    let mut s = doc();
    let tw = sect(&s).text_width();
    s.run("layout.columns", &json!({"widths": [[150.0, 24.0], [tw - 174.0, 0.0]], "separator": true})).unwrap();
    let c = sect(&s).columns;
    assert_eq!((c.count, c.separator, c.widths.len()), (2, true, 2));
    assert_eq!(c.widths.first(), Some(&(150.0, 24.0)));
    s.run("edit.undo", &json!({})).unwrap();
    assert_eq!(sect(&s).columns, Columns::default());
    // Too wide, too narrow, too many, or nonsense: refused.
    for bad in [json!([[tw, 36.0], [100.0, 0.0]]), json!([[5.0, 0.0], [100.0, 0.0]]), json!(vec![[40.0, 0.0]; 13]), json!("x")] {
        assert!(s.run("layout.columns", &json!({"widths": bad})).is_err(), "{bad}");
    }
}

/// Apply to: the whole document, or from the caret on (a continuous section break first).
#[test]
fn columns_apply_to_the_document_or_from_the_caret_on() {
    let mut s = doc();
    s.run("layout.break", &json!({"kind": "nextPage"})).unwrap();
    s.run("layout.columns", &json!({"count": 3, "apply": "document"})).unwrap();
    assert!(s.doc.sections().iter().all(|(_, x)| x.columns.count == 3));
    let mut s = doc();
    s.run("caret.docEnd", &json!({})).unwrap();
    s.run("layout.columns", &json!({"count": 2, "apply": "forward"})).unwrap();
    let counts: Vec<u32> = s.doc.sections().iter().map(|(_, x)| x.columns.count).collect();
    assert_eq!(counts, vec![1, 2]);
    assert_eq!(s.doc.last_section.start, SectionStart::Continuous);
    assert!(s.run("layout.columns", &json!({"count": 2, "apply": "elsewhere"})).is_err());
}

/// Each section's paragraphs (a section break's own paragraph shows as "") and column count.
fn sections_of(s: &Session) -> Vec<(Vec<String>, u32)> {
    let mut from = 0;
    let mut out = Vec::new();
    for (end, x) in s.doc.sections() {
        let paras = (from..=end).map(|i| s.doc.para_at(&Pos::body(i, 0)).map(|p| p.text.clone()).unwrap_or_default()).collect();
        out.push((paras, x.columns.count));
        from = end + 1;
    }
    out
}

fn select(s: &mut Session, from: (usize, usize), to: (usize, usize)) {
    s.sel = Selection { anchor: Pos::body(from.0, from.1), focus: Pos::body(to.0, to.1) };
}

fn strs(v: &[&str]) -> Vec<String> {
    v.iter().map(|x| x.to_string()).collect()
}

/// Columns on selected text (#2024), as observed in Word: a continuous section break before
/// and after the selection, the columns on the section between, the rest left alone.
#[test]
fn columns_apply_to_the_selected_text() {
    let five = || Session::new(wordcraft_doc::Document::from_text("p1\np2\nalpha beta gamma\np4\np5"));
    // A whole paragraph (a triple-click takes its mark): each break gets a paragraph of its own.
    let mut s = five();
    select(&mut s, (2, 0), (3, 0));
    let whole = s.selected_text();
    s.run("layout.columns", &json!({"count": 2})).unwrap();
    assert_eq!(sections_of(&s), vec![(strs(&["p1", "p2", ""]), 1), (strs(&["alpha beta gamma", ""]), 2), (strs(&["p4", "p5"]), 1)]);
    assert!(s.doc.sections().iter().skip(1).all(|(_, x)| x.start == SectionStart::Continuous));
    assert_eq!(s.selected_text(), whole, "the paragraph stays selected");
    // The same paragraph again: its section changes, no new breaks.
    select(&mut s, (3, 0), (4, 0));
    s.run("layout.columns", &json!({"count": 3})).unwrap();
    assert_eq!(sections_of(&s).iter().map(|(_, n)| *n).collect::<Vec<_>>(), vec![1, 3, 1]);
    // Taking the section break along changes nothing more.
    select(&mut s, (3, 0), (5, 0));
    s.run("layout.columns", &json!({"count": 2})).unwrap();
    assert_eq!(sections_of(&s).iter().map(|(_, n)| *n).collect::<Vec<_>>(), vec![1, 2, 1]);
    // One undo step takes the breaks and the columns away.
    let mut s = five();
    select(&mut s, (2, 0), (3, 0));
    s.run("layout.columns", &json!({"count": 2})).unwrap();
    s.run("edit.undo", &json!({})).unwrap();
    assert_eq!(sections_of(&s), vec![(strs(&["p1", "p2", "alpha beta gamma", "p4", "p5"]), 1)]);

    // Words inside a paragraph: the breaks split it there.
    let mut s = five();
    select(&mut s, (2, 10), (2, 6));
    s.run("layout.columns", &json!({"count": 2})).unwrap();
    assert_eq!(sections_of(&s), vec![(strs(&["p1", "p2", "alpha "]), 1), (strs(&["beta"]), 2), (strs(&[" gamma", "p4", "p5"]), 1)]);
    assert_eq!(s.selected_text(), "beta");
    assert!(s.sel.anchor > s.sel.focus, "a backward selection stays backward");

    // At the document's start no break goes before it, at its end none after.
    let mut s = five();
    select(&mut s, (0, 0), (1, 0));
    s.run("layout.columns", &json!({"count": 2})).unwrap();
    assert_eq!(sections_of(&s), vec![(strs(&["p1", ""]), 2), (strs(&["p2", "alpha beta gamma", "p4", "p5"]), 1)]);
    let mut s = five();
    select(&mut s, (4, 0), (4, 2));
    s.run("layout.columns", &json!({"count": 2})).unwrap();
    assert_eq!(sections_of(&s), vec![(strs(&["p1", "p2", "alpha beta gamma", "p4", ""]), 1), (strs(&["p5"]), 2)]);
    // Select All: the whole document, no breaks.
    let mut s = five();
    s.run("select.all", &json!({})).unwrap();
    s.run("layout.columns", &json!({"count": 2})).unwrap();
    assert_eq!(sections_of(&s), vec![(strs(&["p1", "p2", "alpha beta gamma", "p4", "p5"]), 2)]);

    // Without a selection the caret's section changes; "selection" then needs one.
    let mut s = five();
    s.run("layout.columns", &json!({"count": 2})).unwrap();
    assert_eq!(sections_of(&s).len(), 1);
    assert!(s.run("layout.columns", &json!({"count": 2, "apply": "selection"})).is_err());
}

/// #407 Line Numbers options: start, count by, distance and restart; options alone keep the
/// restart mode, `none` turns numbering off.
#[test]
fn line_numbering_options() {
    use wordcraft_doc::section::LineNumberRestart;
    let mut s = Session::new(wordcraft_doc::Document::from_text("One\nTwo"));
    s.run("layout.lineNumbers", &json!({"value": "restartSection", "start": 5, "countBy": 2, "distance": 18})).unwrap();
    let l = s.doc.last_section.line_numbers.clone().unwrap();
    assert_eq!((l.start, l.count_by, l.distance, l.restart), (5, 2, 18.0, LineNumberRestart::Section));
    s.run("layout.lineNumbers", &json!({"countBy": 1e9, "start": -3})).unwrap();
    let l = s.doc.last_section.line_numbers.clone().unwrap();
    assert_eq!((l.start, l.count_by, l.restart), (5, 100, LineNumberRestart::Section), "clamped, mode kept");
    s.run("layout.lineNumbers", &json!({"value": "none"})).unwrap();
    assert!(s.doc.last_section.line_numbers.is_none());
    assert!(s.run("layout.lineNumbers", &json!({"value": "sometimes"})).is_err());
}

/// #407 Hyphenation Options: options don't toggle automatic hyphenation; Manual finds a
/// word at a line start that would fit hyphenated on the line above, and an optional hyphen
/// there breaks the word.
#[test]
fn hyphenation_options_and_manual_hyphenation() {
    if crate::tests::no_language_data("hyphenation_options_and_manual_hyphenation") {
        return;
    }
    let mut s =
        Session::new(wordcraft_doc::Document::from_text(&"a extraordinarily be uncharacteristic of responsibilities the considerations ".repeat(12)));
    let r = s.run("layout.hyphenation", &json!({"zone": 36, "caps": false, "limit": 3})).unwrap();
    assert_eq!(r, json!({"value": false, "zone": 36.0, "caps": false, "limit": 3}));
    s.run("layout.hyphenation", &json!({})).unwrap();
    assert!(s.doc.settings.auto_hyphenation, "nothing given toggles");
    s.run("layout.hyphenation", &json!({"value": false})).unwrap();
    // Accept every candidate (which words they are depends on the fonts).
    let mut found = 0;
    let mut from = json!(null);
    while found < 5 {
        let c = s.run("layout.manualHyphenation", &json!({"from": from})).unwrap();
        if c["done"] == true {
            break;
        }
        let word = c["word"].as_str().unwrap().to_string();
        let pts = c["points"].as_array().unwrap();
        assert!(!pts.is_empty() && pts.contains(&c["suggest"]), "{c}");
        let at = c["suggest"].as_u64().unwrap() as usize;
        let mut pos = c["pos"].clone();
        let off = pos["off"].as_u64().unwrap() as usize + word.char_indices().nth(at).unwrap().0;
        pos["off"] = json!(off);
        s.run("caret.set", &json!({"pos": pos})).unwrap();
        s.run("text.optionalHyphen", &json!({})).unwrap();
        pos["off"] = json!(off + word.len());
        from = pos;
        found += 1;
    }
    // Some line of thirty or so starts with a long word that fits hyphenated above, whatever the font.
    assert!(found > 0, "no candidates");
    assert_eq!(s.doc.plain_text(wordcraft_doc::StoryRef::Body).matches('\u{ad}').count(), found);
    assert!(s.run("layout.manualHyphenation", &json!({"from": {"block": 999, "off": 0}})).unwrap()["done"] == true);
}

/// `layout.pageNumberFormat` sets the section's number format and start; a call without
/// `start` keeps it (the ribbon's old plain call cleared it), and a null `start` numbers on
/// from the section before — the Format Page Numbers dialog's "Continue from previous
/// section" (#1113).
#[test]
fn page_number_format_keeps_or_clears_the_start() {
    use wordcraft_doc::section::NumFormat;
    let mut s = doc();
    s.run("layout.pageNumberFormat", &json!({"format": "upperRoman", "start": 3})).unwrap();
    let x = sect(&s);
    assert_eq!((x.page_num_format, x.page_num_start), (NumFormat::UpperRoman, Some(3)));
    s.run("layout.pageNumberFormat", &json!({"format": "lowerLetter"})).unwrap();
    let x = sect(&s);
    assert_eq!((x.page_num_format, x.page_num_start), (NumFormat::LowerLetter, Some(3)), "a format change keeps the start");
    s.run("layout.pageNumberFormat", &json!({"start": null})).unwrap();
    let x = sect(&s);
    assert_eq!((x.page_num_format, x.page_num_start), (NumFormat::LowerLetter, None), "continue numbers on from the section before");
    // The result carries the section back (scripts read it instead of the dialog).
    let back = s.run("layout.pageNumberFormat", &json!({"format": "decimal", "start": 1})).unwrap();
    assert_eq!(back["pageNumFormat"], "decimal");
    assert_eq!(back["pageNumStart"], 1);
}