zspell 0.5.5

Native Rust library for spellchecking
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! Tests for a dict file

use std::fs;

use indoc::indoc;
use pretty_assertions::assert_eq;
use test_util::workspace_root;

use super::*;

#[test]
fn test_update_personal() {
    let personal_str = r"
        abcd po:verb
        efgh st:something
        *ijkl
        mnop
        qrst
        uvwx st:something
        *yz12 po:verb
        3456
    ";

    let mut d = Dictionary::new(ParsedCfg::default()).unwrap();
    d.parse_update_personal(personal_str, &[]).unwrap();
    assert!(d.wordlist.0.contains_key("abcd"));
    assert!(d.wordlist.0.contains_key("efgh"));
    assert!(!d.wordlist.0.contains_key("ijkl"));
    assert!(d.wordlist_forbidden.0.contains_key("ijkl"));
    assert!(d.check("abcd"));
    assert!(d.check("uvwx"));
    assert!(!d.check("ijkl"));

    let entry = d.entry("efgh");
    let stems: Vec<_> = entry.stems().unwrap().collect();
    assert_eq!(stems, vec!["efgh", "something"]);
}

#[test]
#[cfg(not(miri))] // slow!
fn test_builder() {
    let aff_content = fs::read_to_string("tests/files/w1_eng_short.aff").unwrap();
    let dic_content = fs::read_to_string("tests/files/w1_eng_short.dic").unwrap();
    let dict = DictBuilder::new()
        .config_str(&aff_content)
        .dict_str(&dic_content)
        .build()
        .unwrap();

    assert_eq!(dict.check("reptiles pillow bananas"), true);
    assert_eq!(dict.check("pine missssspelled"), false);
}

#[test]
fn test_builder_large_file() {
    let mut aff_path = workspace_root();
    aff_path.push("dictionaries");
    let mut dic_path = aff_path.clone();
    aff_path.push("en_US.aff");
    dic_path.push("en_US.dic");

    let Ok(aff_content) = fs::read_to_string(aff_path) else {
        eprintln!("skipping large test flies; not found");
        return;
    };

    let dic_content = fs::read_to_string(dic_path).unwrap();
    let dict = DictBuilder::new()
        .config_str(&aff_content)
        .dict_str(&dic_content)
        .build()
        .unwrap();

    assert_eq!(dict.check("reptiles pillow bananas"), true);
    assert_eq!(dict.check("pine missssspelled"), false);
}

// Test how data is inserted
#[test]
fn test_morph() {
    use crate::DictBuilder;

    let dict_str = "drink/X po:verb";
    let aff_str = indoc! {"
        SFX X Y 1
        SFX X 0 able . ds:able
    "};

    let d = DictBuilder::new()
        .dict_str(dict_str)
        .config_str(aff_str)
        .build()
        .unwrap();

    let meta = d.wordlist.0.get("drinkable").unwrap();
    assert_eq!(meta[0].stem(), "drink");
    assert_eq!(meta[1].stem(), "drink");
    assert!(matches!(
        meta[0].source(),
        Source::Affix {
            rule: _,
            pat_idx: 0
        }
    ));

    let Source::Dict(mvec) = meta[1].source() else {
        panic!()
    };

    let po = MorphInfo::Part(crate::PartOfSpeech::Verb);
    assert_eq!(mvec.as_ref(), [po.clone().into()]);

    let entry = d.entry("drinkable");
    let morph = entry.analyze().unwrap().collect::<Vec<_>>();
    assert_eq!(morph, [&MorphInfo::DerivSfx("able".into()), &po]);

    let stems = entry.stems().unwrap().collect::<Vec<_>>();
    assert_eq!(stems, ["drink"]);
    // assert_eq!(stems, ["drinkable", "drink"]);
}