gshell 1.0.1

gshell is a shell for people who live in the terminal. It pairs familiar Unix behavior with a tighter core, fast interaction, and an interface built to stay out of the way.
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
159
160
161
162

use std::sync::{Arc, Mutex};

use gshell::{
    parser::ParsedCommand,
    prompt::{FallbackPromptRenderer, Prompt, ReedlinePromptAdapter},
    runtime::{Executor, ExecutorFuture},
    shell::{CommandOutput, ExitCode, SharedShellState, ShellAction, ShellState},
    ui::{ReplCore, ReplFlow},
};
use reedline::Signal;

#[derive(Clone, Default)]
struct RecordingExecutor {
    calls: Arc<Mutex<Vec<ParsedCommand>>>,
}

impl RecordingExecutor {
    fn calls(&self) -> Vec<ParsedCommand> {
        self.calls.lock().expect("calls lock poisoned").clone()
    }
}

impl Executor<ParsedCommand> for RecordingExecutor {
    fn execute<'a>(
        &'a self,
        _state: SharedShellState,
        command: &'a ParsedCommand,
    ) -> ExecutorFuture<'a> {
        let calls = self.calls.clone();

        Box::pin(async move {
            calls
                .lock()
                .expect("calls lock poisoned")
                .push(command.clone());
            Ok(ShellAction::continue_with(CommandOutput::success()))
        })
    }
}

#[tokio::test]
async fn empty_line_redraws_prompt() {
    let executor = RecordingExecutor::default();
    let core = ReplCore::new(executor.clone());
    let state = ShellState::shared().await.expect("state should initialize");

    let flow = core
        .handle_signal(Signal::Success(String::new()), state.clone())
        .await;

    assert_eq!(flow, ReplFlow::Continue);
    assert!(executor.calls().is_empty());
    assert_eq!(state.read().await.last_exit_status(), ExitCode::SUCCESS);
}

#[tokio::test]
async fn explicit_exit_terminates_session_cleanly() {
    let executor = gshell::runtime::BootstrapExecutor;
    let core = ReplCore::new(executor);
    let state = ShellState::shared().await.expect("state should initialize");

    let flow = core
        .handle_signal(Signal::Success("exit".to_string()), state.clone())
        .await;

    assert_eq!(flow, ReplFlow::Break);
    assert_eq!(state.read().await.last_exit_status(), ExitCode::SUCCESS);
}

#[tokio::test]
async fn prompt_starts_after_two_newlines() {
    let renderer = std::sync::Arc::new(FallbackPromptRenderer);
    let state = ShellState::shared().await.expect("state should initialize");
    let mut prompt = ReedlinePromptAdapter::new(renderer);

    prompt.refresh(state).await;

    assert_eq!(prompt.render_prompt_left(), "\n\n");
    assert_eq!(
        prompt.render_prompt_indicator(reedline::PromptEditMode::Default),
        "$ "
    );
}

#[tokio::test]
async fn prompt_still_available_after_command_execution() {
    let renderer = std::sync::Arc::new(FallbackPromptRenderer);
    let state = ShellState::shared().await.expect("state should initialize");
    let mut prompt = ReedlinePromptAdapter::new(renderer);

    prompt.refresh(state.clone()).await;

    let executor = RecordingExecutor::default();
    let core = ReplCore::new(executor);

    let flow = core
        .handle_signal(Signal::Success("echo hello".to_string()), state.clone())
        .await;

    assert_eq!(flow, ReplFlow::Continue);

    prompt.refresh(state).await;

    assert_eq!(prompt.render_prompt_left(), "\n\n");
    assert_eq!(
        prompt.render_prompt_indicator(reedline::PromptEditMode::Default),
        "$ "
    );
}

#[tokio::test]
async fn cd_followed_by_pwd_updates_shell_state() {
    let executor = gshell::runtime::BootstrapExecutor;
    let core = ReplCore::new(executor);
    let state = ShellState::shared().await.expect("state should initialize");

    let tmp = tempfile::tempdir().expect("temp dir should be created");
    let cmd = format!("cd {}", tmp.path().display());

    let flow = core
        .handle_signal(Signal::Success(cmd), state.clone())
        .await;

    assert_eq!(flow, ReplFlow::Continue);
    let expected =
        std::fs::canonicalize(tmp.path()).expect("temp dir path should canonicalize successfully");
    assert_eq!(state.read().await.cwd(), expected);

    let flow = core
        .handle_signal(Signal::Success("pwd".to_string()), state.clone())
        .await;

    assert_eq!(flow, ReplFlow::Continue);
}

#[tokio::test]
async fn external_command_runs_through_repl_core() {
    let executor = gshell::runtime::BootstrapExecutor;
    let core = ReplCore::new(executor);
    let state = ShellState::shared().await.expect("state should initialize");

    let flow = core
        .handle_signal(Signal::Success("false".to_string()), state.clone())
        .await;

    assert_eq!(flow, ReplFlow::Continue);
    assert!(state.read().await.last_exit_status().is_failure());
}

#[tokio::test]
async fn echo_command_through_repl_core_updates_exit_status() {
    let executor = gshell::runtime::BootstrapExecutor;
    let core = ReplCore::new(executor);
    let state = ShellState::shared().await.expect("state should initialize");

    let flow = core
        .handle_signal(Signal::Success("echo hello".to_string()), state.clone())
        .await;

    assert_eq!(flow, ReplFlow::Continue);
    assert_eq!(state.read().await.last_exit_status(), ExitCode::SUCCESS);
}