use std::ffi::{OsStr, OsString};
use std::fmt;
use std::process::ExitStatus;
use crate::{Error, Result, TmuxText};
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct CommandSummary(String);
impl CommandSummary {
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Display for CommandSummary {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(&self.0)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
struct Argument {
value: OsString,
sensitive: bool,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Command {
subcommand: OsString,
arguments: Vec<Argument>,
input: Option<TmuxText>,
sensitive_input: bool,
}
impl Command {
#[must_use]
pub fn new(subcommand: impl Into<OsString>) -> Self {
Self {
subcommand: subcommand.into(),
arguments: Vec::new(),
input: None,
sensitive_input: false,
}
}
#[must_use]
pub fn arg(mut self, argument: impl Into<OsString>) -> Self {
self.arguments.push(Argument {
value: argument.into(),
sensitive: false,
});
self
}
#[must_use]
pub fn args<I, S>(mut self, arguments: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<OsString>,
{
self.arguments
.extend(arguments.into_iter().map(|value| Argument {
value: value.into(),
sensitive: false,
}));
self
}
#[must_use]
pub fn sensitive_arg(mut self, argument: impl Into<OsString>) -> Self {
self.arguments.push(Argument {
value: argument.into(),
sensitive: true,
});
self
}
#[must_use]
pub fn target(self, target: impl fmt::Display) -> Self {
self.arg("-t").arg(target.to_string())
}
#[must_use]
pub fn input(mut self, input: impl Into<TmuxText>) -> Self {
self.input = Some(input.into());
self.sensitive_input = false;
self
}
#[must_use]
pub fn sensitive_input(mut self, input: impl Into<TmuxText>) -> Self {
self.input = Some(input.into());
self.sensitive_input = true;
self
}
#[must_use]
pub fn subcommand(&self) -> &OsStr {
&self.subcommand
}
#[must_use]
pub fn arguments(&self) -> impl ExactSizeIterator<Item = &OsStr> {
self.arguments
.iter()
.map(|argument| argument.value.as_os_str())
}
pub(crate) const fn standard_input(&self) -> Option<&TmuxText> {
self.input.as_ref()
}
#[must_use]
pub fn summary(&self) -> CommandSummary {
let mut parts = Vec::with_capacity(self.arguments.len() + 1);
parts.push(self.subcommand.to_string_lossy().into_owned());
parts.extend(self.arguments.iter().map(|argument| {
if argument.sensitive {
"<redacted>".to_owned()
} else {
argument.value.to_string_lossy().into_owned()
}
}));
if self.input.is_some() {
parts.push(if self.sensitive_input {
"<stdin:redacted>".to_owned()
} else {
"<stdin>".to_owned()
});
}
CommandSummary(parts.join(" "))
}
}
#[derive(Clone, Debug)]
pub struct CommandResult {
status: ExitStatus,
stdout: TmuxText,
stderr: TmuxText,
summary: CommandSummary,
}
impl CommandResult {
pub(crate) fn new(
status: ExitStatus,
stdout: Vec<u8>,
stderr: Vec<u8>,
summary: CommandSummary,
) -> Self {
Self {
status,
stdout: stdout.into(),
stderr: stderr.into(),
summary,
}
}
#[must_use]
pub fn success(&self) -> bool {
self.status.success()
}
#[must_use]
pub const fn status(&self) -> ExitStatus {
self.status
}
#[must_use]
pub const fn stdout(&self) -> &TmuxText {
&self.stdout
}
#[must_use]
pub const fn stderr(&self) -> &TmuxText {
&self.stderr
}
#[must_use]
pub const fn summary(&self) -> &CommandSummary {
&self.summary
}
pub fn stdout_lines(&self) -> impl Iterator<Item = TmuxText> + '_ {
self.stdout
.as_bytes()
.split(|byte| *byte == b'\n')
.filter(|line| !line.is_empty())
.map(|line| TmuxText::new(line.strip_suffix(b"\r").unwrap_or(line).to_vec()))
}
pub fn stderr_lines(&self) -> impl Iterator<Item = TmuxText> + '_ {
self.stderr
.as_bytes()
.split(|byte| *byte == b'\n')
.filter(|line| !line.is_empty())
.map(|line| TmuxText::new(line.strip_suffix(b"\r").unwrap_or(line).to_vec()))
}
pub fn ensure_success(self, operation: &'static str) -> Result<Self> {
if self.success() {
Ok(self)
} else {
Err(Error::CommandFailed {
operation,
result: Box::new(self),
})
}
}
}
#[cfg(test)]
mod tests {
use super::Command;
#[test]
fn redacts_sensitive_arguments() {
let command = Command::new("set-environment")
.arg("TOKEN")
.sensitive_arg("secret")
.sensitive_input("secret input");
assert_eq!(
command.summary().as_str(),
"set-environment TOKEN <redacted> <stdin:redacted>"
);
assert!(!command.summary().as_str().contains("secret"));
}
}