Add cmd_lib::main attribute macro to log main() error by default

Author: tao-guo

Cargo.toml

@@ -21,7 +21,6 @@ lazy_static = "1.4.0"
 log = "0.4.17"
 faccess = "0.2.4"
 os_pipe = "1.1.3"
-main_error = "0.1.2"
 env_logger = "0.10.0"
 
 [dev-dependencies]

README.md

@@ -91,16 +91,14 @@ run_cmd!(du -ah $dir | sort -hr | head -n 10)?;
 // if any command fails, just return Err(...)
 let file = "/tmp/f";
 let keyword = "rust";
-if run_cmd! {
+run_cmd! {
     cat ${file} | grep ${keyword};
     echo "bad cmd" >&2;
     ignore ls /nofile;
     date;
     ls oops;
     cat oops;
-}.is_err() {
-    // your error handling code
-}
+}?;
 ```
 
 - run_fun! --> FunResult
@@ -183,6 +181,12 @@ It is using rust [log crate](https://crates.io/crates/log), and you can use your
 logger implementation. Notice that if you don't provide any logger, it will use env_logger to print
 messages from process's stderr.
 
+You can also mark your `main()` function with `#[cmd_lib::main]`, which will log error from
+main() by default. Like this:
+```console
+[ERROR] FATAL: Running ["mkdir" "/tmp/folder with spaces"] exited with error; status code: 1
+```
+
 #### Builtin commands
 ##### cd
 cd: set process current directory.

examples/dd_test.rs

@@ -33,6 +33,7 @@ struct Opt {
     file: String,
 }
 
+#[cmd_lib::main]
 fn main() -> MainResult {
     let Opt {
         block_size,

examples/pipes.rs

@@ -338,6 +338,7 @@ fn rand() -> i32 {
     run_fun!(bash -c r"echo $RANDOM").unwrap().parse().unwrap()
 }
 
+#[cmd_lib::main]
 fn main() -> MainResult {
     // simple pre-check of TERM, tput's error message should be enough
     let term = std::env::var("TERM").unwrap();

examples/rust_cookbook.rs

@@ -4,6 +4,8 @@
 //
 use cmd_lib::*;
 use std::io::{BufRead, BufReader};
+
+#[cmd_lib::main]
 fn main() -> MainResult {
     cmd_lib::set_pipefail(false); // do not fail due to pipe errors
 

examples/tetris.rs

@@ -556,6 +556,7 @@ fn cmd_exit() {
     std::process::exit(0);
 }
 
+#[cmd_lib::main]
 fn main() -> MainResult {
     #[rustfmt::skip]
     let old_cfg = run_fun!(stty -g)?; // let's save terminal state ...

macros/src/lib.rs

@@ -2,6 +2,44 @@ use proc_macro2::{Span, TokenStream, TokenTree};
 use proc_macro_error::{abort, proc_macro_error};
 use quote::{quote, ToTokens};
 
+/// Mark main function to log error result by default
+///
+/// ```
+/// # use cmd_lib::*;
+///
+/// #[cmd_lib::main]
+/// fn main() -> MainResult {
+///     run_cmd!(bad_cmd)?;
+///     Ok(())
+/// }
+/// // output:
+/// // [ERROR] FATAL: Running ["bad_cmd"] failed: No such file or directory (os error 2)
+/// ```
+#[proc_macro_attribute]
+pub fn main(
+    _args: proc_macro::TokenStream,
+    item: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    let orig_function: syn::ItemFn = syn::parse2(item.into()).unwrap();
+    let orig_main_return_type = orig_function.sig.output;
+    let orig_main_block = orig_function.block;
+
+    quote! (
+        fn main() {
+            fn cmd_lib_main() #orig_main_return_type {
+                #orig_main_block
+            }
+
+            cmd_lib_main().unwrap_or_else(|err| {
+                ::cmd_lib::error!("FATAL: {err}");
+                std::process::exit(1);
+            });
+        }
+
+    )
+    .into()
+}
+
 /// Export the function as an command to be run by `run_cmd!` or `run_fun!`
 ///
 /// ```
@@ -210,9 +248,7 @@ pub fn spawn_with_output(input: proc_macro::TokenStream) -> proc_macro::TokenStr
 pub fn cmd_die(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let msg = parse_msg(input.into());
     quote!({
-        use ::cmd_lib::error;
-        use ::cmd_lib::AsOsStr;
-        error!("FATAL: {}", #msg);
+        ::cmd_lib::error!("FATAL: {}", #msg);
         std::process::exit(1)
     })
     .into()

src/lib.rs

@@ -99,16 +99,14 @@
 //! // if any command fails, just return Err(...)
 //! let file = "/tmp/f";
 //! let keyword = "rust";
-//! if run_cmd! {
+//! run_cmd! {
 //!     cat ${file} | grep ${keyword};
 //!     echo "bad cmd" >&2;
 //!     ignore ls /nofile;
 //!     date;
 //!     ls oops;
 //!     cat oops;
-//! }.is_err() {
-//!     // your error handling code
-//! }
+//! }?;
 //! # Ok::<(), std::io::Error>(())
 //! ```
 //!
@@ -202,6 +200,12 @@
 //! logger implementation. Notice that if you don't provide any logger, it will use env_logger to print
 //! messages from process's stderr.
 //!
+//! You can also mark your `main()` function with `#[cmd_lib::main]`, which will log error from
+//! main() by default. Like this:
+//! ```console
+//! [ERROR] FATAL: Running ["mkdir" "/tmp/folder with spaces"] exited with error; status code: 1
+//! ```
+//!
 //! ### Builtin commands
 //! #### cd
 //! cd: set process current directory.
@@ -356,7 +360,7 @@
 //!
 
 pub use cmd_lib_macros::{
-    cmd_die, export_cmd, run_cmd, run_fun, spawn, spawn_with_output, use_custom_cmd,
+    cmd_die, export_cmd, main, run_cmd, run_fun, spawn, spawn_with_output, use_custom_cmd,
 };
 /// Return type for run_fun!() macro
 pub type FunResult = std::io::Result<String>;
@@ -378,5 +382,6 @@ mod builtins;
 mod child;
 mod io;
 mod logger;
+mod main_error;
 mod process;
 mod thread_local;

src/main_error.rs

@@ -0,0 +1,28 @@
+use std::error::Error;
+use std::fmt::{self, Debug, Display};
+
+// Modified from https://github.com/danleh/main_error
+pub struct MainError(Box<dyn Error>);
+
+impl<E: Into<Box<dyn Error>>> From<E> for MainError {
+    fn from(e: E) -> Self {
+        MainError(e.into())
+    }
+}
+
+impl Display for MainError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+// Impl Debug (to satisfy trait bound for main()-Result error reporting), but use Display of wrapped
+// error internally (for nicer output).
+impl Debug for MainError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+/// Convenient type as a shorthand return type for `main()`.
+pub type MainResult = Result<(), MainError>;