loop_cmd 0.1.16

A command-line tool for executing commands across multiple directories
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

pub mod args;
pub mod config;
pub mod executor;

use crate::args::LoopOptions;
use std::path::PathBuf;
use walkdir::WalkDir;

/// Runs the main loop command based on the provided options.
///
/// This function is the entry point for the loop command's functionality.
/// It handles initialization if requested, or executes the loop command
/// based on the provided options.
pub fn run(args: LoopOptions) -> i32 {
    if args.init {
        config::create_looprc();
        return exitcode::OK;
    }

    let options = LoopOptions {
        command: args.command,
        cwd: args.cwd,
        include: args.include,
        exclude: args.exclude,
        include_only: args.include_only,
        exclude_only: args.exclude_only,
        include_pattern: args.include_pattern,
        exclude_pattern: args.exclude_pattern,
        init: args.init,
    };

    execute_loop(options)
}

/// Executes the loop command with the given options.
///
/// This function processes directories based on the provided options,
/// executing the specified command in each relevant directory.
pub fn execute_loop(options: LoopOptions) -> i32 {
    let working_dir = options
        .cwd
        .clone()
        .map(PathBuf::from)
        .unwrap_or_else(|| std::env::current_dir().unwrap());
    std::env::set_current_dir(working_dir).unwrap();

    let config = config::read_looprc();

    let mut first_error_code: Option<i32> = None;

    // Process child directories
    for entry in WalkDir::new(".")
        .min_depth(1)
        .max_depth(1)
        .sort_by_file_name()
    {
        let entry = entry.unwrap();
        if entry.file_type().is_dir() {
            let dir_path = entry.path();
            if executor::should_process_directory(dir_path, &options, &config) {
                let exit_code = executor::execute_command_in_directory(dir_path, &options.command);
                if exit_code != 0 && first_error_code.is_none() {
                    first_error_code = Some(exit_code);
                }
            }
        }
    }

    // Process included directories
    if let Some(ref include_dirs) = options.include {
        for dir in include_dirs {
            let dir_path = PathBuf::from(dir);
            if dir_path.is_dir() {
                let exit_code = executor::execute_command_in_directory(&dir_path, &options.command);
                if exit_code != 0 && first_error_code.is_none() {
                    first_error_code = Some(exit_code);
                }
            } else {
                eprintln!("Warning: {} is not a directory", dir);
            }
        }
    }

    match first_error_code {
        Some(code) => code,
        None => exitcode::OK,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    use tempfile::tempdir;

    #[test]
    fn test_run() {
        let temp_dir = tempdir().unwrap();
        fs::create_dir(temp_dir.path().join("test_dir")).unwrap();

        let args = LoopOptions {
            command: vec!["echo".to_string(), "test".to_string()],
            cwd: Some(temp_dir.path().to_string_lossy().into_owned()),
            include: None,
            exclude: None,
            include_only: None,
            exclude_only: None,
            include_pattern: None,
            exclude_pattern: None,
            init: false,
        };
        let exit_code = run(args);
        assert_eq!(exit_code, exitcode::OK);
    }
}