bashkit 0.5.0

Awesomely fast virtual sandbox with bash and file system
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

//! Alias management builtins: alias, unalias
//!
//! Directly mutate aliases via [`ShellRef`](super::ShellRef).

use async_trait::async_trait;

use super::{Builtin, Context};
use crate::error::Result;
use crate::interpreter::ExecResult;

/// `alias` builtin — define or display aliases.
///
/// Usage:
/// - `alias` — list all aliases
/// - `alias name` — show a specific alias
/// - `alias name=value` — define an alias
pub struct Alias;

#[async_trait]
impl Builtin for Alias {
    async fn execute(&self, mut ctx: Context<'_>) -> Result<ExecResult> {
        let Some(shell) = ctx.shell.as_mut() else {
            return Ok(ExecResult::ok(String::new()));
        };

        if ctx.args.is_empty() {
            // List all aliases
            let mut sorted: Vec<_> = shell.aliases.iter().collect();
            sorted.sort_by_key(|(k, _)| (*k).clone());
            let mut output = String::new();
            for (name, value) in sorted {
                output.push_str(&format!("alias {}='{}'\n", name, value));
            }
            return Ok(ExecResult::ok(output));
        }

        let mut output = String::new();
        let mut exit_code = 0;
        let mut stderr = String::new();

        for arg in ctx.args {
            if let Some(eq_pos) = arg.find('=') {
                // alias name=value — set directly
                let name = &arg[..eq_pos];
                let value = &arg[eq_pos + 1..];
                shell.aliases.insert(name.to_string(), value.to_string());
            } else {
                // alias name — show the alias
                if let Some(value) = shell.aliases.get(arg.as_str()) {
                    output.push_str(&format!("alias {}='{}'\n", arg, value));
                } else {
                    stderr.push_str(&format!("bash: alias: {}: not found\n", arg));
                    exit_code = 1;
                }
            }
        }

        Ok(ExecResult {
            stdout: output,
            stderr,
            exit_code,
            ..Default::default()
        })
    }
}

/// `unalias` builtin — remove alias definitions.
///
/// Usage:
/// - `unalias name` — remove alias
/// - `unalias -a` — remove all aliases
pub struct Unalias;

#[async_trait]
impl Builtin for Unalias {
    async fn execute(&self, mut ctx: Context<'_>) -> Result<ExecResult> {
        let Some(shell) = ctx.shell.as_mut() else {
            return Ok(ExecResult::err(
                "bash: unalias: usage: unalias [-a] name [name ...]\n".to_string(),
                2,
            ));
        };

        if ctx.args.is_empty() {
            return Ok(ExecResult::err(
                "bash: unalias: usage: unalias [-a] name [name ...]\n".to_string(),
                2,
            ));
        }

        let mut exit_code = 0;
        let mut stderr = String::new();

        for arg in ctx.args {
            if arg == "-a" {
                shell.aliases.clear();
            } else if shell.aliases.remove(arg.as_str()).is_none() {
                stderr.push_str(&format!("bash: unalias: {}: not found\n", arg));
                exit_code = 1;
            }
        }

        Ok(ExecResult {
            stderr,
            exit_code,
            ..Default::default()
        })
    }
}