multilint 0.2.2

A driver of multiple linters
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

use anyhow::Result;
use std::io::{stdout, Write};

use colored::*;

use crate::{
    linter::Output,
    parser::{Parsed, Parser},
};

fn parse(parser: &Parser, name: &str, output: &Output) -> Result<Vec<Parsed>> {
    let mut msgs = parser.parse(std::str::from_utf8(output.stdout())?);
    for f in output.modified() {
        msgs.push(Parsed {
            file: Some(f.display().to_string()),
            message: Some("modified".to_string()),
            ..Default::default()
        })
    }
    for msg in &mut msgs {
        msg.program.get_or_insert_with(|| name.to_string());
    }
    Ok(msgs)
}

pub trait OutputFormat {
    fn start(&self, name: &str);
    fn no_command(&self, name: &str);
    fn no_file(&self, name: &str);
    fn status(&self, name: &str, output: &Output, parser: &Parser) -> Result<()>;
}

#[derive(Default)]
pub struct NullFormat {}

impl OutputFormat for NullFormat {
    fn start(&self, _name: &str) {}
    fn no_command(&self, _name: &str) {}
    fn no_file(&self, _name: &str) {}
    fn status(&self, _name: &str, _output: &Output, _parser: &Parser) -> Result<()> {
        Ok(())
    }
}

#[derive(Default)]
pub struct TextFormat {}

impl OutputFormat for TextFormat {
    fn start(&self, name: &str) {
        print!("{} {} ... ", "Running".bold().green(), &name);
    }

    fn no_command(&self, _name: &str) {
        println!("{}", "no command".yellow());
    }

    fn no_file(&self, _name: &str) {
        println!("{}", "skipped".yellow());
    }

    fn status(&self, _name: &str, output: &Output, _parser: &Parser) -> Result<()> {
        if output.success() {
            println!("{}", "ok".green());
        } else {
            println!("{}", "failed".red());
        }
        stdout().write_all(output.stdout())?;
        stdout().write_all(output.stderr())?;
        for f in output.modified() {
            println!("{}: modified", f.display());
        }
        Ok(())
    }
}

#[derive(Default)]
pub struct JSONLFormat {}

impl OutputFormat for JSONLFormat {
    fn start(&self, _name: &str) {}
    fn no_command(&self, _name: &str) {}
    fn no_file(&self, _name: &str) {}

    fn status(&self, name: &str, output: &Output, parser: &Parser) -> Result<()> {
        let msgs = parse(parser, name, output)?;
        for msg in msgs {
            println!("{}", serde_json::to_string(&msg)?);
        }
        Ok(())
    }
}

/// See [GNU Coding Standards](https://www.gnu.org/prep/standards/html_node/Errors.html)
#[derive(Default)]
pub struct GNUFormat {}

impl OutputFormat for GNUFormat {
    fn start(&self, _name: &str) {}
    fn no_command(&self, _name: &str) {}
    fn no_file(&self, _name: &str) {}

    fn status(&self, name: &str, output: &Output, parser: &Parser) -> Result<()> {
        let msgs = parse(parser, name, output)?;
        for msg in msgs {
            if let Some(program) = msg.program {
                print!("{}:", program);
            }
            if let Some(file) = msg.file {
                print!("{}:", file);
            }
            if let Some(line) = msg.line {
                print!("{}:", line);
            }
            if let Some(column) = msg.column {
                print!("{}:", column);
            }
            if let Some(message) = msg.message {
                print!(" {}", message);
            }
            println!();
        }
        Ok(())
    }
}