9ed9882 term: Handle SIGPIPE — heartwood

Radicle Heartwood Protocol & Stack

term: Handle SIGPIPE

Fintan Halpenny committed 1 month ago

commit 9ed9882acd809e69aa4110979901c93590283679
parent ab7ad8de948144f9f1d0be024177b9ed32d2879a

2 files changed +62 -23

modified crates/radicle-term/src/element.rs

@@ -84,8 +84,15 @@ pub trait Element: fmt::Debug + Send + Sync {

     /// Print this element to stdout.
     fn print(&self) {
         use std::io::Write;
         let mut stdout = io::stdout().lock();
         for line in self.render(Constraint::from_env().unwrap_or_default()) {
             println!("{}", line.to_string().trim_end());
             match writeln!(stdout, "{}", line.to_string().trim_end()) {
                 Ok(()) => {}
                 Err(e) if e.kind() == io::ErrorKind::BrokenPipe => break,
                 Err(e) => panic!("failed printing to stdout: {e}"),
             }
         }
     }

modified crates/radicle-term/src/io.rs

@@ -74,7 +74,7 @@ macro_rules! info {

         writeln!($writer, $($arg)*).ok();
     });
     ($($arg:tt)*) => ({
         println!("{}", format_args!($($arg)*));
         $crate::io::print(format_args!($($arg)*));
     })
 }

@@ -118,11 +118,11 @@ pub fn success_args<W: io::Write>(w: &mut W, args: fmt::Arguments) {

 }
 pub fn tip_args(args: fmt::Arguments) {
     println!(
     print(format_args!(
         "{} {}",
         format::yellow("*"),
         style(format!("{args}")).italic()
     );
     ));
 }
 pub fn notice_args<W: io::Write>(w: &mut W, args: fmt::Arguments) {

@@ -148,27 +148,56 @@ pub fn viewport() -> Option<Size> {

 }
 pub fn headline(headline: impl fmt::Display) {
     println!();
     println!("{}", style(headline).bold());
     println!();
     print("");
     print(style(headline).bold());
     print("");
 }
 pub fn header(header: &str) {
     println!();
     println!("{}", style(format::yellow(header)).bold().underline());
     println!();
     print("");
     print(style(format::yellow(header)).bold().underline());
     print("");
 }
 pub fn blob(text: impl fmt::Display) {
     println!("{}", style(text.to_string().trim()).dim());
     print(style(text.to_string().trim()).dim());
 }
 pub fn blank() {
     println!()
     print("");
 }
 /// Print a line to stdout, silently handling broken pipe errors.
 ///
 /// This is the primary output function for the CLI. All user-facing stdout
 /// output should go through this function (or [`print_inline`]) to avoid
 /// panicking on broken pipes (e.g. `rad config | head`).
 ///
 /// See: <https://github.com/rust-lang/rust/issues/62569>
 pub fn print(msg: impl fmt::Display) {
     println!("{msg}");
     use io::Write;
     let mut stdout = io::stdout().lock();
     match writeln!(stdout, "{msg}") {
         Ok(()) => {}
         Err(e) if e.kind() == io::ErrorKind::BrokenPipe => {}
         Err(e) => panic!("failed printing to stdout: {e}"),
     }
 }
 /// Print to stdout without a trailing newline, silently handling broken pipe
 /// errors.
 ///
 /// See [`self::print`] for details.
 pub fn print_inline(msg: impl fmt::Display) {
     use io::Write;
     let mut stdout = io::stdout().lock();
     match write!(stdout, "{msg}") {
         Ok(()) => {}
         Err(e) if e.kind() == io::ErrorKind::BrokenPipe => {}
         Err(e) => panic!("failed printing to stdout: {e}"),
     }
 }
 pub fn prefixed(prefix: &str, text: &str) -> String {

@@ -179,7 +208,7 @@ pub fn prefixed(prefix: &str, text: &str) -> String {

 }
 pub fn help(name: &str, version: &str, description: &str, usage: &str) {
     println!("rad-{name} {version}\n{description}\n{usage}");
     print(format_args!("rad-{name} {version}\n{description}\n{usage}"));
 }
 pub fn manual(name: &str) -> io::Result<process::ExitStatus> {

@@ -192,40 +221,43 @@ pub fn manual(name: &str) -> io::Result<process::ExitStatus> {

 }
 pub fn usage(name: &str, usage: &str) {
     println!(
     print(format_args!(
         "{} {}\n{}",
         PREFIX_ERROR,
         Paint::red(format!("Error: rad-{name}: invalid usage")),
         Paint::red(prefixed(TAB, usage)).dim()
     );
     ));
 }
 pub fn println(prefix: impl fmt::Display, msg: impl fmt::Display) {
     println!("{prefix} {msg}");
     print(format_args!("{prefix} {msg}"));
 }
 pub fn indented(msg: impl fmt::Display) {
     println!("{TAB}{msg}");
     print(format_args!("{TAB}{msg}"));
 }
 pub fn subcommand(msg: impl fmt::Display) {
     println!("{}", style(format!("Running `{msg}`...")).dim());
     print(style(format!("Running `{msg}`...")).dim());
 }
 pub fn warning(warning: impl fmt::Display) {
     println!(
     print(format_args!(
         "{} {} {warning}",
         PREFIX_WARNING,
         Paint::yellow("Warning:").bold(),
     );
     ));
 }
 pub fn error(error: impl fmt::Display) {
     println!("{PREFIX_ERROR} {} {error}", Paint::red("Error:"));
     print(format_args!(
         "{PREFIX_ERROR} {} {error}",
         Paint::red("Error:")
     ));
 }
 pub fn hint(hint: impl fmt::Display) {
     println!("{}", format::hint(format!("{SYMBOL_ERROR} Hint: {hint}")));
     print(format::hint(format!("{SYMBOL_ERROR} Hint: {hint}")));
 }
 pub fn ask<D: fmt::Display>(prompt: D, default: bool) -> bool {