harper-core 2.7.0

The language checker for developers.
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

use crate::{
    Dialect, Lint, Token,
    expr::{Expr, SequenceExpr},
    indefinite_article::{InitialSound, starts_with_vowel},
    linting::{ExprLinter, LintKind, Suggestion, expr_linter::Chunk},
};

pub struct HaveAHardTime {
    expr: SequenceExpr,
    dialect: Dialect,
}

impl HaveAHardTime {
    pub fn new(dialect: Dialect) -> Self {
        Self {
            expr: SequenceExpr::word_set(&["have", "had", "has", "having"])
                .then_optional(SequenceExpr::whitespace().t_set(&["extremely", "real"]))
                .t_ws()
                .then_word_seq(&["hard", "time"]),
            dialect,
        }
    }
}

impl ExprLinter for HaveAHardTime {
    type Unit = Chunk;

    fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
        let first_space_idx = 1;
        let next_word_idx = first_space_idx + 1;

        let suggestions = match starts_with_vowel(toks[next_word_idx].get_ch(src), self.dialect) {
            Some(InitialSound::Consonant) => &[&['a', ' '][..]][..],
            Some(InitialSound::Vowel) => &[&['a', 'n', ' '][..]][..],
            Some(InitialSound::Either) => &[&['a', ' '][..], &['a', 'n', ' '][..]][..],
            _ => return None,
        };

        Some(Lint {
            span: toks[first_space_idx].span,
            lint_kind: LintKind::Usage,
            suggestions: suggestions
                .iter()
                .map(|s| Suggestion::InsertAfter(s.to_vec()))
                .collect(),
            message: "This idiom requires the indefinite article `a`.".to_string(),
            ..Default::default()
        })
    }

    fn expr(&self) -> &dyn Expr {
        &self.expr
    }

    fn description(&self) -> &str {
        "Corrects `have hard time` to `have a hard time`."
    }
}

#[cfg(test)]
mod tests {
    use super::HaveAHardTime;
    use crate::{
        Dialect,
        linting::tests::{assert_no_lints, assert_suggestion_result},
    };

    #[test]
    fn had() {
        assert_suggestion_result(
            "I also had hard time to investigate why debug(error) only shows stack traces, but no other visible properties",
            HaveAHardTime::new(Dialect::American),
            "I also had a hard time to investigate why debug(error) only shows stack traces, but no other visible properties",
        );
    }

    #[test]
    fn has() {
        assert_suggestion_result(
            "Typescript has hard time finding declaration file for petite-vue",
            HaveAHardTime::new(Dialect::American),
            "Typescript has a hard time finding declaration file for petite-vue",
        );
    }

    #[test]
    fn have() {
        assert_suggestion_result(
            "I have hard time running getMeasuringContext(text, optionsopt) function.",
            HaveAHardTime::new(Dialect::American),
            "I have a hard time running getMeasuringContext(text, optionsopt) function.",
        );
    }

    #[test]
    fn having() {
        assert_suggestion_result(
            "Instructions for those who are having hard time to install from scratch.",
            HaveAHardTime::new(Dialect::American),
            "Instructions for those who are having a hard time to install from scratch.",
        );
    }

    #[test]
    fn having_extremely() {
        assert_suggestion_result(
            "Bug: having extremely hard time converting html",
            HaveAHardTime::new(Dialect::American),
            "Bug: having an extremely hard time converting html",
        );
    }

    #[test]
    fn having_real() {
        assert_suggestion_result(
            "I am having real hard time integrating kalidokit (face+body tracking)",
            HaveAHardTime::new(Dialect::American),
            "I am having a real hard time integrating kalidokit (face+body tracking)",
        );
    }

    // Oddities and potential false positives

    #[test]
    fn dont_flag_an_hard_time() {
        assert_no_lints(
            "This feature will have an hard time working well with the other ...",
            HaveAHardTime::new(Dialect::American),
        );
    }

    #[test]
    fn dont_flag_some_hard_time() {
        assert_no_lints(
            "we had some hard time finding the right tk because 8.6 has a \"t\" suffix.",
            HaveAHardTime::new(Dialect::American),
        );
    }
}