diff --git a/Cargo.toml b/Cargo.toml index 25057c7..17006d2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "vlog" -version = "0.1.2" +version = "0.1.3" authors = ["Chen Weiguang "] description = "Macros to do stdout / stderr logs based on verbosity level." documentation = "https://docs.rs/vlog" @@ -15,7 +15,7 @@ travis-ci = { repository = "guangie88/vlog-rs" } codecov = { repository = "guangie88/vlog-rs" } # [dev-dependencies] -# gag = "0.1.9" +# gag = "0.1.10" [lib] name = "vlog" diff --git a/README.md b/README.md index 35c3f00..50ac313 100644 --- a/README.md +++ b/README.md @@ -26,25 +26,43 @@ use vlog::{get_verbosity_level, set_verbosity_level}; fn main() { // default verbosity level is 0 assert_eq!(0, get_verbosity_level()); - v0!("v0 prints"); - v1!("v1 won't print"); - v2!("v2 won't print"); - v3!("v3 won't print"); + + v0!("v0 stdout prints"); + v1!("v1 stdout won't print"); + v2!("v2 stdout won't print"); + v3!("v3 stdout won't print"); + + ve0!("ve0 stderr prints"); + ve1!("ve1 stderr won't print"); + ve2!("ve2 stderr won't print"); + ve3!("ve3 stderr won't print"); // set custom verbosity level set_verbosity_level(1); assert_eq!(1, get_verbosity_level()); - v0!("{} prints", "v0"); - v1!("{} prints", "v1"); - v2!("{} won't print", "v2"); - v3!("{} won't print", "v3"); + + v0!("{} stdout prints", "v0"); + v1!("{} stdout prints", "v1"); + v2!("{} stdout won't print", "v2"); + v3!("{} stdout won't print", "v3"); + + ve0!("{} stderr prints", "ve0"); + ve1!("{} stderr prints", "ve1"); + ve2!("{} stderr won't print", "ve2"); + ve3!("{} stderr won't print", "ve3"); // set custom max verbosity level set_verbosity_level(3); assert_eq!(3, get_verbosity_level()); - v0!("{} prints", "v0"); - v1!("{} prints", "v1"); - v2!("{} prints", "v2"); - v3!("{} prints", "v3"); + + v0!("{} stdout prints", "v0"); + v1!("{} stdout prints", "v1"); + v2!("{} stdout prints", "v2"); + v3!("{} stdout prints", "v3"); + + ve0!("{} stderr prints", "ve0"); + ve1!("{} stderr prints", "ve1"); + ve2!("{} stderr prints", "ve2"); + ve3!("{} stderr prints", "ve3"); } ``` diff --git a/appveyor.yml b/appveyor.yml index 053e989..7a6bc78 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -1,7 +1,7 @@ # source: https://github.com/starkat99/appveyor-rust/blob/master/appveyor.yml # source: https://github.com/japaric/rust-everywhere/blob/master/appveyor.yml -version: 0.1.2-build{build} +version: 0.1.3-build-{build} matrix: fast_finish: true diff --git a/examples/simple.rs b/examples/simple.rs index 596f068..66adc4a 100644 --- a/examples/simple.rs +++ b/examples/simple.rs @@ -95,9 +95,37 @@ fn print_v3() { ve3!("[STDERR] {}", "formatted v3"); } +mod nest { + use super::*; + + pub fn print_another_v3() { + set_verbosity_level(3); + println!("\nAnother round of verbosity level 3!"); + + v0!("[STDOUT] v0"); + v0!("[STDOUT] {}", "formatted v0"); + v1!("[STDOUT] v1"); + v1!("[STDOUT] {}", "formatted v1"); + v2!("[STDOUT] v2"); + v2!("[STDOUT] {}", "formatted v2"); + v3!("[STDOUT] v3"); + v3!("[STDOUT] {}", "formatted v3"); + + ve0!("[STDERR] v0"); + ve0!("[STDERR] {}", "formatted v0"); + ve1!("[STDERR] v1"); + ve1!("[STDERR] {}", "formatted v1"); + ve2!("[STDERR] v2"); + ve2!("[STDERR] {}", "formatted v2"); + ve3!("[STDERR] v3"); + ve3!("[STDERR] {}", "formatted v3"); + } +} + fn main() { print_v0(); print_v1(); print_v2(); print_v3(); + nest::print_another_v3(); } diff --git a/src/lib.rs b/src/lib.rs index dd98c2a..9c4f41b 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -42,9 +42,11 @@ //! } //! ``` -// TODO: `gag` does not seem to work properly anymore -// #[cfg(test)] -// extern crate gag; +#[macro_use] +mod macros; + +#[cfg(test)] +mod tests; use std::sync::atomic::{AtomicUsize, Ordering}; @@ -67,6 +69,7 @@ static mut VERBOSITY_LEVEL: AtomicUsize = AtomicUsize::new(0); /// // max verbosity level /// set_verbosity_level(3); /// ``` +#[inline] pub fn set_verbosity_level(verbosity_level: usize) { unsafe { VERBOSITY_LEVEL.store(verbosity_level, Ordering::Relaxed) } } @@ -84,158 +87,7 @@ pub fn set_verbosity_level(verbosity_level: usize) { /// set_verbosity_level(1); /// assert_eq!(1, get_verbosity_level()); /// ``` +#[inline] pub fn get_verbosity_level() -> usize { unsafe { VERBOSITY_LEVEL.load(Ordering::Relaxed) } } - -/// Common macro for verbose `stdout` logs. -/// This is meant to be used internally only. -#[macro_export] -macro_rules! verbose_log { - ($v:expr, $fmt:expr) => { - if $v <= ::vlog::get_verbosity_level() { - println!($fmt); - } - }; - ($v:expr, $fmt:expr, $($arg:tt)*) => { - if $v <= ::vlog::get_verbosity_level() { - println!($fmt, $($arg)*); - } - }; -} - -/// Common macro for verbose `stderr` logs. -/// This is meant to be used internally only. -#[macro_export] -macro_rules! verbose_elog { - ($v:expr, $fmt:expr) => { - if $v <= ::vlog::get_verbosity_level() { - eprintln!($fmt); - } - }; - ($v:expr, $fmt:expr, $($arg:tt)*) => { - if $v <= ::vlog::get_verbosity_level() { - eprintln!($fmt, $($arg)*); - } - }; -} - -/// Always prints to `stdout`. Follows -/// [`format!`](https://doc.rust-lang.org/std/macro.format.html) style. -#[macro_export] -macro_rules! v0 { - ($fmt:expr) => { println!($fmt); }; - ($fmt:expr, $($arg:tt)*) => { println!($fmt, $($arg)*); }; -} - -/// Prints to `stdout` if verbosity level is >= 1. Follows -/// [`format!`](https://doc.rust-lang.org/std/macro.format.html) style. -#[macro_export] -macro_rules! v1 { - ($fmt:expr) => { verbose_log!(1, $fmt); }; - ($fmt:expr, $($arg:tt)*) => { verbose_log!(1, $fmt, $($arg)*); }; -} - -/// Prints to `stdout` if verbosity level is >= 2. Follows -/// [`format!`](https://doc.rust-lang.org/std/macro.format.html) style. -#[macro_export] -macro_rules! v2 { - ($fmt:expr) => { verbose_log!(2, $fmt); }; - ($fmt:expr, $($arg:tt)*) => { verbose_log!(2, $fmt, $($arg)*); }; -} - -/// Prints to `stdout` if verbosity level is >= 3. Follows -/// [`format!`](https://doc.rust-lang.org/std/macro.format.html) style. -#[macro_export] -macro_rules! v3 { - ($fmt:expr) => { verbose_log!(3, $fmt); }; - ($fmt:expr, $($arg:tt)*) => { verbose_log!(3, $fmt, $($arg)*); }; -} - -/// Always prints to `stderr`. Follows -/// [`format!`](https://doc.rust-lang.org/std/macro.format.html) style. -#[macro_export] -macro_rules! ve0 { - ($fmt:expr) => { eprintln!($fmt); }; - ($fmt:expr, $($arg:tt)*) => { eprintln!($fmt, $($arg)*); }; -} - -/// Prints to `stderr` if verbosity level is >= 1. Follows -/// [`format!`](https://doc.rust-lang.org/std/macro.format.html) style. -#[macro_export] -macro_rules! ve1 { - ($fmt:expr) => { verbose_elog!(1, $fmt); }; - ($fmt:expr, $($arg:tt)*) => { verbose_elog!(1, $fmt, $($arg)*); }; -} - -/// Prints to `stderr` if verbosity level is >= 2. Follows -/// [`format!`](https://doc.rust-lang.org/std/macro.format.html) style. -#[macro_export] -macro_rules! ve2 { - ($fmt:expr) => { verbose_elog!(2, $fmt); }; - ($fmt:expr, $($arg:tt)*) => { verbose_elog!(2, $fmt, $($arg)*); }; -} - -/// Prints to `stderr` if verbosity level is >= 3. Follows -/// [`format!`](https://doc.rust-lang.org/std/macro.format.html) style. -#[macro_export] -macro_rules! ve3 { - ($fmt:expr) => { verbose_elog!(3, $fmt); }; - ($fmt:expr, $($arg:tt)*) => { verbose_elog!(3, $fmt, $($arg)*); }; -} - -#[cfg(test)] -mod tests { - use super::*; - // use gag::BufferRedirect; - // use std::io::Read; - - #[test] - fn test_set_get() { - set_verbosity_level(0); - assert_eq!(0, get_verbosity_level()); - - set_verbosity_level(1); - assert_eq!(1, get_verbosity_level()); - - set_verbosity_level(2); - assert_eq!(2, get_verbosity_level()); - - set_verbosity_level(3); - assert_eq!(3, get_verbosity_level()); - } - - // #[test] - // fn test_v0() { - // set_verbosity_level(0); - - // let mut buf = BufferRedirect::stdout().unwrap(); - - // v0!("{} {}", "level", "0"); - // v1!("{} {}", "level", "1"); - // v2!("{} {}", "level", "2"); - // v3!("{} {}", "level", "3"); - - // let mut output = String::new(); - // buf.read_to_string(&mut output).unwrap(); - - // assert_eq!("level 0", &output); - // } - - // #[test] - // fn test_ve0() { - // set_verbosity_level(0); - - // let mut buf = BufferRedirect::stderr().unwrap(); - - // ve0!("{} {}", "level", "0"); - // ve1!("{} {}", "level", "1"); - // ve2!("{} {}", "level", "2"); - // ve3!("{} {}", "level", "3"); - - // let mut output = String::new(); - // buf.read_to_string(&mut output).unwrap(); - - // assert_eq!("level 0", &output); - // } -} diff --git a/src/macros.rs b/src/macros.rs new file mode 100644 index 0000000..88cc745 --- /dev/null +++ b/src/macros.rs @@ -0,0 +1,95 @@ +/// Common macro for verbose `stdout` logs. +/// This is meant to be used internally only. +#[macro_export] +macro_rules! verbose_log { + ($v:expr, $fmt:expr) => { + if $v <= $crate::get_verbosity_level() { + println!($fmt); + } + }; + ($v:expr, $fmt:expr, $($arg:tt)*) => { + if $v <= $crate::get_verbosity_level() { + println!($fmt, $($arg)*); + } + }; +} + +/// Common macro for verbose `stderr` logs. +/// This is meant to be used internally only. +#[macro_export] +macro_rules! verbose_elog { + ($v:expr, $fmt:expr) => { + if $v <= $crate::get_verbosity_level() { + eprintln!($fmt); + } + }; + ($v:expr, $fmt:expr, $($arg:tt)*) => { + if $v <= $crate::get_verbosity_level() { + eprintln!($fmt, $($arg)*); + } + }; +} + +/// Always prints to `stdout`. Follows +/// [`format!`](https://doc.rust-lang.org/std/macro.format.html) style. +#[macro_export] +macro_rules! v0 { + ($fmt:expr) => { println!($fmt); }; + ($fmt:expr, $($arg:tt)*) => { println!($fmt, $($arg)*); }; +} + +/// Prints to `stdout` if verbosity level is >= 1. Follows +/// [`format!`](https://doc.rust-lang.org/std/macro.format.html) style. +#[macro_export] +macro_rules! v1 { + ($fmt:expr) => { verbose_log!(1, $fmt); }; + ($fmt:expr, $($arg:tt)*) => { verbose_log!(1, $fmt, $($arg)*); }; +} + +/// Prints to `stdout` if verbosity level is >= 2. Follows +/// [`format!`](https://doc.rust-lang.org/std/macro.format.html) style. +#[macro_export] +macro_rules! v2 { + ($fmt:expr) => { verbose_log!(2, $fmt); }; + ($fmt:expr, $($arg:tt)*) => { verbose_log!(2, $fmt, $($arg)*); }; +} + +/// Prints to `stdout` if verbosity level is >= 3. Follows +/// [`format!`](https://doc.rust-lang.org/std/macro.format.html) style. +#[macro_export] +macro_rules! v3 { + ($fmt:expr) => { verbose_log!(3, $fmt); }; + ($fmt:expr, $($arg:tt)*) => { verbose_log!(3, $fmt, $($arg)*); }; +} + +/// Always prints to `stderr`. Follows +/// [`format!`](https://doc.rust-lang.org/std/macro.format.html) style. +#[macro_export] +macro_rules! ve0 { + ($fmt:expr) => { eprintln!($fmt); }; + ($fmt:expr, $($arg:tt)*) => { eprintln!($fmt, $($arg)*); }; +} + +/// Prints to `stderr` if verbosity level is >= 1. Follows +/// [`format!`](https://doc.rust-lang.org/std/macro.format.html) style. +#[macro_export] +macro_rules! ve1 { + ($fmt:expr) => { verbose_elog!(1, $fmt); }; + ($fmt:expr, $($arg:tt)*) => { verbose_elog!(1, $fmt, $($arg)*); }; +} + +/// Prints to `stderr` if verbosity level is >= 2. Follows +/// [`format!`](https://doc.rust-lang.org/std/macro.format.html) style. +#[macro_export] +macro_rules! ve2 { + ($fmt:expr) => { verbose_elog!(2, $fmt); }; + ($fmt:expr, $($arg:tt)*) => { verbose_elog!(2, $fmt, $($arg)*); }; +} + +/// Prints to `stderr` if verbosity level is >= 3. Follows +/// [`format!`](https://doc.rust-lang.org/std/macro.format.html) style. +#[macro_export] +macro_rules! ve3 { + ($fmt:expr) => { verbose_elog!(3, $fmt); }; + ($fmt:expr, $($arg:tt)*) => { verbose_elog!(3, $fmt, $($arg)*); }; +} diff --git a/src/tests.rs b/src/tests.rs new file mode 100644 index 0000000..5dade12 --- /dev/null +++ b/src/tests.rs @@ -0,0 +1,16 @@ +use super::*; + +#[test] +fn test_set_get() { + set_verbosity_level(0); + assert_eq!(0, get_verbosity_level()); + + set_verbosity_level(1); + assert_eq!(1, get_verbosity_level()); + + set_verbosity_level(2); + assert_eq!(2, get_verbosity_level()); + + set_verbosity_level(3); + assert_eq!(3, get_verbosity_level()); +}