reef-shell 0.3.0

Bash compatibility layer for fish shell
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

//! Reef CLI — binary entry point.

use std::path::Path;
use std::process;

fn main() {
    let args: Vec<String> = std::env::args().collect();

    if args.len() < 2 {
        eprintln!("usage: reef <detect|translate|bash-exec|daemon> [flags] -- <command>");
        process::exit(2);
    }

    match args[1].as_str() {
        "--version" | "-V" => {
            println!("reef {}", env!("CARGO_PKG_VERSION"));
        }
        "detect" => {
            // --quick and full detection use the same heuristic for now;
            // full AST-based detection may be added later.
            let cmd = collect_after_dashdash(&args[2..]);
            if reef::detect::looks_like_bash(&cmd) {
                process::exit(0);
            } else {
                process::exit(1);
            }
        }
        "translate" => {
            let cmd = collect_after_dashdash(&args[2..]);
            match reef::translate::translate_bash_to_fish(&cmd) {
                Ok(fish_code) => print!("{fish_code}"),
                Err(e) => {
                    eprintln!("reef: translation failed: {e}");
                    process::exit(1);
                }
            }
        }
        "bash-exec" => {
            let env_diff = args[2..].iter().any(|a| a == "--env-diff");
            let state_file = find_flag_value(&args[2..], "--state-file");
            let cmd = collect_after_dashdash(&args[2..]);
            let exit_code = if env_diff {
                reef::passthrough::bash_exec_env_diff(&cmd)
            } else if let Some(path) = state_file {
                reef::passthrough::bash_exec_with_state(&cmd, Path::new(&path))
            } else {
                reef::passthrough::bash_exec(&cmd)
            };
            process::exit(exit_code);
        }
        "daemon" => {
            if args.len() < 3 {
                eprintln!("usage: reef daemon <start|stop|status|exec> --socket <path>");
                process::exit(2);
            }
            let socket = find_flag_value(&args[3..], "--socket").unwrap_or_else(|| {
                eprintln!("reef daemon: --socket <path> is required");
                process::exit(2);
            });
            match args[2].as_str() {
                "start" => reef::daemon::start(&socket),
                "stop" => reef::daemon::stop(&socket),
                "status" => {
                    if reef::daemon::status(&socket) {
                        println!("reef daemon: running");
                    } else {
                        println!("reef daemon: not running");
                        process::exit(1);
                    }
                }
                "exec" => {
                    let cmd = collect_after_dashdash(&args[3..]);
                    let exit_code = reef::daemon::exec(&socket, &cmd);
                    process::exit(exit_code);
                }
                // Internal: called by `start` to run the daemon loop
                "_serve" => reef::daemon::serve(&socket),
                other => {
                    eprintln!("reef daemon: unknown subcommand '{other}'");
                    process::exit(2);
                }
            }
        }
        other => {
            eprintln!("reef: unknown command '{other}'");
            process::exit(2);
        }
    }
}

/// Collect all arguments after `--` into a single string.
fn collect_after_dashdash(args: &[String]) -> String {
    if let Some(pos) = args.iter().position(|a| a == "--") {
        args[pos + 1..].join(" ")
    } else {
        args.join(" ")
    }
}

/// Find the value of a `--flag value` pair in an argument list.
fn find_flag_value(args: &[String], flag: &str) -> Option<String> {
    args.windows(2).find_map(|pair| {
        if pair[0] == flag {
            Some(pair[1].clone())
        } else {
            None
        }
    })
}