codebook 0.3.42

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use codebook::queries::LanguageType;

use super::utils::{assert_spelling, assert_spelling_at};

#[test]
fn test_just_comment() {
    assert_spelling(
        LanguageType::Just,
        "# A comentt with a tyypo\nbuild:\n    echo hi\n",
        &["comentt", "tyypo"],
        &[],
    );
}

#[test]
fn test_just_recipe_name_and_parameters() {
    // Recipe names and parameter names are checked.
    assert_spelling(
        LanguageType::Just,
        "buidl targt=\"debug\":\n    echo hi\n",
        &["buidl", "targt"],
        &[],
    );
}

#[test]
fn test_just_assignment_and_string() {
    assert_spelling(
        LanguageType::Just,
        "some_varable := \"a strng value\"\n",
        &["varable", "strng"],
        &[],
    );
}

#[test]
fn test_just_alias_definition() {
    // Only the alias name is a definition; the right side is a usage of a
    // recipe name that's already checked at its own definition.
    assert_spelling(
        LanguageType::Just,
        "alias bulid := build\nbuild:\n    echo hi\n",
        &["bulid"],
        &[],
    );
}

#[test]
fn test_just_setting_and_import_strings_skipped() {
    // Setting values and import paths are configuration, not prose.
    assert_spelling(
        LanguageType::Just,
        "set shell := [\"bsh\", \"-c\"]\nimport 'foo/badspeling.just'\n",
        &[],
        &["bsh", "badspeling"],
    );
}

#[test]
fn test_just_recipe_body_checked_as_bash() {
    let sample_text = r#"build:
    # a shel comentt
    echo "a strng with a tyypo"
    mkdir -p out
"#;
    // Comments and strings come from the injected bash grammar;
    // bash.scm doesn't capture command invocations, so mkdir isn't checked.
    assert_spelling(
        LanguageType::Just,
        sample_text,
        &["shel", "comentt", "strng", "tyypo"],
        &["mkdir"],
    );
}

#[test]
fn test_just_shebang_recipe_uses_language_grammar() {
    let sample_text = r#"build:
    #!/usr/bin/env python3
    # python comentt here
    msg = "a strng with a tyypo"
    def my_functin():
        pass
"#;
    // The shebang line itself is not spell-checked (usr, env).
    assert_spelling(
        LanguageType::Just,
        sample_text,
        &["comentt", "strng", "tyypo", "functin"],
        &["usr", "env"],
    );
}

#[test]
fn test_just_shebang_unknown_language_skipped() {
    assert_spelling(
        LanguageType::Just,
        "build:\n    #!/usr/bin/env unknownlang\n    badwwword stuff\n",
        &[],
        &["badwwword"],
    );
}

#[test]
fn test_just_interpolation_no_duplicate_spans() {
    // Strings inside interpolations are covered by the bash injection;
    // make sure the just-level string capture doesn't double-report them:
    // a duplicated span would show up as an extra, unexpected range.
    assert_spelling_at(
        LanguageType::Just,
        "build:\n    echo {{ \"a strng\" }}\n",
        &[("strng", &[0])],
    );
}

/// Ranges reported from the injected bash region must map back to original
/// document coordinates; `spell_check` in utils asserts every reported range
/// slices back to its word.
#[test]
fn test_just_injected_region_byte_offsets() {
    assert_spelling(
        LanguageType::Just,
        "build:\n    echo \"a tyypo here\"\n",
        &["tyypo"],
        &[],
    );
}

#[test]
fn test_just_filename_detection() {
    use codebook::queries::get_language_name_from_filename;
    assert_eq!(
        get_language_name_from_filename("justfile"),
        LanguageType::Just
    );
    assert_eq!(
        get_language_name_from_filename("Justfile"),
        LanguageType::Just
    );
    assert_eq!(
        get_language_name_from_filename("/some/path/justfile"),
        LanguageType::Just
    );
    assert_eq!(
        get_language_name_from_filename("/some/path/.justfile"),
        LanguageType::Just
    );
    assert_eq!(
        get_language_name_from_filename("recipes.just"),
        LanguageType::Just
    );
}