lintje 0.11.1

Lintje is an opinionated linter for Git.
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

use core::ops::Range;
use regex::Regex;

use crate::commit::Commit;
use crate::issue::{Context, Issue, Position};
use crate::rule::Rule;
use crate::rule::RuleValidator;

lazy_static! {
    static ref SUBJECT_STARTS_WITH_PREFIX: Regex = Regex::new(r"^([\w\(\)/!]+:)\s.*").unwrap();
}

pub struct SubjectCapitalization {}

impl SubjectCapitalization {
    pub fn new() -> Self {
        Self {}
    }
}

impl RuleValidator<Commit> for SubjectCapitalization {
    fn validate(&self, commit: &Commit) -> Option<Vec<Issue>> {
        if commit.has_issue(&Rule::SubjectPrefix) {
            return None;
        }
        if commit.subject.chars().count() == 0 && commit.has_issue(&Rule::SubjectLength) {
            return None;
        }

        match commit.subject.chars().next() {
            Some(character) => {
                if character.is_lowercase() {
                    let mut subject = commit.subject.clone();
                    let first_char = subject.get_mut(0..character.len_utf8());
                    match first_char {
                        Some(s) => s.make_ascii_uppercase(),
                        None => {
                            error!("SubjectCapitalization validation failure: Unable to fetch first character in subject.");
                            return None;
                        }
                    }

                    let char_len = character.len_utf8();
                    let context = vec![
                        Context::subject_removal_suggestion(
                            commit.subject.to_string(),
                            Range {
                                start: 0,
                                end: char_len,
                            },
                            "".to_string(),
                        ),
                        Context::subject_addition_suggestion(
                            subject,
                            Range {
                                start: 0,
                                end: char_len,
                            },
                            "Start the subject with a capital letter".to_string(),
                        ),
                    ];
                    Some(vec![Issue::error(
                        Rule::SubjectCapitalization,
                        "The subject does not start with a capital letter".to_string(),
                        Position::Subject { line: 1, column: 1 },
                        context,
                    )])
                } else {
                    None
                }
            }
            None => {
                error!("SubjectCapitalization validation failure: No first character found of subject.");
                None
            }
        }
    }
}

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

    fn validate(commit: &Commit) -> Option<Vec<Issue>> {
        SubjectCapitalization::new().validate(commit)
    }

    fn assert_subject_as_valid(subject: &str) {
        assert_eq!(validate(&commit(subject, "")), None);
    }

    #[test]
    fn valid_subjects() {
        assert_subject_as_valid("Fix test");
    }

    #[test]
    fn starting_with_lowercase() {
        let issue = first_issue(validate(&commit("fix test", "")));
        assert_eq!(
            issue.message,
            "The subject does not start with a capital letter"
        );
        assert_eq!(issue.position, subject_position(1));
        assert_contains_issue_output(
            &issue,
            "1 | fix test\n\
               | -\n\
             1 | Fix test\n\
               | + Start the subject with a capital letter",
        );
    }

    #[test]
    fn skipped_length() {
        let mut short_commit = commit("", "");
        short_commit.issues.push(Issue::error(
            Rule::SubjectLength,
            "some message".to_string(),
            Position::Subject { line: 1, column: 1 },
            vec![],
        ));
        // Already a SubjectLength issue, so it's skipped
        assert!(short_commit.has_issue(&Rule::SubjectLength));
        assert!(!short_commit.has_issue(&Rule::SubjectCapitalization));
    }

    #[test]
    fn skipped_prefix() {
        let mut short_commit = commit("chore: foo", "");
        short_commit.issues.push(Issue::error(
            Rule::SubjectPrefix,
            "some message".to_string(),
            Position::Subject { line: 1, column: 1 },
            vec![],
        ));
        // Already a SubjectLength issue, so it's skipped
        assert!(short_commit.has_issue(&Rule::SubjectPrefix));
        assert!(!short_commit.has_issue(&Rule::SubjectCapitalization));
    }
}