rrubocop 0.8.15

10x faster RuboCop drop-in. Same output format and configs, without maintaining RuboCop gems.
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

//! Layout/EmptyLines — empty lines around code (simplified: consecutive blanks > 1).

use crate::cop::{Cop, CopConfig};
use crate::correction::Correction;
use crate::diagnostic::Diagnostic;
use crate::parse::source::SourceFile;

pub struct EmptyLines;

fn is_blank(line: &[u8]) -> bool {
    line.iter().all(|&b| b == b' ' || b == b'\t' || b == b'\r')
}

fn report_extra(
    cop: &dyn Cop, source: &SourceFile, lines: &[&[u8]], start_line: usize, start_byte: usize,
    remove_end: usize,
    diagnostics: &mut Vec<Diagnostic>, corrections: &mut Option<&mut Vec<Correction>>,
) {
    let mut diag = cop.diagnostic(source, start_line + 2, 0, "Extra blank line detected.".into());
    if let Some(corr) = corrections {
        let keep_end = start_byte + lines[start_line].len() + 1;
        if remove_end > keep_end {
            corr.push(Correction {
                start: keep_end, end: remove_end, replacement: String::new(),
                cop_name: cop.name(), cop_index: 0,
            });
            diag.corrected = true;
        }
    }
    diagnostics.push(diag);
}

fn on_nonblank(
    cop: &dyn Cop, source: &SourceFile, lines: &[&[u8]],
    blank_count: usize, run: Option<(usize, usize)>, byte_offset: usize,
    diagnostics: &mut Vec<Diagnostic>, corrections: &mut Option<&mut Vec<Correction>>,
) {
    if blank_count <= 1 { return; }
    let Some((start_line, start_byte)) = run else { return; };
    report_extra(cop, source, lines, start_line, start_byte, byte_offset, diagnostics, corrections);
}

impl Cop for EmptyLines {
    fn name(&self) -> &'static str { "Layout/EmptyLines" }
    fn supports_autocorrect(&self) -> bool { true }

    fn uses_line_phase(&self) -> bool {
        true
    }

    fn check_lines(
        &self, source: &SourceFile, _config: &CopConfig,
        diagnostics: &mut Vec<Diagnostic>, mut corrections: Option<&mut Vec<Correction>>,
    ) {
        let lines: Vec<&[u8]> = source.lines().collect();
        let mut byte_offset = 0usize;
        let mut blank_run_start: Option<(usize, usize)> = None;
        let mut blank_count = 0usize;
        for (i, line) in lines.iter().enumerate() {
            if is_blank(line) {
                if blank_count == 0 { blank_run_start = Some((i, byte_offset)); }
                blank_count += 1;
            } else {
                on_nonblank(
                    self, source, &lines, blank_count, blank_run_start, byte_offset,
                    diagnostics, &mut corrections,
                );
                blank_count = 0;
                blank_run_start = None;
            }
            byte_offset += line.len() + 1;
        }
    }
}