starship/src/modules/status.rs

649 lines
21 KiB
Rust

use std::string::ToString;
use super::{Context, Module, RootModuleConfig};
use crate::configs::status::StatusConfig;
use crate::formatter::{string_formatter::StringFormatterError, StringFormatter};
use crate::segment::Segment;
type ExitCode = i64;
type SignalNumber = u32;
#[derive(PartialEq)]
enum PipeStatusStatus<'a> {
Disabled,
NoPipe,
Pipe(&'a Vec<std::string::String>),
}
/// Creates a module with the status of the last command
///
/// Will display the status only if it is not 0
pub fn module<'a>(context: &'a Context) -> Option<Module<'a>> {
let mut module = context.new_module("status");
let config = StatusConfig::try_load(module.config);
// As we default to disabled=true, we have to check here after loading our config module,
// before it was only checking against whatever is in the config starship.toml
if config.disabled {
return None;
};
let exit_code = context.properties.status_code.unwrap_or_default();
let pipestatus_status = match &context.pipestatus {
None => PipeStatusStatus::Disabled,
Some(ps) => match ps.len() > 1 {
true => PipeStatusStatus::Pipe(ps),
false => PipeStatusStatus::NoPipe,
},
};
let pipestatus_status = match config.pipestatus {
true => pipestatus_status,
false => PipeStatusStatus::Disabled,
};
// Exit code is zero and pipestatus is all zero or disabled/missing
if exit_code == 0
&& (match pipestatus_status {
PipeStatusStatus::Pipe(ps) => ps.iter().all(|s| s == "0"),
_ => true,
})
{
return None;
}
// Create pipestatus string
let pipestatus = match pipestatus_status {
PipeStatusStatus::Pipe(pipestatus) => pipestatus
.iter()
.map(
|ec| match format_exit_code(ec.as_str(), config.format, None, &config, context) {
Ok(segments) => segments
.into_iter()
.map(|s| s.to_string())
.collect::<Vec<String>>()
.join(""),
Err(_) => "".to_string(),
},
)
.collect::<Vec<String>>()
.join(config.pipestatus_separator),
_ => "".to_string(),
};
let main_format = match pipestatus_status {
PipeStatusStatus::Pipe(_) => config.pipestatus_format,
_ => config.format,
};
let parsed = format_exit_code(
&exit_code.to_string(),
main_format,
Some(&pipestatus),
&config,
context,
);
module.set_segments(match parsed {
Ok(segments) => segments,
Err(_error) => {
log::warn!("Error parsing format string in `status.format`");
return None;
}
});
Some(module)
}
fn format_exit_code<'a>(
exit_code: &'a str,
format: &'a str,
pipestatus: Option<&str>,
config: &'a StatusConfig,
context: &'a Context,
) -> Result<Vec<Segment>, StringFormatterError> {
let exit_code_int: ExitCode = match exit_code.parse() {
Ok(i) => i,
Err(_) => {
log::warn!("Error parsing exit_code string to int");
return Ok(Vec::new());
}
};
let hex_status = exit_code
.parse::<i32>()
.ok()
.map(|code| format!("0x{:X}", code));
let common_meaning = status_common_meaning(exit_code_int);
let raw_signal_number = match config.recognize_signal_code {
true => status_to_signal(exit_code_int),
false => None,
};
let signal_number = raw_signal_number.map(|sn| sn.to_string());
let signal_name = raw_signal_number
.and_then(|sn| status_signal_name(sn).or_else(|| signal_number.as_deref()));
// If not a signal and not a common meaning, it should at least print the raw exit code number
let maybe_exit_code_number = match common_meaning.is_none() && signal_name.is_none() {
true => Some(exit_code),
false => None,
};
StringFormatter::new(format).and_then(|formatter| {
formatter
.map_meta(|var, _| match var {
"symbol" => match exit_code_int {
0 => Some(config.success_symbol),
126 if config.map_symbol => Some(config.not_executable_symbol),
127 if config.map_symbol => Some(config.not_found_symbol),
130 if config.recognize_signal_code && config.map_symbol => {
Some(config.sigint_symbol)
}
x if (129..256).contains(&x)
&& config.recognize_signal_code
&& config.map_symbol =>
{
Some(config.signal_symbol)
}
_ => Some(config.symbol),
},
_ => None,
})
.map_style(|variable| match variable {
"style" => Some(Ok(config.style)),
_ => None,
})
.map(|variable| match variable {
"status" => Some(Ok(exit_code)),
"hex_status" => Ok(hex_status.as_deref().or(Some(exit_code))).transpose(),
"int" => Some(Ok(exit_code)),
"maybe_int" => Ok(maybe_exit_code_number).transpose(),
"common_meaning" => Ok(common_meaning).transpose(),
"signal_number" => Ok(signal_number.as_deref()).transpose(),
"signal_name" => Ok(signal_name).transpose(),
"pipestatus" => {
let pipestatus = pipestatus.unwrap_or_else(|| {
// We might enter this case if pipestatus hasn't
// been processed yet, which means that it has been
// set in format
log::warn!("pipestatus variable is only available in pipestatus_format");
""
});
Some(Ok(pipestatus))
}
_ => None,
})
.parse(None, Some(context))
})
}
fn status_common_meaning(ex: ExitCode) -> Option<&'static str> {
// Over 128 are Signal exit code
if ex > 128 {
return None;
}
match ex {
0 => Some(""),
1 => Some("ERROR"),
2 => Some("USAGE"),
126 => Some("NOPERM"),
127 => Some("NOTFOUND"),
_ => None,
}
}
fn status_to_signal(ex: ExitCode) -> Option<SignalNumber> {
if ex < 129 {
return None;
}
let sn = ex - 128;
Some(sn as u32)
}
fn status_signal_name(signal: SignalNumber) -> Option<&'static str> {
match signal {
1 => Some("HUP"), // 128 + 1
2 => Some("INT"), // 128 + 2
3 => Some("QUIT"), // 128 + 3
4 => Some("ILL"), // 128 + 4
5 => Some("TRAP"), // 128 + 5
6 => Some("IOT"), // 128 + 6
7 => Some("BUS"), // 128 + 7
8 => Some("FPE"), // 128 + 8
9 => Some("KILL"), // 128 + 9
10 => Some("USR1"), // 128 + 10
11 => Some("SEGV"), // 128 + 11
12 => Some("USR2"), // 128 + 12
13 => Some("PIPE"), // 128 + 13
14 => Some("ALRM"), // 128 + 14
15 => Some("TERM"), // 128 + 15
16 => Some("STKFLT"), // 128 + 16
17 => Some("CHLD"), // 128 + 17
18 => Some("CONT"), // 128 + 18
19 => Some("STOP"), // 128 + 19
20 => Some("TSTP"), // 128 + 20
21 => Some("TTIN"), // 128 + 21
22 => Some("TTOU"), // 128 + 22
_ => None,
}
}
#[cfg(test)]
mod tests {
use ansi_term::Color;
use crate::test::ModuleRenderer;
#[test]
fn success_status() {
let expected = None;
// Status code 0
let actual = ModuleRenderer::new("status")
.config(toml::toml! {
[status]
disabled = false
})
.status(0)
.collect();
assert_eq!(expected, actual);
// No status code
let actual = ModuleRenderer::new("status")
.config(toml::toml! {
[status]
disabled = false
})
.collect();
assert_eq!(expected, actual);
}
#[test]
fn not_enabled() {
let expected = None;
let actual = ModuleRenderer::new("status").status(1).collect();
assert_eq!(expected, actual);
}
#[test]
fn failure_status() {
let exit_values = [1, 2, 130];
for status in &exit_values {
let expected = Some(format!(
"{} ",
Color::Red.bold().paint(format!("{}", status))
));
let actual = ModuleRenderer::new("status")
.config(toml::toml! {
[status]
symbol = ""
disabled = false
})
.status(*status)
.collect();
assert_eq!(expected, actual);
}
}
#[test]
fn failure_hex_status() {
let exit_values = [1, 2, 130, -2147467260];
let string_values = ["0x1", "0x2", "0x82", "0x80004004"];
for (exit_value, string_value) in exit_values.iter().zip(string_values) {
let expected = Some(format!(
"{} ",
Color::Red.bold().paint(format!("{}", string_value))
));
let actual = ModuleRenderer::new("status")
.config(toml::toml! {
[status]
symbol = ""
disabled = false
format = "[${symbol}${hex_status}]($style) "
})
.status(*exit_value)
.collect();
assert_eq!(expected, actual);
}
}
#[test]
fn signal_name() {
let exit_values = [1, 2, 126, 127, 130, 101];
let exit_values_name = [
Some("ERROR"),
Some("USAGE"),
Some("NOPERM"),
Some("NOTFOUND"),
Some("INT"),
None,
];
for (status, name) in exit_values.iter().zip(&exit_values_name) {
let expected = name.map(std::string::ToString::to_string);
let actual = ModuleRenderer::new("status")
.config(toml::toml! {
[status]
format = "$common_meaning$signal_name"
disabled = false
})
.status(*status)
.collect();
assert_eq!(expected, actual);
}
}
#[test]
fn exit_code_name_no_signal() {
let exit_values = [1, 2, 126, 127, 130, 101, 132];
let exit_values_name = [
Some("ERROR"),
Some("USAGE"),
Some("NOPERM"),
Some("NOTFOUND"),
None,
None,
None,
];
for (status, name) in exit_values.iter().zip(&exit_values_name) {
let expected = name.map(std::string::ToString::to_string);
let actual = ModuleRenderer::new("status")
.config(toml::toml! {
[status]
format = "$common_meaning$signal_name"
recognize_signal_code = false
disabled = false
})
.status(*status)
.collect();
assert_eq!(expected, actual);
}
}
#[test]
fn maybe_exit_code_number() {
let exit_values = [1, 2, 126, 127, 130, 101, 6, -3];
let exit_values_name = [
None,
None,
None,
None,
None,
Some("101"),
Some("6"),
Some("-3"),
];
for (status, name) in exit_values.iter().zip(&exit_values_name) {
let expected = name.map(std::string::ToString::to_string);
let actual = ModuleRenderer::new("status")
.config(toml::toml! {
[status]
format = "$maybe_int"
disabled = false
})
.status(*status)
.collect();
assert_eq!(expected, actual);
}
}
#[test]
fn special_symbols() {
let exit_values = [1, 126, 127, 130, 131];
let exit_values_name = ["🔴", "🚫", "🔍", "🧱", ""];
for (status, name) in exit_values.iter().zip(&exit_values_name) {
let expected = Some((*name).to_string());
let actual = ModuleRenderer::new("status")
.config(toml::toml! {
[status]
format = "$symbol"
symbol = "🔴"
not_executable_symbol = "🚫"
not_found_symbol = "🔍"
sigint_symbol = "🧱"
signal_symbol = ""
recognize_signal_code = true
map_symbol = true
disabled = false
})
.status(*status)
.collect();
assert_eq!(expected, actual);
}
}
#[test]
fn special_symbols_no_signals() {
let exit_values = [1, 126, 127, 130, 131];
let exit_values_name = ["🔴", "🚫", "🔍", "🔴", "🔴"];
for (status, name) in exit_values.iter().zip(&exit_values_name) {
let expected = Some((*name).to_string());
let actual = ModuleRenderer::new("status")
.config(toml::toml! {
[status]
format = "$symbol"
symbol = "🔴"
not_executable_symbol = "🚫"
not_found_symbol = "🔍"
sigint_symbol = "🧱"
signal_symbol = ""
recognize_signal_code = false
map_symbol = true
disabled = false
})
.status(*status)
.collect();
assert_eq!(expected, actual);
}
}
#[test]
fn pipeline_uses_pipestatus_format() {
let exit_values = [
[0, 1, 0, 0],
[0, 1, 2, 3],
[130, 126, 131, 127],
[1, 1, 1, 1],
];
let exit_values_rendered = [
"PSF 🟢=🔴 🟢 🟢",
"PSF 🟢=🔴 🔴 🔴",
"PSF 🧱=🚫 ⚡ 🔍",
"PSF 🔴=🔴 🔴 🔴",
];
for (status, rendered) in exit_values.iter().zip(&exit_values_rendered) {
let main_exit_code = status[0];
let pipe_exit_code = &status[1..];
let expected = Some((*rendered).to_string());
let actual = ModuleRenderer::new("status")
.config(toml::toml! {
[status]
format = "$symbol"
symbol = "🔴"
success_symbol = "🟢"
not_executable_symbol = "🚫"
not_found_symbol = "🔍"
sigint_symbol = "🧱"
signal_symbol = ""
recognize_signal_code = true
map_symbol = true
pipestatus = true
pipestatus_separator = " "
pipestatus_format = "PSF $symbol=$pipestatus"
disabled = false
})
.status(main_exit_code)
.pipestatus(pipe_exit_code)
.collect();
assert_eq!(expected, actual);
}
}
#[test]
fn pipeline_no_map_symbols() {
let exit_values = [
[0, 1, 0, 0],
[0, 1, 2, 3],
[130, 126, 131, 127],
[1, 1, 1, 1],
];
let exit_values_rendered = [
"PSF 🟢=🔴1 🟢0 🟢0",
"PSF 🟢=🔴1 🔴2 🔴3",
"PSF INT🔴=🔴126 🔴1313 🔴127",
"PSF 🔴=🔴1 🔴1 🔴1",
];
for (status, rendered) in exit_values.iter().zip(&exit_values_rendered) {
let main_exit_code = status[0];
let pipe_exit_code = &status[1..];
let expected = Some((*rendered).to_string());
let actual = ModuleRenderer::new("status")
.config(toml::toml! {
[status]
format = "$symbol$int$signal_number"
symbol = "🔴"
success_symbol = "🟢"
not_executable_symbol = "🚫"
not_found_symbol = "🔍"
sigint_symbol = "🧱"
signal_symbol = ""
recognize_signal_code = true
map_symbol = false
pipestatus = true
pipestatus_separator = " "
pipestatus_format = "PSF $signal_name$symbol=$pipestatus"
disabled = false
})
.status(main_exit_code)
.pipestatus(pipe_exit_code)
.collect();
assert_eq!(expected, actual);
}
}
#[test]
fn successful_pipeline() {
let pipe_exit_code = [0, 0, 0];
let main_exit_code = 0;
let expected = None;
let actual = ModuleRenderer::new("status")
.config(toml::toml! {
[status]
disabled = false
})
.status(main_exit_code)
.pipestatus(&pipe_exit_code)
.collect();
assert_eq!(expected, actual);
}
#[test]
fn successful_pipeline_pipestatus_enabled() {
let pipe_exit_code = [0, 0, 0];
let main_exit_code = 0;
let expected = None;
let actual = ModuleRenderer::new("status")
.config(toml::toml! {
[status]
disabled = false
pipestatus = true
})
.status(main_exit_code)
.pipestatus(&pipe_exit_code)
.collect();
assert_eq!(expected, actual);
}
#[test]
fn pipeline_disabled() {
let exit_values = [[130, 126, 131, 127], [1, 1, 1, 1]];
let exit_values_rendered = ["F 🧱", "F 🔴"];
for (status, rendered) in exit_values.iter().zip(&exit_values_rendered) {
let main_exit_code = status[0];
let pipe_exit_code = &status[1..];
let expected = Some((*rendered).to_string());
let actual = ModuleRenderer::new("status")
.config(toml::toml! {
[status]
format = "F $symbol"
symbol = "🔴"
success_symbol = "🟢"
not_executable_symbol = "🚫"
not_found_symbol = "🔍"
sigint_symbol = "🧱"
signal_symbol = ""
recognize_signal_code = true
map_symbol = true
pipestatus = false
pipestatus_separator = " "
pipestatus_format = "PSF $symbol=$pipestatus"
disabled = false
})
.status(main_exit_code)
.pipestatus(pipe_exit_code)
.collect();
assert_eq!(expected, actual);
}
}
#[test]
fn pipeline_long() {
let exit_values = [
[130, 0, 0, 0, 30, 1, 2, 3, 142, 0, 0, 0, 130],
[1, 0, 0, 0, 30, 127, 126, 3, 142, 0, 230, 0, 2],
];
let exit_values_rendered = [
"PSF 130INT=🟢|🟢|🟢|🔴30|🔴|🔴|🔴3|⚡|🟢|🟢|🟢|🧱",
"PSF 1ERROR=🟢|🟢|🟢|🔴30|🔍|🚫|🔴3|⚡|🟢|⚡|🟢|🔴",
];
for (status, rendered) in exit_values.iter().zip(&exit_values_rendered) {
let main_exit_code = status[0];
let pipe_exit_code = &status[1..];
let expected = Some((*rendered).to_string());
let actual = ModuleRenderer::new("status")
.config(toml::toml! {
[status]
format = "$symbol$maybe_int"
symbol = "🔴"
success_symbol = "🟢"
not_executable_symbol = "🚫"
not_found_symbol = "🔍"
sigint_symbol = "🧱"
signal_symbol = ""
recognize_signal_code = true
map_symbol = true
pipestatus = true
pipestatus_separator = "|"
pipestatus_format = "PSF $int$common_meaning$signal_name=$pipestatus"
disabled = false
})
.status(main_exit_code)
.pipestatus(pipe_exit_code)
.collect();
assert_eq!(expected, actual);
}
}
}