harper-core 2.0.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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use crate::linting::expr_linter::Chunk;
use crate::{
    Token, TokenStringExt,
    expr::{Expr, SequenceExpr},
    linting::{ExprLinter, Lint, LintKind, Suggestion},
    patterns::NominalPhrase,
};

/// Linter that corrects "take X serious" to "take X seriously".
///
/// This linter identifies and corrects the common mistake of using the adjective "serious"
/// instead of the adverb "seriously" in phrases like "take it serious".
pub struct TakeSerious {
    expr: SequenceExpr,
}

impl Default for TakeSerious {
    /// Creates a new `TakeSerious` instance with the default pattern.
    ///
    /// The pattern matches:
    /// - Any form of "take" (take/takes/taking/took/taken)
    /// - Followed by a nominal phrase
    /// - Ending with "serious"
    fn default() -> Self {
        let pattern = SequenceExpr::word_set(&["take", "taken", "takes", "taking", "took"])
            .t_ws()
            .then(NominalPhrase)
            .t_ws()
            .t_aco("serious");

        Self { expr: pattern }
    }
}

impl ExprLinter for TakeSerious {
    type Unit = Chunk;

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

    fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Option<Lint> {
        let whole_phrase_span = matched_tokens.span()?;
        let all_but_last_token = matched_tokens[..matched_tokens.len() - 1].span()?;

        let mut sugg_value = all_but_last_token.get_content(source).to_vec();
        sugg_value.extend_from_slice(&['s', 'e', 'r', 'i', 'o', 'u', 's', 'l', 'y']);

        let sugg_template = whole_phrase_span.get_content(source);

        let suggestions = vec![Suggestion::replace_with_match_case(
            sugg_value,
            sugg_template,
        )];

        Some(Lint {
            span: whole_phrase_span,
            lint_kind: LintKind::WordChoice,
            suggestions,
            message: "Take seriously".to_string(),
            priority: 63,
        })
    }

    fn description(&self) -> &'static str {
        "Ensures the correct use of the adverb `seriously` instead of the adjective `serious` in phrases like `take it seriously`."
    }
}

#[cfg(test)]
mod tests {
    use crate::linting::tests::assert_suggestion_result;

    use super::TakeSerious;

    #[test]
    fn take_it() {
        assert_suggestion_result(
            "I take it serious.",
            TakeSerious::default(),
            "I take it seriously.",
        );
    }

    #[test]
    #[ignore = "'This' and 'that', which can be determiners and pronouns, are not handled properly by `NominalPhrase`"]
    fn take_this() {
        assert_suggestion_result(
            "What's more important is, that it's impossible to actually take this serious when ...",
            TakeSerious::default(),
            "What's more important is, that it's impossible to actually take this seriously when ...",
        );
    }

    #[test]
    fn not_take_security() {
        assert_suggestion_result(
            "When you say someone does not take security serious you are being judgemental / destructive.",
            TakeSerious::default(),
            "When you say someone does not take security seriously you are being judgemental / destructive.",
        );
    }

    #[test]
    fn we_take_security() {
        assert_suggestion_result(
            "We take security serious.",
            TakeSerious::default(),
            "We take security seriously.",
        );
    }

    #[test]
    fn take_me() {
        assert_suggestion_result(
            "Yeah , don't take me serious , i do this as a hobby - jusspatel.",
            TakeSerious::default(),
            "Yeah , don't take me seriously , i do this as a hobby - jusspatel.",
        );
    }

    #[test]
    #[ignore = "Passive voice and adverbs are not yet supported"]
    fn taken_adv() {
        assert_suggestion_result(
            "This is not meant to be taken overly serious",
            TakeSerious::default(),
            "This is not meant to be taken overly seriously",
        );
    }

    #[test]
    fn takes_these_numbers() {
        assert_suggestion_result(
            "if a program actually takes these numbers serious the results could be catastrophic.",
            TakeSerious::default(),
            "if a program actually takes these numbers seriously the results could be catastrophic.",
        );
    }

    #[test]
    #[ignore = "'No one' is not handled properly by `NominalPhrase`"]
    fn takes_bf() {
        assert_suggestion_result(
            "And obviously no one takes brainfuck serious as a language.",
            TakeSerious::default(),
            "And obviously no one takes brainfuck seriously as a language.",
        );
    }

    #[test]
    #[ignore = "Adverbs are not yet supported"]
    fn taken_very() {
        assert_suggestion_result(
            "Hmm flaky soldering iron is something that must be taken very serious.",
            TakeSerious::default(),
            "Hmm flaky soldering iron is something that must be taken very seriously.",
        );
    }
}