suitcase 0.1.4

A set of personal CLI tools to automate common tasks in software development (including Rust, Dart, and Flutter), written in Rust.
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use crate::{
    exec_on,
    internal::{
        shell::ShellError,
        utils::{
            dart::{DartProjectMetadata, DartShell},
            directory_utils::DirectoryUtils,
        },
    },
    progress,
};
use anyhow::Context;
use clap::Args;
use log::info;
use std::{ops::Deref, path::PathBuf};
use thiserror::Error;

use super::InternalCommandOptions;

#[derive(Args, Debug)]
pub struct ForEveryDartProjectOptions {
    /// The command to run on each Dart project.
    #[arg()]
    command: Vec<String>,

    /// The path from which to search for Dart projects.
    #[arg(default_value = ".", short, long)]
    path: PathBuf,

    /// Include Flutter projects when searching for Dart projects to run the command on.
    #[arg(default_value = "true", short, long)]
    include_flutter_projects: bool,

    /// Exit the process immediately if any of the commands run on the Dart projects fail.
    #[arg(default_value = "false", short, long)]
    fail_fast: bool,

    /// Show the output of the command run on each Dart project.
    #[arg(default_value = "false", short, long)]
    show_output: bool,
}

#[derive(Error, Debug)]
pub enum ForEveryDartProjectError {
    /// An error that occurred when trying to execute a command in one or more Dart projects.
    #[error("error while executing command '{command}' for one or more projects: {errors:?}")]
    CommandExecutionError {
        command: String,
        errors: Vec<(String, ShellError)>,
    },
}

pub fn for_every_dart_project(
    InternalCommandOptions {
        shell,
        base_args: _,
        options,
    }: InternalCommandOptions<ForEveryDartProjectOptions>,
) -> anyhow::Result<()> {
    let command = options.command.join(" ");
    let path = options.path.clone();
    let mut dir_utils = DirectoryUtils::new();

    dir_utils
        .pushd(&path)
        .context("trying to navigate to provided path")?;

    let dart_shell = DartShell::new(shell);

    let mut projects = progress!("Finding Dart projects", {
        dart_shell.find_dart_projects(None).context(format!(
            "trying to find Dart projects in path '{}'",
            path.display()
        ))
    })?;

    if !options.include_flutter_projects {
        projects.retain(|project| !project.is_flutter_project);
        info!("Found {} Dart (non-Flutter) projects", projects.len());
    } else {
        info!("Found {} Dart and Flutter projects", projects.len());
    }

    if projects.is_empty() {
        info!("No projects found");
        return Ok(());
    }

    let mut errors: Vec<(&DartProjectMetadata, ShellError)> = vec![];

    for project in projects.iter() {
        dir_utils.pushd(&project.path).context(format!(
            "trying to navigate to project path '{}'",
            project.path.display()
        ))?;

        let result = progress!(
            format!(
                "Running command in '{}' ('{}')",
                project.name,
                project.path.display()
            )
            .as_str(),
            exec_on!(shell, "bash", "-c", &command)
        );

        if let Err(error) = &result {
            let error = error.deref().clone();
            if options.fail_fast {
                return Err(error).context(format!(
                    "trying to run command '{}' on project '{}'",
                    command, project.name
                ));
            } else {
                errors.push((project, error.clone()));
            }
        }

        if options.show_output {
            let output = &result.map_or_else(
                |err| match err {
                    crate::internal::shell::ShellError::HostProcessExecutionFailure {
                        command: _,
                        args: _,
                        status: _,
                        stdout,
                        stderr,
                    } => format!("{}\n---\n{}", stdout, stderr),
                    crate::internal::shell::ShellError::ShellStartFailure {
                        command: _,
                        args: _,
                        error,
                    } => error.to_string(),
                },
                |output| output.stdout,
            );

            info!("Output:\n{}\n---", output);
        }
    }

    if !errors.is_empty() {
        return Err(ForEveryDartProjectError::CommandExecutionError {
            command,
            errors: errors
                .into_iter()
                .map(|(project, error)| (project.name.clone(), error))
                .collect(),
        }
        .into());
    }

    dir_utils
        .popd()
        .context("trying to navigate back to original path")?;

    Ok(())
}