codebook 0.3.37

A code-aware spell checker library (dependency for codebook-lsp)
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

use codebook::{
    parser::{TextRange, WordLocation},
    queries::LanguageType,
};

mod utils;

#[test]
fn test_ocaml_location() {
    utils::init_logging();
    let sample_text = r#"
(* Commment with a typo *)
type usr_recrod = {
  name: string;
  agge: int;
}
let greet_usr (persn : usr_recrod) =
  let msega = "Helllo " ^ persn.name in
  print_endline msega
let () =
  let u = { name = "Alise"; agge = 30 } in
  greet_usr u
"#;

    let expected = vec![
        WordLocation::new(
            "Commment".to_string(),
            vec![TextRange {
                start_byte: 4,
                end_byte: 12,
            }],
        ),
        WordLocation::new(
            "recrod".to_string(),
            vec![
                // type definition
                TextRange {
                    start_byte: 37,
                    end_byte: 43,
                },
                // parameter annotation in greet_usr
                TextRange {
                    start_byte: 106,
                    end_byte: 112,
                },
            ],
        ),
        WordLocation::new(
            "agge".to_string(),
            vec![
                // field definition
                TextRange {
                    start_byte: 66,
                    end_byte: 70,
                },
                // field assignment in let u = { ... }
                TextRange {
                    start_byte: 215,
                    end_byte: 219,
                },
            ],
        ),
        WordLocation::new(
            "persn".to_string(),
            vec![TextRange {
                start_byte: 94,
                end_byte: 99,
            }],
        ),
        WordLocation::new(
            "msega".to_string(),
            vec![TextRange {
                start_byte: 122,
                end_byte: 127,
            }],
        ),
        WordLocation::new(
            "Helllo".to_string(),
            vec![TextRange {
                start_byte: 131,
                end_byte: 137,
            }],
        ),
        WordLocation::new(
            "Alise".to_string(),
            vec![TextRange {
                start_byte: 207,
                end_byte: 212,
            }],
        ),
    ];

    let not_expected = [
      "and", "as", "assert", "begin", "class", "constraint", "do", "done", "downto", "effect",
      "else", "end", "exception", "external", "for", "fun", "function", "functor", "if", "in",
      "include", "inherit", "initializer", "lazy", "let", "match", "method", "module",
      "mutable", "new", "nonrec", "object", "of", "open", "private", "rec", "sig", "struct",
      "then", "to", "try", "type", "val", "virtual", "when", "while", "with",
    ];

    let processor = utils::get_processor();
    let misspelled = processor
        .spell_check(sample_text, Some(LanguageType::OCaml), None)
        .to_vec();

    println!("Misspelled words: {misspelled:?}");

    for e in &expected {
        println!("Expecting: {e:?}");
        let miss = misspelled.iter().find(|r| r.word == e.word).unwrap();
        assert!(miss.locations.len() == e.locations.len());
        for location in &miss.locations {
            assert!(e.locations.contains(location));
        }
    }

    for result in misspelled {
        assert!(!not_expected.contains(&result.word.as_str()));
    }
}