Add parameters to main!, add logging

Author: killercup

Cargo.lock

@@ -16,6 +16,8 @@ serde = "1.0.27"
 serde_derive = "1.0.27"
 structopt = "0.1.6"
 structopt-derive = "0.1.6"
+log = "0.4.1"
+env_logger = "0.5.3"
 
 [dev-dependencies]
 reqwest = "0.8.3"

Cargo.toml

@@ -28,12 +28,14 @@ Quickly build cool CLI apps in Rust.
     serde = "1"
     ```
 
-3. Now, open up your `src/main.rs`. First, let's import all the good stuff:
+3. Now, open up your `src/main.rs`. Let's import all the good stuff:
 
     ```rust
     #[macro_use] extern crate quicli;
     use quicli::prelude::*;
     ```
+    
+    That's it. That's all the imports you should need for now.
 
 4. Now, quickly write a cool CLI (it's also okay to type slowly):
 
@@ -49,11 +51,14 @@ Quickly build cool CLI apps in Rust.
         // Add a positional argument that the user has to supply:
         /// The file to read
         file: String,
+        /// Pass many times for more log output
+        #[structopt(long = "verbosity", short = "v")]
+        verbosity: u64,
     }
 
-    main!({
-        let args = Cli::from_args();
-        let data = read_file(args.file)?;
+    main!(|args: Cli, log_level: verbosity| {
+        let data = read_file(&args.file)?;
+        info!("Reading first {} lines of {:?}", args.count, args.file);
         data.lines().take(args.count).for_each(|line| println!("{}", line));
     });
     ```
@@ -65,6 +70,8 @@ Quickly build cool CLI apps in Rust.
     3. How about `cargo run -- Cargo.toml --count=4` or `cargo run -- Cargo.toml -n 2`?
     4. `cargo run -- --help` -- how cool is that?
     5. More fun: Try `--cont 4` (with the missing u).
+    6. You like log messages? That's what we added the `verbosity` field for!
+       Give `cargo run -- Cargo.toml -vv` a try!
 
 ## Thanks
 

Readme.md

@@ -9,17 +9,19 @@ struct Cli {
     /// How many?
     #[structopt(long = "amount", default_value = "3")]
     amount: i32,
+    /// Pass many times for more log output
+    #[structopt(long = "verbosity", short = "v")]
+    verbosity: u64,
 }
 
 #[derive(Debug, Deserialize)]
 struct Commit {
     commit_message: String,
 }
 
-main!({
-    let args = Cli::from_args();
-
+main!(|args: Cli, log_level: verbosity| {
     for i in 0..args.amount {
+        info!("try {}", i);
         let c: Commit = reqwest::get("https://whatthecommit.com/index.json")?.json()?;
         println!("{}) {}", i + 1, c.commit_message);
     }

examples/commit_message.rs

@@ -14,8 +14,7 @@ struct Cli {
     file: String,
 }
 
-main!({
-    let args = Cli::from_args();
+main!(|args: Cli| {
     let data = read_file(args.file)?;
     data.lines().take(args.count).for_each(|line| println!("{}", line));
 });

examples/readme_example.rs

@@ -12,6 +12,9 @@ extern crate structopt;
 #[macro_use] extern crate failure_derive;
 #[macro_use] extern crate failure;
 
+#[macro_use] extern crate log;
+extern crate env_logger;
+
 mod fs;
 mod main_macro;
 
@@ -26,6 +29,8 @@ mod reexports {
 
     #[doc(hidden)] pub use failure_derive::*;
     #[doc(hidden)] pub use failure::*;
+
+    #[doc(hidden)] pub use log::*;
 }
 
 /// Prelude – import all of this
@@ -42,4 +47,7 @@ pub mod prelude {
     pub type Result<T> = ::std::result::Result<T, ::failure::Error>;
 
     pub use fs::{read_file, write_to_file};
+
+    #[doc(hidden)] pub use env_logger::Builder as LoggerBuiler;
+    #[doc(hidden)] pub use log::Level as LogLevel;
 }

src/lib.rs

@@ -3,8 +3,22 @@
 /// Inside the block, you can write code using `?`. An `Ok(())` will
 /// automatically be appended.
 ///
-/// _Note:_ This will be deprecated once the `try_main` feature is stabilized in
-/// Rust.
+/// # Parameters
+///
+/// You can optionally call this macro with a closure-like syntax to get some
+/// default bindings:
+///
+/// - `main!(|args: Cli| { ... })`: Automatically parses command line flags into
+///   a struct `Cli` and binds it to `args`. (Basically, it prepends
+///   `let args = Cli::from_args();`).
+/// - `main!(|args: Cli, log_level: verbosity| { ... })`: In addition to parsing
+///   the command line flags into `args` of type `Cli`, it will also initialize
+///   a logger.
+///
+///   The log level will depend on the integer value of the `verbosity` field of
+///   `args` (error = 0, warn = 1, info = 2, debug = 3, trace = ≥4). The field's
+///   type should be `u64`, so structopt will automatically give you its
+///   number of occurances.
 ///
 /// # Examples
 ///
@@ -19,6 +33,60 @@
 /// ```
 #[macro_export]
 macro_rules! main {
+    (|$args:ident: $cli:ty, log_level: $verbosity:ident| $body:expr) => {
+        fn main() {
+            fn run() -> $crate::prelude::Result<()> {
+                let $args = <$cli>::from_args();
+                let log_level = match $args.verbosity {
+                    0 => $crate::prelude::LogLevel::Error,
+                    1 => $crate::prelude::LogLevel::Warn,
+                    2 => $crate::prelude::LogLevel::Info,
+                    3 => $crate::prelude::LogLevel::Debug,
+                    _ => $crate::prelude::LogLevel::Trace,
+                }.to_level_filter();
+
+                $crate::prelude::LoggerBuiler::new()
+                    .filter(Some(env!("CARGO_PKG_NAME")), log_level)
+                    .filter(None, $crate::prelude::LogLevel::Info.to_level_filter())
+                    .try_init()?;
+
+                $body
+
+                Ok(())
+            }
+
+            match run() {
+                Ok(_) => {}
+                Err(e) => {
+                    eprintln!("{}", e);
+                    ::std::process::exit(1);
+                }
+            }
+        }
+    };
+
+    (|$args:ident: $cli:ty| $body:expr) => {
+        fn main() {
+            fn run() -> $crate::prelude::Result<()> {
+                let $args = <$cli>::from_args();
+
+                $body
+
+                Ok(())
+            }
+
+            match run() {
+                Ok(_) => {}
+                Err(e) => {
+                    eprintln!("{}", e);
+                    ::std::process::exit(1);
+                }
+            }
+        }
+    };
+
+    (|| $body:expr) => { main!($body); };
+
     ($body:expr) => {
         fn main() {
             fn run() -> $crate::prelude::Result<()> {