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

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

pub struct MeansALotTo {
    expr: SequenceExpr,
}

impl Default for MeansALotTo {
    fn default() -> Self {
        Self {
            expr: SequenceExpr::default()
                // Note that "meaning a lot to" is not used.
                .t_set(&["mean", "means", "meant"])
                .t_ws()
                .then_any_of(vec![
                    Box::new(FixedPhrase::from_phrase("a lot")),
                    Box::new(WordSet::new(&["alot", "lot"])),
                ])
                .t_ws()
                .t_aco("for"),
        }
    }
}

impl ExprLinter for MeansALotTo {
    type Unit = Chunk;

    fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
        if ![5, 7].contains(&toks.len()) {
            return None;
        }

        let (span, sug, msg) = match toks.len() {
            5 => (
                toks[2..5].span()?,
                "a lot to",
                "In this phrase the correct spelling is `a lot` and the correct preposition is `to`.",
            ),
            7 => (
                toks.last()?.span,
                "to",
                "The correct preposition in this phrase is `to`.",
            ),
            _ => return None,
        };
        Some(Lint {
            span,
            lint_kind: LintKind::Usage,
            suggestions: vec![Suggestion::replace_with_match_case(
                sug.chars().collect(),
                span.get_content(src),
            )],
            message: msg.to_string(),
            ..Default::default()
        })
    }

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

    fn description(&self) -> &str {
        "Corrects wrong variants of `means a lot for [someone]` to `means a lot to [someone]`."
    }
}

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

    use super::MeansALotTo;

    #[test]
    fn fix_mean_a_lot_for() {
        assert_suggestion_result(
            "It would mean a lot for me and save me a lot of time and effort",
            MeansALotTo::default(),
            "It would mean a lot to me and save me a lot of time and effort",
        );
    }

    #[test]
    fn fix_mean_alot_for() {
        assert_suggestion_result(
            "Appreciate it! Would mean alot for me!",
            MeansALotTo::default(),
            "Appreciate it! Would mean a lot to me!",
        );
    }

    #[test]
    fn fix_mean_lot_for() {
        assert_suggestion_result(
            "It would be very grateful to achieve number of sponsors for me and it mean lot for me.",
            MeansALotTo::default(),
            "It would be very grateful to achieve number of sponsors for me and it mean a lot to me.",
        );
    }

    #[test]
    fn fix_means_a_lot_for() {
        assert_suggestion_result(
            "Your star means a lot for us to develop this project!",
            MeansALotTo::default(),
            "Your star means a lot to us to develop this project!",
        );
    }

    #[test]
    fn fix_means_alot_for() {
        assert_suggestion_result(
            "Even a single sponsor means alot for me.",
            MeansALotTo::default(),
            "Even a single sponsor means a lot to me.",
        );
    }

    #[test]
    fn fix_means_lot_for() {
        assert_suggestion_result(
            "Any help means lot for me.",
            MeansALotTo::default(),
            "Any help means a lot to me.",
        );
    }

    #[test]
    fn fix_meant_a_lot_for() {
        assert_suggestion_result(
            "It meant a lot for me to improve this library further.",
            MeansALotTo::default(),
            "It meant a lot to me to improve this library further.",
        );
    }

    #[test]
    fn fix_meant_alot_for() {
        assert_suggestion_result(
            "Thanks a lot by the way. this meant alot for me.",
            MeansALotTo::default(),
            "Thanks a lot by the way. this meant a lot to me.",
        );
    }
}