cargo-q 0.1.2

A cargo subcommand for running multiple cargo commands in a time
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

use crate::parser::Strategy;
use crate::process::{ColorExt, ExecutionSummary};
use crate::routine::Routine;
use std::io::{self, Error, ErrorKind};

pub(crate) struct Executor {
    pub(super) parallel: bool,
    pub(super) verbose: bool,
    pub(super) strategy: Strategy,
    pub(super) routines: Vec<Routine>,
}

impl Executor {
    pub fn new(parallel: bool, verbose: bool, routines: Vec<Routine>, strategy: Strategy) -> Self {
        Executor {
            parallel,
            verbose,
            strategy,
            routines,
        }
    }

    pub fn execute(&self) -> io::Result<()> {
        if self.parallel {
            return Err(Error::new(
                ErrorKind::Unsupported,
                "Parallel execution not yet implemented",
            ));
        }

        let total_commands = self.routines.len();
        let mut summary = ExecutionSummary::new(total_commands);

        for (idx, cmd) in self.routines.iter().enumerate() {
            let cmd_str = if cmd.args.is_empty() {
                cmd.name.clone()
            } else {
                format!("{} {}", cmd.name, cmd.args.join(" "))
            };
            println!(
                "\n    {} {}",
                format!("[{}/{}]", idx + 1, total_commands).bold(),
                cmd_str
            );

            match cmd.run(self.verbose) {
                Ok((success, output)) => {
                    match self.strategy {
                        Strategy::Independent => {
                            if success {
                                summary.increment_success();
                            } else if !output.stderr.is_empty() {
                                eprintln!("error: Command failed but continuing due to Independent strategy");
                                eprintln!("{}", String::from_utf8_lossy(&output.stderr));
                            }
                        }
                        Strategy::Dependent | Strategy::Pipe => {
                            if !success {
                                if !output.stderr.is_empty() {
                                    eprintln!("error: {}", String::from_utf8_lossy(&output.stderr));
                                }
                                return Err(Error::new(
                                    ErrorKind::Other,
                                    format!("Command failed: cargo {}", cmd_str),
                                ));
                            }
                            summary.increment_success();
                        }
                    }
                }
                Err(e) => {
                    eprintln!("error: Failed to execute command: {}", e);
                    return Err(e);
                }
            }
        }

        Ok(())
    }
}