rsconstruct 0.9.126

Rust based fast build system
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

//! Comment rules: yamllint's `comments` and `comments-indentation`.

use super::super::Problem;
use super::super::config::RuleConf;
use super::super::parser::{Kind, Stream};
use super::{Check, Default, OptKind, OptSpec, RuleSpec};

fn check_comments(conf: &RuleConf, stream: &Stream<'_>, idx: usize, out: &mut Vec<Problem>) {
    let comment = stream.comments[idx];
    let buf = stream.bytes();
    let min_spaces = conf.int_opt("min-spaces-from-content");
    if min_spaces != -1 && stream.comment_is_inline(&comment) {
        let before = &stream.tokens[comment.token_before];
        if (comment.pointer as i64 - before.end.index as i64) < min_spaces {
            out.push(Problem::new(
                comment.line_no,
                comment.column_no,
                format!("too few spaces before comment: expected {min_spaces}"),
            ));
        }
    }

    if conf.bool_opt("require-starting-space") {
        let mut text_start = comment.pointer + 1;
        while text_start < buf.len() && buf[text_start] == b'#' {
            text_start += 1;
        }
        if text_start < buf.len() {
            if conf.bool_opt("ignore-shebangs")
                && comment.line_no == 1
                && comment.column_no == 1
                && buf[text_start] == b'!'
            {
                return;
            }
            // \r and \r\n are both covered by checking the first character;
            // \r itself is a valid newline on some older systems.
            if !matches!(buf[text_start], b' ' | b'\n' | b'\r' | 0) {
                let column = comment.column_no + text_start - comment.pointer;
                out.push(Problem::new(
                    comment.line_no,
                    column,
                    "missing starting space in comment",
                ));
            }
        }
    }
}

pub const COMMENTS: RuleSpec = RuleSpec {
    id: "comments",
    options: &[
        OptSpec {
            name: "require-starting-space",
            kind: OptKind::Bool,
            default: Default::Bool(true),
        },
        OptSpec {
            name: "ignore-shebangs",
            kind: OptKind::Bool,
            default: Default::Bool(true),
        },
        OptSpec {
            name: "min-spaces-from-content",
            kind: OptKind::Int,
            default: Default::Int(2),
        },
    ],
    validate: None,
    check: Check::Comment(check_comments),
};

// Case A:
//
//     prev: line:
//       # commented line
//       current: line
//
// Case B:
//
//       prev: line
//       # commented line 1
//     # commented line 2
//     current: line
fn check_comments_indentation(
    _: &RuleConf,
    stream: &Stream<'_>,
    idx: usize,
    out: &mut Vec<Problem>,
) {
    let comment = stream.comments[idx];
    let before = &stream.tokens[comment.token_before];
    // Only check block comments.
    if before.kind != Kind::StreamStart && before.end.line + 1 == comment.line_no {
        return;
    }

    let next_line_indent = comment.token_after.map_or(0, |i| {
        let after = &stream.tokens[i];
        if after.kind == Kind::StreamEnd {
            0
        } else {
            after.start.column
        }
    });

    let mut prev_line_indent = if before.kind == Kind::StreamStart {
        0
    } else {
        before.line_indent(stream.buffer)
    };

    // In the following case only the next line indent is valid:
    //     list:
    //         # comment
    //         - 1
    //         - 2
    prev_line_indent = prev_line_indent.max(next_line_indent);

    // If two indents are valid but a previous comment went back to normal
    // indent, the next ones must do the same. In other words, avoid this:
    //     list:
    //         - 1
    //     # comment on valid indent (0)
    //         # comment on valid indent (4)
    //     other-list:
    //         - 2
    if let Some(i) = comment.previous
        && !stream.comment_is_inline(&stream.comments[i])
    {
        prev_line_indent = stream.comments[i].column_no - 1;
    }

    if comment.column_no - 1 != prev_line_indent && comment.column_no - 1 != next_line_indent {
        out.push(Problem::new(
            comment.line_no,
            comment.column_no,
            "comment not indented like content",
        ));
    }
}

pub const COMMENTS_INDENTATION: RuleSpec = RuleSpec {
    id: "comments-indentation",
    options: &[],
    validate: None,
    check: Check::Comment(check_comments_indentation),
};