beb3427 · helix · git.iko.soy

git.iko.soy/helix

on master help sign in

improve app close failure display

beb3427Skyler Hawthorne4 years ago

helix-term/src/application.rs+23−49

compare with master

unifiedsplit

@@ -951,28 +951,10 @@ impl Application {

951

952 self.event_loop(input_stream).await;

953

954− // let mut save_errs = Vec::new();

955−

956− // for doc in self.editor.documents_mut() {

957− // if let Some(Err(err)) = doc.close().await {

958− // save_errs.push((

959− // doc.path()

960− // .map(|path| path.to_string_lossy().into_owned())

961− // .unwrap_or_else(|| "".into()),

962− // err,

963− // ));

964− // }

965− // }

966−

967− let close_err = self.close().await.err();

954+ let close_errs = self.close().await;

968 restore_term()?;

955 restore_term()?;

969

956

970− // for (path, err) in save_errs {

957+ for err in close_errs {

971− // self.editor.exit_code = 1;

972− // eprintln!("Error closing '{}': {}", path, err);

973− // }

974−

975− if let Some(err) = close_err {

976 self.editor.exit_code = 1;

958 self.editor.exit_code = 1;

977 eprintln!("Error: {}", err);

959 eprintln!("Error: {}", err);

978 }

960 }

@@ -980,49 +962,41 @@ impl Application {

980 Ok(self.editor.exit_code)

962 Ok(self.editor.exit_code)

981 }

963 }

982

964

983− pub async fn close(&mut self) -> anyhow::Result<()> {

965+ pub async fn close(&mut self) -> Vec<anyhow::Error> {

984 // [NOTE] we intentionally do not return early for errors because we

966 // [NOTE] we intentionally do not return early for errors because we

985 // want to try to run as much cleanup as we can, regardless of

967 // want to try to run as much cleanup as we can, regardless of

986 // errors along the way

968 // errors along the way

969+ let mut errs = Vec::new();

987

970

988− let mut result = match self

971+ if let Err(err) = self

989 .jobs

972 .jobs

990 .finish(&mut self.editor, Some(&mut self.compositor))

973 .finish(&mut self.editor, Some(&mut self.compositor))

991 .await

974 .await

992 {

975 {

993− Ok(_) => Ok(()),

994− Err(err) => {

995− log::error!("Error executing job: {}", err);

976+ log::error!("Error executing job: {}", err);

996− Err(err)

977+ errs.push(err);

997− }

998 };

978 };

999

979

1000 for doc in self.editor.documents_mut() {

980 for doc in self.editor.documents_mut() {

1001− if let Some(save_result) = doc.close().await {

981+ if let Some(Err(err)) = doc.close().await {

1002− result = match save_result {

1003− Ok(_) => result,

1004− Err(err) => {

1005− if let Some(path) = doc.path() {

982+ if let Some(path) = doc.path() {

1006− log::error!(

983+ log::error!(

1007− "Error saving document '{}': {}",

984+ "Error saving document '{}': {}",

1008− path.to_string_lossy(),

985+ path.to_string_lossy(),

1009− err

986+ err

1010− );

987+ );

1011− }

988+ }

1012− Err(err)

989+ errs.push(err);

1013− }

1014− };

1015 }

990 }

1016 }

991 }

1017

992

1018− match self.editor.close_language_servers(None).await {

993+ if self.editor.close_language_servers(None).await.is_err() {

1019− Ok(_) => result,

1020− Err(_) => {

1021− log::error!("Timed out waiting for language servers to shutdown");

994+ log::error!("Timed out waiting for language servers to shutdown");

1022− Err(anyhow::format_err!(

995+ errs.push(anyhow::format_err!(

1023− "Timed out waiting for language servers to shutdown"

996+ "Timed out waiting for language servers to shutdown"

1024− ))

997+ ));

1025− }

1026 }

998 }

999+

1000+ errs

1027 }

1001 }

1028}

1002}

helix-term/tests/test/helpers.rs+11−1

@@ -94,7 +94,17 @@ pub async fn test_key_sequences(

94 tokio::time::timeout(TIMEOUT, event_loop).await?;

95 }

97− app.close().await?;

97+ let errs = app.close().await;

98+

99+ if !errs.is_empty() {

100+ log::error!("Errors closing app");

101+

102+ for err in errs {

103+ log::error!("{}", err);

104+ }

105+

106+ bail!("Error closing app");

107+ }

108

99 Ok(())

109 Ok(())

100}

110}