clipped 0.1.0

Clipped your cargo clippy
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::{
    env, ffi,
    fmt::{self, Display, Formatter},
    io::{BufReader, Read},
    process::{Child, Command, ExitStatus, Stdio},
    sync::mpsc::{self, Receiver},
    thread::{self, JoinHandle},
};

use crate::error::{Error, Result};

use cargo_metadata::Message;

#[derive(Debug)]
pub struct ClippyRunner {
    child: Child,
    stderr_handle: JoinHandle<Result<String>>,
    receiver: Receiver<std::result::Result<Message, std::io::Error>>,
}

impl ClippyRunner {
    pub fn wait(mut self) -> Result<(ExitStatus, String)> {
        let status = self.child.wait().map_err(Error::ClippyWait)?;
        let stderr = self.stderr_handle.join().expect("failed to join stderr thread")?;
        Ok((status, stderr))
    }
}

impl Iterator for ClippyRunner {
    type Item = std::result::Result<Message, std::io::Error>;

    fn next(&mut self) -> Option<Self::Item> {
        self.receiver.recv().ok()
    }
}

#[derive(Debug)]
pub struct ClippyCommand {
    cmd: Command,
}

impl ClippyCommand {
    pub fn new() -> Self {
        let mut command = Command::new(env::var("CARGO").unwrap_or("cargo".into()));
        command.arg("clippy").arg("--message-format=json-diagnostic-rendered-ansi");
        ClippyCommand { cmd: command }
    }

    pub fn arg<S: AsRef<ffi::OsStr>>(mut self, arg: S) -> Self {
        self.cmd.arg(arg);
        self
    }

    pub fn args<I, S>(mut self, args: I) -> Self
    where
        I: IntoIterator<Item = S>,
        S: AsRef<ffi::OsStr>,
    {
        self.cmd.args(args);
        self
    }

    pub fn spawn(&mut self) -> Result<ClippyRunner> {
        let mut child = self
            .cmd
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .spawn()
            .map_err(Error::ClippySpawn)?;

        let stdout = child.stdout.take().ok_or(Error::ClippyCapture { stream: "stdout" })?;
        let mut stderr = child.stderr.take().ok_or(Error::ClippyCapture { stream: "stderr" })?;

        let (tx, rx) = mpsc::sync_channel::<std::result::Result<Message, std::io::Error>>(100);

        thread::spawn(move || {
            let reader = BufReader::new(stdout);
            for message in Message::parse_stream(reader) {
                if tx.send(message).is_err() {
                    break;
                }
            }
        });

        let stderr_handle = thread::spawn(move || {
            let mut output = String::new();
            stderr.read_to_string(&mut output).map(|_| output).map_err(Error::ClippyStderrRead)
        });

        Ok(ClippyRunner { child, stderr_handle, receiver: rx })
    }
}

impl Default for ClippyCommand {
    fn default() -> Self {
        ClippyCommand::new()
    }
}

impl Display for ClippyCommand {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.cmd.get_program().to_string_lossy())?;
        for arg in self.cmd.get_args() {
            write!(f, " {}", arg.to_string_lossy())?;
        }
        Ok(())
    }
}