standout 12.0.1

Styled CLI template rendering with automatic terminal detection
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

use crate::cli::handler::{
    Delivery, DispatchResult, ExitStatus, RunError, RunErrorKind, RunOutput, RunRecorder,
};
use crate::{ColorPolicy, Representation};

#[must_use = "exit the process with `status`, or otherwise act on the outcome"]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ProcessOutcome {
    pub handled: bool,
    pub status: ExitStatus,
}

#[derive(Debug)]
pub struct CompletedRun {
    inner: DispatchResult,
    warnings: Vec<String>,
    output_mode: Representation,
    color_policy: ColorPolicy,
    results: Vec<serde_json::Value>,
    delivery: Delivery,
    entries: String,
}

impl CompletedRun {
    pub fn from_dispatch(
        inner: DispatchResult,
        warnings: Vec<String>,
        output_mode: Representation,
        color_policy: ColorPolicy,
        recorder: &RunRecorder,
    ) -> Self {
        Self {
            inner,
            warnings,
            output_mode,
            color_policy,
            results: recorder.records(),
            delivery: recorder.delivery(),
            entries: String::new(),
        }
    }

    pub fn with_entries(mut self, entries: String) -> Self {
        self.entries = entries;
        self
    }

    pub fn outcome(&self) -> &DispatchResult {
        &self.inner
    }

    /// The event lines `run_with` and `dispatch` capture as the handler emits
    /// them, newlines included.
    pub fn entries(&self) -> &str {
        &self.entries
    }

    pub fn into_outcome(self) -> DispatchResult {
        self.inner
    }

    pub fn warnings(&self) -> &[String] {
        &self.warnings
    }

    pub fn output_mode(&self) -> Representation {
        self.output_mode
    }

    pub fn color_policy(&self) -> ColorPolicy {
        self.color_policy
    }

    /// The run's result values as data, whatever representation it selected.
    pub fn results(&self) -> &[serde_json::Value] {
        &self.results
    }

    /// Where the rendered bytes went.
    pub fn delivery(&self) -> &Delivery {
        &self.delivery
    }
}

impl std::ops::Deref for CompletedRun {
    type Target = DispatchResult;

    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

#[derive(Debug)]
pub enum HelpResult {
    Matches(clap::ArgMatches),
    Help(String),
    Error(clap::Error),
}

#[derive(Debug)]
pub(crate) enum HelpDisplay {
    Rendered { text: String },
    Clap(clap::Error),
    RenderFailed(clap::Error),
}

impl From<HelpDisplay> for HelpResult {
    fn from(display: HelpDisplay) -> Self {
        match display {
            HelpDisplay::Rendered { text } => HelpResult::Help(text),
            HelpDisplay::Clap(e) | HelpDisplay::RenderFailed(e) => HelpResult::Error(e),
        }
    }
}

impl From<HelpDisplay> for DispatchResult {
    fn from(display: HelpDisplay) -> Self {
        match display {
            HelpDisplay::Rendered { text } => DispatchResult::Handled(RunOutput::clap_help(text)),
            HelpDisplay::Clap(e) if e.use_stderr() => {
                DispatchResult::Error(RunError::new(e.to_string(), RunErrorKind::ClapUsage))
            }
            HelpDisplay::Clap(e) => DispatchResult::Handled(RunOutput::clap_help(e.to_string())),
            HelpDisplay::RenderFailed(e) => {
                DispatchResult::Error(RunError::new(e.to_string(), RunErrorKind::Render))
            }
        }
    }
}