stax 0.91.2

Fast stacked Git branches and PRs
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

use std::io::IsTerminal;
use std::time::Duration;

pub(crate) fn detect_interactive_stdio() -> (bool, bool) {
    #[cfg(debug_assertions)]
    if std::env::var_os("STAX_TEST_FORCE_INTERACTIVE_TERMINAL").is_some() {
        // Integration tests use this to drive the interactive fallback path without a real PTY.
        return (true, true);
    }

    (
        std::io::stdin().is_terminal(),
        std::io::stdout().is_terminal(),
    )
}

pub(crate) fn has_interactive_terminal(stdin_is_terminal: bool, stdout_is_terminal: bool) -> bool {
    stdin_is_terminal && stdout_is_terminal
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct InteractiveTerminalCheck {
    pub(crate) available: bool,
    pub(crate) reason: Option<String>,
}

pub(crate) fn check_interactive_terminal(
    stdin_is_terminal: bool,
    stdout_is_terminal: bool,
) -> InteractiveTerminalCheck {
    check_interactive_terminal_with_probe(stdin_is_terminal, stdout_is_terminal, || {
        #[cfg(debug_assertions)]
        if let Ok(reason) = std::env::var("STAX_TEST_FORCE_INPUT_READER_FAILURE") {
            // Integration tests use this to exercise the interactive fallback path deterministically.
            return Err(reason);
        }

        crossterm::event::poll(Duration::from_millis(0))
            .map(|_| ())
            .map_err(|err| err.to_string())
    })
}

pub(crate) fn check_interactive_terminal_with_probe<F>(
    stdin_is_terminal: bool,
    stdout_is_terminal: bool,
    probe_input_reader: F,
) -> InteractiveTerminalCheck
where
    F: FnOnce() -> std::result::Result<(), String>,
{
    if !has_interactive_terminal(stdin_is_terminal, stdout_is_terminal) {
        return InteractiveTerminalCheck {
            available: false,
            reason: None,
        };
    }

    match probe_input_reader() {
        Ok(()) => InteractiveTerminalCheck {
            available: true,
            reason: None,
        },
        Err(reason) => InteractiveTerminalCheck {
            available: false,
            reason: Some(reason),
        },
    }
}

pub(crate) fn print_interactive_fallback(reason: Option<&str>, dashboard: &str, fallback: &str) {
    if let Some(reason) = reason {
        eprintln!(
            "stax: interactive {} unavailable ({}); {}.",
            dashboard, reason, fallback
        );
    }
}