autocorrect 2.14.2

A linter and formatter for help you improve copywriting, to correct spaces, words, punctuations between CJK (Chinese, Japanese, Korean).
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

use std::borrow::Cow;

use crate::config::SeverityMode;
use crate::result::Severity;

pub(crate) struct Rule {
    #[allow(dead_code)]
    pub name: String,
    pub format_fn: for<'a> fn(input: &'a str) -> Cow<'a, str>,
}

#[derive(Default)]
pub(crate) struct RuleResult<'a> {
    pub out: Cow<'a, str>,
    pub severity: Severity,
}

impl<'a> RuleResult<'a> {
    pub fn new(input: &'a str) -> Self {
        Self {
            out: Cow::Borrowed(input),
            ..Default::default()
        }
    }
}

impl Rule {
    pub fn new(name: &str, format: for<'a> fn(input: &'a str) -> Cow<'a, str>) -> Self {
        Rule {
            name: name.to_string(),
            format_fn: format,
        }
    }

    pub fn format(&self, result: &mut RuleResult) {
        if self.severity() != SeverityMode::Error {
            return;
        }

        if let Cow::Owned(new) = (self.format_fn)(&result.out) {
            result.severity = Severity::Error;
            result.out = Cow::Owned(new);
        }
    }

    pub fn lint(&self, result: &mut RuleResult) {
        if self.severity() == SeverityMode::Off {
            return;
        }

        if let Cow::Owned(new) = (self.format_fn)(&result.out) {
            if result.severity == Severity::Pass {
                if self.severity() == SeverityMode::Warning {
                    result.severity = Severity::Warning;
                } else {
                    result.severity = Severity::Error;
                }
            }
            result.out = Cow::Owned(new);
        }
    }

    fn severity(&self) -> SeverityMode {
        let config = crate::Config::current();

        if let Some(s) = config.rules.get(&self.name) {
            *s
        } else {
            SeverityMode::Off
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_rule_not_pass() {
        let rule = Rule::new("space-word", |input| Cow::Owned(format!("{input} - foo")));
        assert_eq!(rule.severity(), SeverityMode::Error);
        assert_eq!(rule.name, "space-word");

        let mut result = RuleResult::new("test");
        rule.format(&mut result);
        assert_eq!(result.out, "test - foo");
        assert_eq!(result.severity, Severity::Error);

        let mut result = RuleResult::new("test");
        rule.lint(&mut result);
        assert_eq!(result.out, "test - foo");
        assert_eq!(result.severity, Severity::Error);
    }

    #[test]
    fn test_rule_pass() {
        let rule = Rule::new("spellcheck", |input| Cow::Borrowed(input));

        let mut result = RuleResult::new("test");
        rule.format(&mut result);
        assert_eq!(result.out, "test");
        assert_eq!(result.severity, Severity::Pass);

        rule.lint(&mut result);
        assert_eq!(result.out, "test");
        assert_eq!(result.severity, Severity::Pass);
    }
}