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

/*
let message "Did you mean `by accident`?"
let description "Incorrect preposition: `by accident` is the idiomatic expression."
 */

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

pub struct ByAccident {
    expr: SequenceExpr,
}

impl Default for ByAccident {
    fn default() -> Self {
        Self {
            expr: SequenceExpr::aco("on")
                .t_ws()
                .then_optional(
                    SequenceExpr::word_set(&[
                        "complete", "happy", "literal", "mere", "pure", "sheer", "total",
                    ])
                    .t_ws(),
                )
                .t_aco("accident"),
        }
    }
}

impl ExprLinter for ByAccident {
    type Unit = Chunk;

    fn description(&self) -> &str {
        "Incorrect preposition: `by accident` is the idiomatic expression."
    }

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

    fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
        let span = toks.first()?.span;
        let suggestions = vec![Suggestion::replace_with_match_case_str(
            "by",
            span.get_content(src),
        )];

        Some(Lint {
            span,
            lint_kind: LintKind::Usage,
            suggestions,
            message: "Did you mean `by accident`?".to_string(),
            ..Default::default()
        })
    }
}

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

    #[test]
    fn fix_on_accident() {
        assert_suggestion_result(
            "Snapshot revert feature is unintuitive and easy to use on accident.",
            ByAccident::default(),
            "Snapshot revert feature is unintuitive and easy to use by accident.",
        );
    }

    #[test]
    fn fix_on_complete_accident() {
        assert_suggestion_result(
            "I Came across this comment on complete accident, however, I did notice the same thing with a slowdown in chrome for android",
            ByAccident::default(),
            "I Came across this comment by complete accident, however, I did notice the same thing with a slowdown in chrome for android",
        );
    }

    #[test]
    fn fix_on_happy_accident() {
        assert_suggestion_result(
            "Just did this on happy accident the other day with my partner.",
            ByAccident::default(),
            "Just did this by happy accident the other day with my partner.",
        );
    }

    #[test]
    fn fix_on_literal_accident() {
        assert_suggestion_result(
            "I did this on literal accident, trying to prove someone wrong that its not that easy.",
            ByAccident::default(),
            "I did this by literal accident, trying to prove someone wrong that its not that easy.",
        );
    }

    #[test]
    fn fix_on_mere_accident() {
        assert_suggestion_result(
            "I hated this challenge and nope I don't I completed it on mere accident.",
            ByAccident::default(),
            "I hated this challenge and nope I don't I completed it by mere accident.",
        );
    }

    #[test]
    fn fix_on_pure_accident() {
        assert_suggestion_result(
            "I got this on pure accident after forgetting to enable WebGL on LibreWolf",
            ByAccident::default(),
            "I got this by pure accident after forgetting to enable WebGL on LibreWolf",
        );
    }

    #[test]
    fn fix_on_sheer_accident() {
        assert_suggestion_result(
            "I more of think of things that got discovered on sheer accident, something no normal human would just do and expect results.",
            ByAccident::default(),
            "I more of think of things that got discovered by sheer accident, something no normal human would just do and expect results.",
        );
    }

    #[test]
    fn fix_on_total_accident() {
        assert_suggestion_result(
            "On Total Accident, I Found Out Yona's True Title.",
            ByAccident::default(),
            "By Total Accident, I Found Out Yona's True Title.",
        );
    }
}