atuin 18.24.0

atuin - magical shell history
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

use std::fmt::Write as _;
use std::process::Command;
use std::{io, process};

#[cfg(feature = "client")]
use atuin_client::plugin::{OfficialPluginRegistry, PluginContext};
use clap::CommandFactory;
use clap::builder::{StyledStr, Styles};
use eyre::Result;

use crate::Atuin;
use crate::i18n::writet;

pub fn run(args: &[String]) -> Result<()> {
    let subcommand = &args[0];
    let bin = format!("atuin-{subcommand}");
    let mut cmd = Command::new(&bin);
    cmd.args(&args[1..]);

    #[cfg(feature = "client")]
    let context = PluginContext::new(subcommand);

    let spawn_result = match cmd.spawn() {
        Ok(child) => Ok(child),
        Err(e) => match e.kind() {
            io::ErrorKind::NotFound => {
                let output = render_not_found(subcommand, &bin);
                Err(output)
            }
            _ => Err(e.to_string().into()),
        },
    };

    match spawn_result {
        Ok(mut child) => {
            let status = child.wait()?;
            if status.success() {
                Ok(())
            } else {
                #[cfg(feature = "client")]
                drop(context);

                process::exit(status.code().unwrap_or(1));
            }
        }
        Err(e) => {
            eprintln!("{}", e.ansi());

            #[cfg(feature = "client")]
            drop(context);

            process::exit(1);
        }
    }
}

fn render_not_found(subcommand: &str, bin: &str) -> StyledStr {
    let mut output = StyledStr::new();
    let styles = Styles::styled();

    let error = styles.get_error();
    let invalid = styles.get_invalid();
    let literal = styles.get_literal();

    #[cfg(feature = "client")]
    {
        let registry = OfficialPluginRegistry::new();

        // Check if this is an official plugin
        if let Some(install_message) = registry.get_install_message(subcommand) {
            let _ = write!(output, "{error}error:{error:#} ");
            let _ = write!(
                output,
                "'{invalid}{subcommand}{invalid:#}' is an official atuin plugin, but it's not \
                 installed"
            );
            let _ = write!(output, "\n\n");
            let _ = write!(output, "{install_message}");
            return output;
        }
    }

    let mut atuin_cmd = Atuin::command();
    let usage = atuin_cmd.render_usage();

    let _ = write!(output, "{error}error:{error:#} ");
    let _ = writet!(
        output,
        "unrecognized-subcommand",
        subcommand = format!("{invalid}{subcommand}{invalid:#}"),
        bin = format!("{invalid}{bin}{invalid:#}"),
    );
    let _ = write!(output, "\n\n");
    let _ = write!(output, "{usage}");
    let _ = write!(output, "\n\n");
    let _ = write!(output, "For more information, try '{literal}--help{literal:#}'.");

    output
}

#[cfg(test)]
mod tests {
    use rstest::rstest;

    use super::render_not_found;

    #[rstest]
    fn not_found_names_the_subcommand_and_its_binary() {
        let rendered = render_not_found("frobnicate", "atuin-frobnicate").to_string();
        assert!(
            rendered.starts_with(
                "error: unrecognized subcommand 'frobnicate' and no executable named \
                 'atuin-frobnicate' found in your PATH\n\n"
            ),
            "{rendered:?}"
        );
    }
}