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

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

pub struct InTimeFromNow {
    expr: SequenceExpr,
}

impl Default for InTimeFromNow {
    fn default() -> Self {
        Self {
            expr: SequenceExpr::aco("in")
                .t_ws()
                .then_optional(
                    SequenceExpr::word_set(&[
                        "about",
                        "almost",
                        "approximately",
                        "around",
                        "circa",
                        "exactly",
                        "just",
                        "maybe",
                        "nearly",
                        "only",
                        "perhaps",
                        "precisely",
                        "probably",
                        "roughly",
                    ])
                    .t_ws(),
                )
                .then(DurationExpr)
                .t_ws()
                .t_aco("from")
                .t_ws()
                .t_aco("now"),
        }
    }
}

impl ExprLinter for InTimeFromNow {
    type Unit = Chunk;

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

    fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
        let without_in: Vec<char> = toks[2..].span()?.get_content(src).to_vec();
        let without_from_now: Vec<char> = toks[..toks.len() - 4].span()?.get_content(src).to_vec();

        let template_chars = toks.span()?.get_content(src);

        Some(Lint {
            span: toks.span()?,
            lint_kind: LintKind::Redundancy,
            message: "Avoid redundancy by using either `in [period of time]` or `[period of time] from now`, but not both together.".to_string(),
            suggestions: vec![
                Suggestion::replace_with_match_case(without_in, template_chars),
                Suggestion::replace_with_match_case(without_from_now, template_chars),
            ],
            ..Default::default()
        })
    }

    fn description(&self) -> &str {
        "Checks for redundant use of `in` before [period of time] together with `from now` after it."
    }
}

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

    #[test]
    fn in_three_years_from_now() {
        assert_good_and_bad_suggestions(
            "Closing this issue now to prevent it from still being open in three years from now.",
            InTimeFromNow::default(),
            &[
                "Closing this issue now to prevent it from still being open in three years.",
                "Closing this issue now to prevent it from still being open three years from now.",
            ],
            &[],
        );
    }

    #[test]
    fn in_2_seconds_from_now() {
        assert_good_and_bad_suggestions(
            "The task will be executed in 2 seconds from now.",
            InTimeFromNow::default(),
            &[
                "The task will be executed 2 seconds from now.",
                "The task will be executed in 2 seconds.",
            ],
            &[],
        );
    }

    #[test]
    fn in_three_weeks_from_now() {
        assert_good_and_bad_suggestions(
            "I have created a pull request, which can be merged in three weeks from now",
            InTimeFromNow::default(),
            &[
                "I have created a pull request, which can be merged in three weeks",
                "I have created a pull request, which can be merged three weeks from now",
            ],
            &[],
        );
    }

    #[test]
    fn in_2_hours_from_now() {
        assert_good_and_bad_suggestions(
            "send a notification every 30 minutes, starting in 2 hours from now",
            InTimeFromNow::default(),
            &[
                "send a notification every 30 minutes, starting 2 hours from now",
                "send a notification every 30 minutes, starting in 2 hours",
            ],
            &[],
        );
    }

    #[test]
    fn in_two_weeks_from_now() {
        assert_good_and_bad_suggestions(
            "That problem will be solved in two weeks from now by Bintray people.",
            InTimeFromNow::default(),
            &[
                "That problem will be solved two weeks from now by Bintray people.",
                "That problem will be solved in two weeks by Bintray people.",
            ],
            &[],
        );
    }
}