cargo-q 0.1.1

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

use crate::parser::Strategy;
use crate::routine::Routine;
use std::io::{self, Error, ErrorKind};
use std::time::Instant;

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 start_time = Instant::now();
        let mut success_count = 0;
        let total_commands = self.routines.len();

        for cmd in &self.routines {
            let success = cmd.run(self.verbose)?;

            match self.strategy {
                Strategy::Independent => {
                    // Continue to next command regardless of success
                    if success {
                        success_count += 1;
                    }
                }
                Strategy::Dependent | Strategy::Pipe => {
                    // Stop if command failed
                    if !success {
                        let elapsed = start_time.elapsed();
                        eprintln!(
                            "Summary: {}/{} commands succeeded ({:.2}s)",
                            success_count,
                            total_commands,
                            elapsed.as_secs_f32()
                        );
                        return Err(Error::new(
                            ErrorKind::Other,
                            format!("Command 'cargo {} {}' failed", cmd.name, cmd.args.join(" ")),
                        ));
                    }
                    success_count += 1;
                }
            }
        }

        let elapsed = start_time.elapsed();
        println!(
            "Summary: {}/{} commands succeeded ({:.2}s)",
            success_count,
            total_commands,
            elapsed.as_secs_f32()
        );
        Ok(())
    }
}