mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-18 08:53:33 +00:00
A listed word whose text already equals `to` is now left out of the edit. When every listed word does, the command makes no edit and no undo step, so the redo history is kept, and `changed` is 0.
495 lines
25 KiB
Rust
495 lines
25 KiB
Rust
//! Edit → Spelling (`text.spelling.check`, `text.spelling.suggest`): the unknown words of the
|
||
//! document's type, at the bytes `text.editRange` changes, each in its run's language.
|
||
|
||
use serde_json::{Value, json};
|
||
|
||
use crate::cmd::spelling::MAX_DICTIONARY_FILE_BYTES;
|
||
use crate::*;
|
||
|
||
/// Held by each test that changes the custom dictionary, which the whole process shares: a save
|
||
/// writes every word in it to the test's file and a reload takes the file's words back, so another
|
||
/// test's word could come back after that test deleted it.
|
||
fn dictionary_lock() -> std::sync::MutexGuard<'static, ()> {
|
||
static LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
|
||
LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
|
||
}
|
||
|
||
/// A session with a new 400 × 400 document.
|
||
fn session() -> Session {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
|
||
s
|
||
}
|
||
|
||
/// Runs a command that must succeed and gives its result.
|
||
fn run(s: &mut Session, id: &str, p: Value) -> Value {
|
||
s.execute(id, &p).unwrap()
|
||
}
|
||
|
||
/// New point type at (10, `y`) holding `t`.
|
||
fn text(s: &mut Session, y: f64, t: &str) -> NodeId {
|
||
NodeId(run(s, "text.create", json!({"x": 10, "y": y, "text": t}))["id"].as_u64().unwrap())
|
||
}
|
||
|
||
/// The unknown words a check lists: (id, start, end, word).
|
||
fn unknown(s: &mut Session, p: Value) -> Vec<(u64, u64, u64, String)> {
|
||
let r = run(s, "text.spelling.check", p);
|
||
assert_eq!(r["more"], false);
|
||
r["words"]
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.map(|w| (w["id"].as_u64().unwrap(), w["start"].as_u64().unwrap(), w["end"].as_u64().unwrap(), w["word"].as_str().unwrap().to_string()))
|
||
.collect()
|
||
}
|
||
|
||
#[test]
|
||
fn check_lists_unknown_words_at_the_bytes_edit_range_changes() {
|
||
let mut s = session();
|
||
// "—" is three bytes, so the unknown word starts at byte 12, not character 10. Punctuation,
|
||
// not a word, so the result doesn't depend on which dictionary is built in.
|
||
let t = text(&mut s, 50.0, "drawing — qzxvw tools");
|
||
assert_eq!(unknown(&mut s, json!({})), [(t.0, 12, 17, "qzxvw".to_string())]);
|
||
let w = &run(&mut s, "text.spelling.check", json!({}))["words"][0];
|
||
assert_eq!(w["lang"], "en", "text with no language is checked in English");
|
||
// Change: the bytes the check gave, as one undo step.
|
||
run(&mut s, "text.editRange", json!({"id": t.0, "start": 12, "end": 17, "insert": "vector"}));
|
||
assert_eq!(unknown(&mut s, json!({})), []);
|
||
run(&mut s, "edit.undo", json!({}));
|
||
assert_eq!(unknown(&mut s, json!({})).len(), 1, "undo brings the word back");
|
||
}
|
||
|
||
#[test]
|
||
fn check_goes_through_visible_unlocked_type_in_paint_order_or_the_ids_given() {
|
||
let mut s = session();
|
||
let a = text(&mut s, 50.0, "first qzxvw");
|
||
let b = text(&mut s, 100.0, "second wvxzq");
|
||
let hidden = text(&mut s, 150.0, "hidden qqzzx");
|
||
let locked = text(&mut s, 200.0, "locked zzqqx");
|
||
run(&mut s, "object.hide", json!({"ids": [hidden.0]}));
|
||
run(&mut s, "object.lock", json!({"ids": [locked.0]}));
|
||
let ids: Vec<u64> = unknown(&mut s, json!({})).iter().map(|w| w.0).collect();
|
||
assert_eq!(ids, [a.0, b.0], "hidden and locked type are left out");
|
||
assert_eq!(unknown(&mut s, json!({"ids": [b.0]})), [(b.0, 7, 12, "wvxzq".to_string())]);
|
||
assert_eq!(unknown(&mut s, json!({"ids": null})).len(), 2, "null ids is the default");
|
||
let both = [(a.0, 6, 11, "qzxvw".to_string()), (b.0, 7, 12, "wvxzq".to_string())];
|
||
assert_eq!(unknown(&mut s, json!({"ids": [b.0, a.0]})), both, "given ids are listed in paint order too");
|
||
for ids in [json!(b.0), json!("all"), json!({"id": b.0}), json!([-1]), json!(["x"]), json!([999_999])] {
|
||
assert!(s.execute("text.spelling.check", &json!({"ids": ids})).is_err(), "malformed ids {ids} is refused");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn a_language_without_a_dictionary_marks_nothing() {
|
||
let mut s = session();
|
||
let t = text(&mut s, 50.0, "qzxvw");
|
||
run(&mut s, "text.setFormat", json!({"ids": [t.0], "language": "German"}));
|
||
assert_eq!(unknown(&mut s, json!({})), [], "German has no spelling dictionary in craft-proof");
|
||
}
|
||
|
||
#[test]
|
||
fn suggest_offers_dictionary_words() {
|
||
let mut s = session();
|
||
let r = run(&mut s, "text.spelling.suggest", json!({"word": "drawng"}));
|
||
let got: Vec<&str> = r["suggestions"].as_array().unwrap().iter().map(|w| w.as_str().unwrap()).collect();
|
||
assert!(got.len() <= 5, "five at most by default: {got:?}");
|
||
assert!(got.contains(&"drawing"), "{got:?}");
|
||
assert_eq!(run(&mut s, "text.spelling.suggest", json!({"word": "drawng", "max": 1}))["suggestions"].as_array().unwrap().len(), 1);
|
||
assert!(s.execute("text.spelling.suggest", &json!({})).is_err(), "a word is required");
|
||
assert!(s.execute("text.spelling.suggest", &json!({"word": " "})).is_err(), "a blank word is refused");
|
||
for max in [json!(0), json!(21), json!(-1), json!("3")] {
|
||
assert!(s.execute("text.spelling.suggest", &json!({"word": "drawng", "max": max})).is_err(), "max {max}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn each_paragraph_is_checked_on_its_own_at_the_bytes_of_the_whole_text() {
|
||
let mut s = session();
|
||
// Read as one block, the Vietnamese first paragraph would make the whole text Vietnamese,
|
||
// which has no dictionary, and the English typo below it would go unmarked.
|
||
let vi = "Cảm ơn những người bạn";
|
||
let t = text(&mut s, 50.0, &format!("{vi}\ndrawing qzxvw tools"));
|
||
let at = vi.len() + 1 + "drawing ".len();
|
||
assert_eq!(unknown(&mut s, json!({})), [(t.0, at as u64, at as u64 + 5, "qzxvw".to_string())]);
|
||
}
|
||
|
||
// The custom dictionary is craft-proof's, shared by the whole process, so each test below uses
|
||
// made-up words of its own: tests running at the same time never see each other's.
|
||
|
||
/// The words a check of the whole active document lists.
|
||
fn marked(s: &mut Session) -> Vec<String> {
|
||
unknown(s, json!({})).into_iter().map(|w| w.3).collect()
|
||
}
|
||
|
||
#[test]
|
||
fn added_words_are_right_in_every_check_until_deleted() {
|
||
let _one_at_a_time = dictionary_lock();
|
||
let mut s = session();
|
||
text(&mut s, 50.0, "drawing Zqvwkx tools");
|
||
assert_eq!(marked(&mut s), ["Zqvwkx"]);
|
||
// Kept in lower case, so the capitalized word is right too.
|
||
let r = run(&mut s, "text.spelling.addWord", json!({"word": " Zqvwkx "}));
|
||
assert_eq!((r["word"].as_str(), r["added"].as_bool()), (Some("zqvwkx"), Some(true)));
|
||
assert_eq!(marked(&mut s), Vec::<String>::new());
|
||
assert_eq!(run(&mut s, "text.spelling.addWord", json!({"word": "zqvwkx"}))["added"], false, "already there");
|
||
let words = run(&mut s, "text.spelling.dictionary", json!({}))["words"].clone();
|
||
assert!(words.as_array().unwrap().contains(&json!("zqvwkx")), "{words}");
|
||
// Another document's check takes it as right too.
|
||
s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
|
||
text(&mut s, 50.0, "zqvwkx");
|
||
assert_eq!(marked(&mut s), Vec::<String>::new());
|
||
run(&mut s, "text.spelling.removeWord", json!({"word": "ZQVWKX"}));
|
||
assert_eq!(marked(&mut s), ["zqvwkx"]);
|
||
let e = s.execute("text.spelling.removeWord", &json!({"word": "zqvwkx"})).unwrap_err().to_string();
|
||
assert!(e.contains("isn't in the custom dictionary"), "{e}");
|
||
}
|
||
|
||
#[test]
|
||
fn a_changed_word_replaces_the_old_one() {
|
||
let _one_at_a_time = dictionary_lock();
|
||
let mut s = session();
|
||
text(&mut s, 50.0, "xkvzqa xkvzqb");
|
||
run(&mut s, "text.spelling.addWord", json!({"word": "xkvzqa"}));
|
||
assert_eq!(marked(&mut s), ["xkvzqb"]);
|
||
assert_eq!(run(&mut s, "text.spelling.changeWord", json!({"word": "xkvzqa", "to": "Xkvzqb"}))["word"], "xkvzqb");
|
||
assert_eq!(marked(&mut s), ["xkvzqa"]);
|
||
let e = s.execute("text.spelling.changeWord", &json!({"word": "xkvzqa", "to": "x"})).unwrap_err().to_string();
|
||
assert!(e.contains("isn't in the custom dictionary"), "{e}");
|
||
run(&mut s, "text.spelling.removeWord", json!({"word": "xkvzqb"}));
|
||
}
|
||
|
||
#[test]
|
||
fn the_custom_dictionary_file_is_read_and_kept_up_to_date() {
|
||
let _one_at_a_time = dictionary_lock();
|
||
let dir = vectorcraft_testkit::TempDir::new("spelling-dictionary");
|
||
let file = dir.join("Custom Dictionary.txt");
|
||
std::fs::write(&file, "kqzvwx\nnot one word\n\n").unwrap();
|
||
let mut s = session();
|
||
s.attach_custom_dictionary(file.clone());
|
||
text(&mut s, 50.0, "kqzvwx vkqzwx");
|
||
assert_eq!(marked(&mut s), ["vkqzwx"], "the file's word is right; its line of three words is skipped");
|
||
run(&mut s, "text.spelling.addWord", json!({"word": "vkqzwx"}));
|
||
let saved = std::fs::read_to_string(&file).unwrap();
|
||
assert!(saved.lines().any(|l| l == "kqzvwx") && saved.lines().any(|l| l == "vkqzwx"), "{saved}");
|
||
run(&mut s, "text.spelling.changeWord", json!({"word": "kqzvwx", "to": "kqzvwy"}));
|
||
run(&mut s, "text.spelling.removeWord", json!({"word": "vkqzwx"}));
|
||
let saved = std::fs::read_to_string(&file).unwrap();
|
||
assert!(saved.lines().any(|l| l == "kqzvwy"), "{saved}");
|
||
assert!(!saved.lines().any(|l| l == "kqzvwx" || l == "vkqzwx"), "changed and deleted words are gone from the file: {saved}");
|
||
run(&mut s, "text.spelling.removeWord", json!({"word": "kqzvwy"}));
|
||
}
|
||
|
||
#[test]
|
||
fn ignore_all_skips_a_word_in_the_active_document_only() {
|
||
let _one_at_a_time = dictionary_lock();
|
||
let mut s = session();
|
||
text(&mut s, 50.0, "Wqzxkv drawing wqzxkv vqzxkw");
|
||
run(&mut s, "text.spelling.ignoreAll", json!({"word": "WQZXKV"}));
|
||
assert_eq!(marked(&mut s), ["vqzxkw"], "every occurrence, whatever its case");
|
||
let words = run(&mut s, "text.spelling.dictionary", json!({}))["words"].clone();
|
||
assert!(!words.as_array().unwrap().contains(&json!("wqzxkv")), "not added to the custom dictionary");
|
||
s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
|
||
text(&mut s, 50.0, "wqzxkv");
|
||
assert_eq!(marked(&mut s), ["wqzxkv"], "another document still marks it");
|
||
}
|
||
|
||
#[test]
|
||
fn custom_dictionary_commands_refuse_what_isnt_one_word() {
|
||
let _one_at_a_time = dictionary_lock();
|
||
let mut s = session();
|
||
let long = "q".repeat(65);
|
||
for (id, p) in [
|
||
("text.spelling.addWord", json!({})),
|
||
("text.spelling.addWord", json!({"word": " "})),
|
||
("text.spelling.addWord", json!({"word": "two words"})),
|
||
("text.spelling.addWord", json!({"word": long})),
|
||
("text.spelling.addWord", json!({"word": 5})),
|
||
("text.spelling.removeWord", json!({})),
|
||
("text.spelling.changeWord", json!({"word": "qzx"})),
|
||
("text.spelling.changeWord", json!({"word": "qzx", "to": "a b"})),
|
||
("text.spelling.ignoreAll", json!({"word": "a\tb"})),
|
||
] {
|
||
assert!(s.execute(id, &p).is_err(), "{id} {p} is refused");
|
||
}
|
||
let mut empty = Session::new();
|
||
assert!(empty.execute("text.spelling.ignoreAll", &json!({"word": "qzx"})).is_err(), "Ignore All needs a document");
|
||
assert!(empty.execute("text.spelling.dictionary", &json!({})).is_ok(), "the dictionary is the app's");
|
||
}
|
||
|
||
/// Whether the custom dictionary holds `word`.
|
||
fn in_dictionary(s: &mut Session, word: &str) -> bool {
|
||
run(s, "text.spelling.dictionary", json!({}))["words"].as_array().unwrap().contains(&json!(word))
|
||
}
|
||
|
||
#[test]
|
||
fn a_dictionary_file_that_cant_be_read_whole_is_never_written_over() {
|
||
let _one_at_a_time = dictionary_lock();
|
||
let dir = vectorcraft_testkit::TempDir::new("spelling-unreadable");
|
||
// A folder where the file should be can't be read as one; a file past what craft-proof reads
|
||
// would lose its other words if written back.
|
||
let folder = dir.join("Custom Dictionary.txt");
|
||
std::fs::create_dir_all(&folder).unwrap();
|
||
let big = dir.join("big.txt");
|
||
let words = "qkzvxw\n".repeat((MAX_DICTIONARY_FILE_BYTES / 7 + 2) as usize);
|
||
std::fs::write(&big, &words).unwrap();
|
||
for path in [folder.clone(), big.clone()] {
|
||
let mut s = session();
|
||
s.attach_custom_dictionary(path.clone());
|
||
let e = s.execute("text.spelling.addWord", &json!({"word": "zkqvxw"})).unwrap_err().to_string();
|
||
assert!(e.contains("can't be read"), "{}: {e}", path.display());
|
||
assert!(!in_dictionary(&mut s, "zkqvxw"), "the refused word isn't kept either");
|
||
}
|
||
assert!(folder.is_dir());
|
||
assert_eq!(std::fs::read_to_string(&big).unwrap(), words, "the large file is as it was");
|
||
}
|
||
|
||
#[test]
|
||
fn a_change_that_cant_be_saved_is_taken_back() {
|
||
let _one_at_a_time = dictionary_lock();
|
||
let mut s = session();
|
||
run(&mut s, "text.spelling.addWord", json!({"word": "wkqzvx"}));
|
||
let dir = vectorcraft_testkit::TempDir::new("spelling-rollback");
|
||
let folder = dir.join("Custom Dictionary.txt");
|
||
std::fs::create_dir_all(&folder).unwrap();
|
||
let mut failing = session();
|
||
failing.attach_custom_dictionary(folder);
|
||
assert!(failing.execute("text.spelling.removeWord", &json!({"word": "wkqzvx"})).is_err());
|
||
assert!(in_dictionary(&mut s, "wkqzvx"), "a delete that wasn't saved leaves the word");
|
||
assert!(failing.execute("text.spelling.changeWord", &json!({"word": "wkqzvx", "to": "wkqzvy"})).is_err());
|
||
assert!(in_dictionary(&mut s, "wkqzvx") && !in_dictionary(&mut s, "wkqzvy"), "a change that wasn't saved leaves the old word");
|
||
run(&mut s, "text.spelling.removeWord", json!({"word": "wkqzvx"}));
|
||
}
|
||
|
||
/// Edit Custom Dictionary's Done: its deletes and adds are saved together, or, when the save
|
||
/// fails, none of them is kept (a delete saved before an add that failed would stay otherwise).
|
||
#[test]
|
||
fn a_dictionary_edit_is_saved_whole_or_not_at_all() {
|
||
let _one_at_a_time = dictionary_lock();
|
||
const EDIT: &str = "text.spelling.editDictionary";
|
||
let dir = vectorcraft_testkit::TempDir::new("spelling-edit");
|
||
let file = dir.join("Custom Dictionary.txt");
|
||
std::fs::write(&file, "pqzvka\npqzvkb\n").unwrap();
|
||
let mut s = session();
|
||
s.attach_custom_dictionary(file.clone());
|
||
// A word already gone and a word already there are skipped; added words are kept in lower case.
|
||
let r = run(&mut s, EDIT, json!({"remove": ["pqzvka", "pqzvkz"], "add": ["PqzvkC", "pqzvkb"]}));
|
||
assert_eq!(r, json!({"removed": ["pqzvka"], "added": ["pqzvkc"]}));
|
||
let saved = std::fs::read_to_string(&file).unwrap();
|
||
let lines: Vec<&str> = saved.lines().collect();
|
||
assert!(lines.contains(&"pqzvkb") && lines.contains(&"pqzvkc") && !lines.contains(&"pqzvka"), "{saved}");
|
||
// A save that fails takes back every delete and add.
|
||
let folder = dir.join("folder");
|
||
std::fs::create_dir_all(&folder).unwrap();
|
||
let mut failing = session();
|
||
failing.attach_custom_dictionary(folder);
|
||
assert!(failing.execute(EDIT, &json!({"remove": ["pqzvkb", "pqzvkc"], "add": ["pqzvkd"]})).is_err());
|
||
assert!(in_dictionary(&mut s, "pqzvkb") && in_dictionary(&mut s, "pqzvkc"), "the deletes are taken back");
|
||
assert!(!in_dictionary(&mut s, "pqzvkd"), "the add is taken back");
|
||
// A list that isn't one of words is refused before anything changes.
|
||
let many: Vec<String> = (0..10_001).map(|i| format!("pqzv{i}")).collect();
|
||
for p in [json!({"remove": "pqzvkb"}), json!({"add": ["a b"]}), json!({"add": [5]}), json!({"remove": ["pqzvkb"], "add": many})] {
|
||
assert!(s.execute(EDIT, &p).is_err(), "{EDIT} refuses a bad list");
|
||
assert!(in_dictionary(&mut s, "pqzvkb"), "{EDIT} changed nothing");
|
||
}
|
||
let e = s.execute(EDIT, &json!({"add": ["a b"]})).unwrap_err().to_string();
|
||
assert!(e.contains("must hold single words of at most 64 characters"), "{e}");
|
||
run(&mut s, EDIT, json!({"remove": ["pqzvkb", "pqzvkc"]}));
|
||
assert!(!in_dictionary(&mut s, "pqzvkb") && !in_dictionary(&mut s, "pqzvkc"));
|
||
}
|
||
|
||
#[cfg(unix)]
|
||
#[test]
|
||
fn a_word_another_window_saved_stays_when_this_save_fails() {
|
||
let _one_at_a_time = dictionary_lock();
|
||
use std::os::unix::fs::PermissionsExt;
|
||
let dir = vectorcraft_testkit::TempDir::new("spelling-readonly");
|
||
let file = dir.join("Custom Dictionary.txt");
|
||
std::fs::write(&file, "").unwrap();
|
||
let mut s = session();
|
||
s.attach_custom_dictionary(file.clone());
|
||
// Another window saves a word this session hasn't taken in, then the folder can't be written:
|
||
// the save reads the file, takes the word in, and fails writing.
|
||
std::fs::write(&file, "zvkqxw\n").unwrap();
|
||
std::fs::set_permissions(&dir, std::fs::Permissions::from_mode(0o500)).unwrap();
|
||
let probe = dir.join("probe");
|
||
let writable = std::fs::write(&probe, "").is_ok();
|
||
let r = (!writable).then(|| s.execute("text.spelling.addWord", &json!({"word": "zvkqxw"})));
|
||
std::fs::set_permissions(&dir, std::fs::Permissions::from_mode(0o700)).unwrap();
|
||
let Some(r) = r else {
|
||
// Run as root, the folder stays writable: there is no failing save to check.
|
||
return;
|
||
};
|
||
assert!(r.is_err(), "{r:?}");
|
||
assert!(in_dictionary(&mut s, "zvkqxw"), "the word in the file stays, though this Add was taken back");
|
||
run(&mut s, "text.spelling.removeWord", json!({"word": "zvkqxw"}));
|
||
}
|
||
|
||
/// `misspellings` finds in one type object what the check lists for it, stops at the most it is
|
||
/// asked for and says so, and leaves out the Ignore All words it is given.
|
||
#[test]
|
||
fn misspellings_of_one_object_are_what_the_check_lists() {
|
||
use crate::cmd::spelling::misspellings;
|
||
let mut s = session();
|
||
let id = text(&mut s, 50.0, "the Vqzrtwx cat\nsat Wzqrvtx Xqrzvtw");
|
||
let listed: Vec<_> = unknown(&mut s, json!({"ids": [id.0]})).into_iter().map(|(_, a, b, _)| a as usize..b as usize).collect();
|
||
let st = s.doc().unwrap();
|
||
let Some(vectorcraft_doc::NodeKind::Text(t)) = st.doc.node(id).map(|n| n.kind.clone()) else { panic!("type") };
|
||
let none = Default::default();
|
||
let (found, cut) = misspellings(&t, &none, 10);
|
||
assert_eq!((found.iter().map(|m| m.range.clone()).collect::<Vec<_>>(), cut), (listed.clone(), false));
|
||
assert!(found.iter().all(|m| m.lang.tag() == "en"), "{found:?}");
|
||
let (first, cut) = misspellings(&t, &none, 2);
|
||
assert_eq!((first.iter().map(|m| m.range.clone()).collect::<Vec<_>>(), cut), (listed[..2].to_vec(), true));
|
||
let ignored = std::collections::BTreeSet::from(["wzqrvtx".to_string()]);
|
||
let (found, _) = misspellings(&t, &ignored, 10);
|
||
assert_eq!(found.iter().map(|m| m.range.clone()).collect::<Vec<_>>(), [listed[0].clone(), listed[2].clone()]);
|
||
}
|
||
|
||
/// The (id, start, word) of each word a check lists, and its `more`.
|
||
fn listed(s: &mut Session, p: Value) -> (Vec<(u64, u64, String)>, bool) {
|
||
let r = run(s, "text.spelling.check", p);
|
||
let words = r["words"]
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.map(|w| (w["id"].as_u64().unwrap(), w["start"].as_u64().unwrap(), w["word"].as_str().unwrap().to_string()))
|
||
.collect();
|
||
(words, r["more"].as_bool().unwrap())
|
||
}
|
||
|
||
/// A check cut short at `max` goes on with `from` at the end of the last word listed: the rest of
|
||
/// that type object first, then the objects after it, and nothing listed twice.
|
||
#[test]
|
||
fn a_check_goes_on_from_where_the_last_one_stopped() {
|
||
let mut s = session();
|
||
let a = text(&mut s, 50.0, "qzxvw one wvxzq two\nthree qqzzx");
|
||
let b = text(&mut s, 100.0, "zzqqx");
|
||
let (first, more) = listed(&mut s, json!({"max": 2}));
|
||
assert_eq!((first.clone(), more), (vec![(a.0, 0, "qzxvw".into()), (a.0, 10, "wvxzq".into())], true));
|
||
// From the end of the second word: the third, in the next paragraph of the same object, not
|
||
// the start of the next object.
|
||
let (rest, more) = listed(&mut s, json!({"from": {"id": a.0, "byte": 15}, "max": 2}));
|
||
assert_eq!((rest, more), (vec![(a.0, 26, "qqzzx".into()), (b.0, 0, "zzqqx".into())], false));
|
||
// A byte inside a word starts from the next word.
|
||
let (rest, _) = listed(&mut s, json!({"from": {"id": a.0, "byte": 1}}));
|
||
assert_eq!(rest.first(), Some(&(a.0, 10, "wvxzq".to_string())));
|
||
// `from` follows the ids given, groups' type included.
|
||
run(&mut s, "select.set", json!({"ids": [a.0, b.0]}));
|
||
let g = run(&mut s, "object.group", json!({}))["id"].as_u64().unwrap();
|
||
let (rest, more) = listed(&mut s, json!({"ids": [g], "from": {"id": a.0, "byte": 26}, "max": 1}));
|
||
assert_eq!((rest, more), (vec![(a.0, 26, "qqzzx".into())], true));
|
||
let (rest, more) = listed(&mut s, json!({"ids": [g], "from": {"id": a.0, "byte": 31}, "max": 1}));
|
||
assert_eq!((rest, more), (vec![(b.0, 0, "zzqqx".into())], false));
|
||
let bad = [
|
||
json!({"from": {"id": a.0}}),
|
||
json!({"from": {"id": a.0, "byte": -1}}),
|
||
json!({"from": {"id": a.0, "byte": 1000}}),
|
||
json!({"from": {"id": a.0, "byte": 0, "x": 1}}),
|
||
json!({"from": a.0}),
|
||
json!({"ids": [b.0], "from": {"id": a.0, "byte": 0}}),
|
||
json!({"max": 0}),
|
||
json!({"max": 10_001}),
|
||
json!({"max": "2"}),
|
||
];
|
||
for p in bad {
|
||
assert!(s.execute("text.spelling.check", &p).is_err(), "{p} is refused");
|
||
}
|
||
}
|
||
|
||
/// One type object with one unknown word more than a check lists: going on from the last word
|
||
/// listed reaches the last one.
|
||
#[test]
|
||
fn a_check_past_the_limit_in_one_object_goes_on_to_its_last_word() {
|
||
use crate::cmd::spelling::MAX_WORDS;
|
||
let mut s = session();
|
||
let t = text(&mut s, 50.0, &vec!["qzxvw"; MAX_WORDS + 1].join(" "));
|
||
let r = run(&mut s, "text.spelling.check", json!({}));
|
||
let words = r["words"].as_array().unwrap();
|
||
assert_eq!((words.len(), &r["more"]), (MAX_WORDS, &json!(true)));
|
||
let end = words.last().unwrap()["end"].as_u64().unwrap();
|
||
let (rest, more) = listed(&mut s, json!({"from": {"id": t.0, "byte": end}}));
|
||
assert_eq!((rest, more), (vec![(t.0, end + 1, "qzxvw".into())], false));
|
||
}
|
||
|
||
/// The plain text of type object `id`.
|
||
fn plain(s: &Session, id: NodeId) -> String {
|
||
match &s.doc().unwrap().doc.node(id).unwrap().kind {
|
||
vectorcraft_doc::NodeKind::Text(t) => t.plain_text(),
|
||
_ => panic!("not type"),
|
||
}
|
||
}
|
||
|
||
/// Change All's command replaces every word listed, in several objects, as one undo step, and
|
||
/// refuses a list with any word not in its object's text, changing nothing.
|
||
#[test]
|
||
fn change_all_replaces_every_word_listed_in_one_undo_step() {
|
||
let mut s = session();
|
||
let a = text(&mut s, 50.0, "qzxvw one qzxvw\nqzxvw");
|
||
let b = text(&mut s, 100.0, "é qzxvw");
|
||
let depth = s.doc().unwrap().history.undo.len();
|
||
let words = json!([{"id": a.0, "start": 16, "end": 21}, {"id": a.0, "start": 0, "end": 5}, {"id": b.0, "start": 3, "end": 8}, {"id": a.0, "start": 10, "end": 15}]);
|
||
let r = run(&mut s, "text.spelling.change", json!({"to": "fixed", "words": words}));
|
||
assert_eq!(r["changed"], 4);
|
||
assert_eq!((plain(&s, a), plain(&s, b)), ("fixed one fixed\nfixed".to_string(), "é fixed".to_string()));
|
||
assert_eq!(s.doc().unwrap().history.undo.len(), depth + 1);
|
||
run(&mut s, "edit.undo", json!({}));
|
||
assert_eq!((plain(&s, a), plain(&s, b)), ("qzxvw one qzxvw\nqzxvw".to_string(), "é qzxvw".to_string()));
|
||
let bad = [
|
||
json!({"to": "x", "words": [{"id": a.0, "start": 0, "end": 5}, {"id": a.0, "start": 3, "end": 8}]}),
|
||
json!({"to": "x", "words": [{"id": a.0, "start": 0, "end": 5}, {"id": a.0, "start": 20, "end": 99}]}),
|
||
json!({"to": "x", "words": [{"id": b.0, "start": 1, "end": 4}]}),
|
||
json!({"to": "x", "words": [{"id": a.0, "start": 5, "end": 5}]}),
|
||
json!({"to": "x", "words": [{"id": a.0, "start": 0, "end": 5, "x": 1}]}),
|
||
json!({"to": "x", "words": [{"id": a.0, "start": -1, "end": 5}]}),
|
||
json!({"to": "x", "words": [{"id": 999_999, "start": 0, "end": 5}]}),
|
||
json!({"to": "x", "words": {"id": a.0}}),
|
||
json!({"words": []}),
|
||
];
|
||
for p in bad {
|
||
assert!(s.execute("text.spelling.change", &p).is_err(), "{p} is refused");
|
||
}
|
||
assert_eq!(plain(&s, a), "qzxvw one qzxvw\nqzxvw", "nothing changed by a refused list");
|
||
assert_eq!(run(&mut s, "text.spelling.change", json!({"to": "x", "words": []}))["changed"], 0);
|
||
}
|
||
|
||
/// A listed word that already reads as `to` is left alone: with no other word, no edit and no
|
||
/// undo step, so the redo history stays.
|
||
#[test]
|
||
fn change_all_skips_words_that_already_read_as_the_replacement() {
|
||
let mut s = session();
|
||
let a = text(&mut s, 50.0, "fixed qzxvw");
|
||
run(&mut s, "text.editRange", json!({"id": a.0, "start": 6, "end": 11, "insert": "other"}));
|
||
run(&mut s, "edit.undo", json!({}));
|
||
let (undo, redo) = {
|
||
let h = &s.doc().unwrap().history;
|
||
(h.undo.len(), h.redo.len())
|
||
};
|
||
let r = run(&mut s, "text.spelling.change", json!({"to": "fixed", "words": [{"id": a.0, "start": 0, "end": 5}]}));
|
||
assert_eq!(r["changed"], 0);
|
||
let h = &s.doc().unwrap().history;
|
||
assert_eq!((h.undo.len(), h.redo.len()), (undo, redo), "no undo step, and redo kept");
|
||
let words = json!([{"id": a.0, "start": 0, "end": 5}, {"id": a.0, "start": 6, "end": 11}]);
|
||
assert_eq!(run(&mut s, "text.spelling.change", json!({"to": "fixed", "words": words}))["changed"], 1);
|
||
assert_eq!(plain(&s, a), "fixed fixed");
|
||
}
|
||
|
||
/// Each change to the custom dictionary moves its generation on, whether it is saved or not, so
|
||
/// what Auto Spell Check found before is checked again.
|
||
#[test]
|
||
fn custom_dictionary_changes_move_its_generation_on() {
|
||
let _one_at_a_time = dictionary_lock();
|
||
use crate::cmd::spelling::dictionary_generation;
|
||
let mut s = session();
|
||
let mut last = dictionary_generation();
|
||
let mut moved = |s: &mut Session, id: &str, p: Value| {
|
||
let _ = s.execute(id, &p);
|
||
let now = dictionary_generation();
|
||
let on = now > last;
|
||
last = now;
|
||
on
|
||
};
|
||
assert!(moved(&mut s, "text.spelling.addWord", json!({"word": "Gqzvrtx"})), "add");
|
||
assert!(moved(&mut s, "text.spelling.changeWord", json!({"word": "gqzvrtx", "to": "hqzvrtx"})), "change");
|
||
assert!(moved(&mut s, "text.spelling.removeWord", json!({"word": "hqzvrtx"})), "delete");
|
||
}
|