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

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

pub struct VeryUnique {
    expr: SequenceExpr,
}

impl Default for VeryUnique {
    fn default() -> Self {
        Self {
            expr: SequenceExpr::word_set(&[
                "fairly", "pretty", "rather", "quite", "somewhat", "very",
            ])
            .t_ws()
            .t_aco("unique"),
        }
    }
}

impl ExprLinter for VeryUnique {
    type Unit = Chunk;

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

    fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
        let very_unique_span = toks.span()?;
        let very_unique_chars = very_unique_span.get_content(src);
        let qualifier_tok = &toks.first()?;
        let qualifier_str = qualifier_tok.get_str(src);

        let adjectives = ["special", "rare", "unusual"];

        let suggestions = adjectives
            .iter()
            .map(|adj| {
                Suggestion::replace_with_match_case(
                    format!("{qualifier_str} {adj}").chars().collect(),
                    very_unique_chars,
                )
            })
            .chain(std::iter::once(Suggestion::replace_with_match_case(
                "unique".chars().collect(),
                very_unique_chars,
            )))
            .collect::<Vec<_>>();

        Some(Lint {
            span: very_unique_span,
            lint_kind: LintKind::WordChoice,
            suggestions,
            message: "`Unique` is absolute, so consider using `unique` alone or a more precise adjective such as `special`, `rare`, or `unusual`.".to_string(),
            priority: 57,
        })
    }

    fn description(&self) -> &str {
        "Flags phrases like `very unique`, `pretty unique`, etc., and suggests using `unique` alone or a more precise adjective such as `special`, `rare`, or `unusual`."
    }
}

#[cfg(test)]
mod tests {
    use super::VeryUnique;
    use crate::linting::tests::{assert_good_and_bad_suggestions, assert_suggestion_result};

    #[test]
    fn fix_very_unique() {
        assert_good_and_bad_suggestions(
            "I'm not sure whether Llama Stack or ollama are generating the chat completion ids, but they are not very unique.",
            VeryUnique::default(),
            &[
                "I'm not sure whether Llama Stack or ollama are generating the chat completion ids, but they are not unique.",
            ],
            &[],
        );
    }

    #[test]
    fn fix_pretty_unique() {
        assert_suggestion_result(
            "Numerous accounts with my exact full name/surname (which is pretty unique) has been created (most recently).",
            VeryUnique::default(),
            "Numerous accounts with my exact full name/surname (which is pretty rare) has been created (most recently).",
        );
    }

    #[test]
    fn fix_fairly_unique() {
        assert_good_and_bad_suggestions(
            "In browsers, the first chars are obtained from the user agent string (which is fairly unique), and the supported mimeTypes",
            VeryUnique::default(),
            &[
                "In browsers, the first chars are obtained from the user agent string (which is unique), and the supported mimeTypes",
            ],
            &[],
        );
    }

    #[test]
    fn fix_somewhat_unique() {
        assert_suggestion_result(
            "A new pack of somewhat unique upgrades for R.E.P.O.!",
            VeryUnique::default(),
            "A new pack of somewhat unusual upgrades for R.E.P.O.!",
        );
    }

    #[test]
    fn fix_quite_unique() {
        assert_good_and_bad_suggestions(
            "Now I understand that this is quite unique to insta and if it's not useful I am also going to investigate alternatives",
            VeryUnique::default(),
            &[
                "Now I understand that this is unique to insta and if it's not useful I am also going to investigate alternatives",
            ],
            &[],
        );
    }

    #[test]
    fn fix_rather_unique() {
        assert_suggestion_result(
            "I regret using the Vue compiler because the resulting AST is rather unique.",
            VeryUnique::default(),
            "I regret using the Vue compiler because the resulting AST is rather unusual.",
        );
    }
}