diff --git a/src/lib.rs b/src/lib.rs index 8ca360c..c6eaa26 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -269,8 +269,7 @@ const INITIALIZED: usize = 2; static MAX_LOG_LEVEL_FILTER: AtomicUsize = ATOMIC_USIZE_INIT; -static LOG_LEVEL_NAMES: [&'static str; 6] = ["OFF", "ERROR", "WARN", "INFO", - "DEBUG", "TRACE"]; +static LOG_LEVEL_NAMES: [&'static str; 6] = ["OFF", "ERROR", "WARN", "INFO", "DEBUG", "TRACE"]; static SET_LOGGER_ERROR: &'static str = "attempted to set a logger after the logging system \ was already initialized"; @@ -369,8 +368,8 @@ fn eq_ignore_ascii_case(a: &str, b: &str) -> bool { if a.len() == b.len() { a.bytes() - .zip(b.bytes()) - .all(|(a, b)| to_ascii_uppercase(a) == to_ascii_uppercase(b)) + .zip(b.bytes()) + .all(|(a, b)| to_ascii_uppercase(a) == to_ascii_uppercase(b)) } else { false } @@ -379,12 +378,14 @@ fn eq_ignore_ascii_case(a: &str, b: &str) -> bool { impl FromStr for Level { type Err = ParseLevelError; fn from_str(level: &str) -> Result { - ok_or(LOG_LEVEL_NAMES.iter() - .position(|&name| eq_ignore_ascii_case(name, level)) - .into_iter() - .filter(|&idx| idx != 0) - .map(|idx| Level::from_usize(idx).unwrap()) - .next(), ParseLevelError(())) + ok_or(LOG_LEVEL_NAMES + .iter() + .position(|&name| eq_ignore_ascii_case(name, level)) + .into_iter() + .filter(|&idx| idx != 0) + .map(|idx| Level::from_usize(idx).unwrap()) + .next(), + ParseLevelError(())) } } @@ -402,7 +403,7 @@ impl Level { 3 => Some(Level::Info), 4 => Some(Level::Debug), 5 => Some(Level::Trace), - _ => None + _ => None, } } @@ -491,9 +492,11 @@ impl Ord for LevelFilter { impl FromStr for LevelFilter { type Err = ParseLevelError; fn from_str(level: &str) -> Result { - ok_or(LOG_LEVEL_NAMES.iter() - .position(|&name| eq_ignore_ascii_case(name, level)) - .map(|p| LevelFilter::from_usize(p).unwrap()), ParseLevelError(())) + ok_or(LOG_LEVEL_NAMES + .iter() + .position(|&name| eq_ignore_ascii_case(name, level)) + .map(|p| LevelFilter::from_usize(p).unwrap()), + ParseLevelError(())) } } @@ -512,7 +515,7 @@ impl LevelFilter { 3 => Some(LevelFilter::Info), 4 => Some(LevelFilter::Debug), 5 => Some(LevelFilter::Trace), - _ => None + _ => None, } } /// Returns the most verbose logging level filter. @@ -668,7 +671,7 @@ impl<'a> Metadata<'a> { } /// A trait encapsulating the operations required of a logger -pub trait Log: Sync+Send { +pub trait Log: Sync + Send { /// Determines if a log message with the specified metadata would be /// logged. /// @@ -689,7 +692,9 @@ pub trait Log: Sync+Send { struct NopLogger; impl Log for NopLogger { - fn enabled(&self, _: &Metadata) -> bool { false } + fn enabled(&self, _: &Metadata) -> bool { + false + } fn log(&self, _: &Record) {} } @@ -823,7 +828,8 @@ pub fn max_level() -> LevelFilter { /// Requires the `use_std` feature (enabled by default). #[cfg(feature = "use_std")] pub fn set_logger(make_logger: M) -> Result<(), SetLoggerError> - where M: FnOnce(MaxLevelFilter) -> Box { + where M: FnOnce(MaxLevelFilter) -> Box +{ unsafe { set_logger_raw(|max_level| mem::transmute(make_logger(max_level))) } } @@ -850,9 +856,9 @@ pub fn set_logger(make_logger: M) -> Result<(), SetLoggerError> /// duration of the program or until `shutdown_logger_raw` is called. In /// addition, `shutdown_logger` *must not* be called after this function. pub unsafe fn set_logger_raw(make_logger: M) -> Result<(), SetLoggerError> - where M: FnOnce(MaxLevelFilter) -> *const Log { - if STATE.compare_and_swap(UNINITIALIZED, INITIALIZING, - Ordering::SeqCst) != UNINITIALIZED { + where M: FnOnce(MaxLevelFilter) -> *const Log +{ + if STATE.compare_and_swap(UNINITIALIZED, INITIALIZING, Ordering::SeqCst) != UNINITIALIZED { return Err(SetLoggerError(())); } @@ -895,8 +901,7 @@ pub fn shutdown_logger_raw() -> Result<*const Log, ShutdownLoggerError> { MAX_LOG_LEVEL_FILTER.store(0, Ordering::SeqCst); // Set to INITIALIZING to prevent re-initialization after - if STATE.compare_and_swap(INITIALIZED, INITIALIZING, - Ordering::SeqCst) != INITIALIZED { + if STATE.compare_and_swap(INITIALIZED, INITIALIZING, Ordering::SeqCst) != INITIALIZED { return Err(ShutdownLoggerError(())); } @@ -949,7 +954,7 @@ impl fmt::Display for ShutdownLoggerError { #[cfg(feature = "use_std")] impl error::Error for ShutdownLoggerError { fn description(&self) -> &str { - SHUTDOWN_LOGGER_ERROR + SHUTDOWN_LOGGER_ERROR } } @@ -993,9 +998,11 @@ mod panic { let msg = match info.payload().downcast_ref::<&'static str>() { Some(s) => *s, - None => match info.payload().downcast_ref::() { - Some(s) => &s[..], - None => "Box", + None => { + match info.payload().downcast_ref::() { + Some(s) => &s[..], + None => "Box", + } } }; @@ -1044,7 +1051,10 @@ fn logger() -> Option { #[doc(hidden)] pub fn __enabled(level: Level, target: &str) -> bool { if let Some(logger) = logger() { - logger.enabled(&Metadata { level: level, target: target }) + logger.enabled(&Metadata { + level: level, + target: target, + }) } else { false } @@ -1054,8 +1064,7 @@ pub fn __enabled(level: Level, target: &str) -> bool { // This is not considered part of the crate's public API. It is subject to // change at any time. #[doc(hidden)] -pub fn __log(level: Level, target: &str, loc: &Location, - args: fmt::Arguments) { +pub fn __log(level: Level, target: &str, loc: &Location, args: fmt::Arguments) { if let Some(logger) = logger() { let record = Record { metadata: Metadata { @@ -1063,7 +1072,7 @@ pub fn __log(level: Level, target: &str, loc: &Location, target: target, }, location: loc, - args: args + args: args, }; logger.log(&record) } @@ -1078,17 +1087,17 @@ pub fn __static_max_level() -> LevelFilter { if !cfg!(debug_assertions) { // This is a release build. Check `release_max_level_*` first. if cfg!(feature = "release_max_level_off") { - return LevelFilter::Off + return LevelFilter::Off; } else if cfg!(feature = "release_max_level_error") { - return LevelFilter::Error + return LevelFilter::Error; } else if cfg!(feature = "release_max_level_warn") { - return LevelFilter::Warn + return LevelFilter::Warn; } else if cfg!(feature = "release_max_level_info") { - return LevelFilter::Info + return LevelFilter::Info; } else if cfg!(feature = "release_max_level_debug") { - return LevelFilter::Debug + return LevelFilter::Debug; } else if cfg!(feature = "release_max_level_trace") { - return LevelFilter::Trace + return LevelFilter::Trace; } } if cfg!(feature = "max_level_off") { @@ -1108,99 +1117,96 @@ pub fn __static_max_level() -> LevelFilter { #[cfg(test)] mod tests { - extern crate std; - use tests::std::string::ToString; - use super::{Level, LevelFilter, ParseLevelError}; + extern crate std; + use tests::std::string::ToString; + use super::{Level, LevelFilter, ParseLevelError}; - #[test] - fn test_levelfilter_from_str() { - let tests = [ - ("off", Ok(LevelFilter::Off)), - ("error", Ok(LevelFilter::Error)), - ("warn", Ok(LevelFilter::Warn)), - ("info", Ok(LevelFilter::Info)), - ("debug", Ok(LevelFilter::Debug)), - ("trace", Ok(LevelFilter::Trace)), - ("OFF", Ok(LevelFilter::Off)), - ("ERROR", Ok(LevelFilter::Error)), - ("WARN", Ok(LevelFilter::Warn)), - ("INFO", Ok(LevelFilter::Info)), - ("DEBUG", Ok(LevelFilter::Debug)), - ("TRACE", Ok(LevelFilter::Trace)), - ("asdf", Err(ParseLevelError(()))), - ]; - for &(s, ref expected) in &tests { - assert_eq!(expected, &s.parse()); - } - } + #[test] + fn test_levelfilter_from_str() { + let tests = [("off", Ok(LevelFilter::Off)), + ("error", Ok(LevelFilter::Error)), + ("warn", Ok(LevelFilter::Warn)), + ("info", Ok(LevelFilter::Info)), + ("debug", Ok(LevelFilter::Debug)), + ("trace", Ok(LevelFilter::Trace)), + ("OFF", Ok(LevelFilter::Off)), + ("ERROR", Ok(LevelFilter::Error)), + ("WARN", Ok(LevelFilter::Warn)), + ("INFO", Ok(LevelFilter::Info)), + ("DEBUG", Ok(LevelFilter::Debug)), + ("TRACE", Ok(LevelFilter::Trace)), + ("asdf", Err(ParseLevelError(())))]; + for &(s, ref expected) in &tests { + assert_eq!(expected, &s.parse()); + } + } - #[test] - fn test_level_from_str() { - let tests = [ - ("OFF", Err(ParseLevelError(()))), - ("error", Ok(Level::Error)), - ("warn", Ok(Level::Warn)), - ("info", Ok(Level::Info)), - ("debug", Ok(Level::Debug)), - ("trace", Ok(Level::Trace)), - ("ERROR", Ok(Level::Error)), - ("WARN", Ok(Level::Warn)), - ("INFO", Ok(Level::Info)), - ("DEBUG", Ok(Level::Debug)), - ("TRACE", Ok(Level::Trace)), - ("asdf", Err(ParseLevelError(()))), - ]; - for &(s, ref expected) in &tests { - assert_eq!(expected, &s.parse()); - } - } + #[test] + fn test_level_from_str() { + let tests = [("OFF", Err(ParseLevelError(()))), + ("error", Ok(Level::Error)), + ("warn", Ok(Level::Warn)), + ("info", Ok(Level::Info)), + ("debug", Ok(Level::Debug)), + ("trace", Ok(Level::Trace)), + ("ERROR", Ok(Level::Error)), + ("WARN", Ok(Level::Warn)), + ("INFO", Ok(Level::Info)), + ("DEBUG", Ok(Level::Debug)), + ("TRACE", Ok(Level::Trace)), + ("asdf", Err(ParseLevelError(())))]; + for &(s, ref expected) in &tests { + assert_eq!(expected, &s.parse()); + } + } - #[test] - fn test_level_show() { - assert_eq!("INFO", Level::Info.to_string()); - assert_eq!("ERROR", Level::Error.to_string()); - } + #[test] + fn test_level_show() { + assert_eq!("INFO", Level::Info.to_string()); + assert_eq!("ERROR", Level::Error.to_string()); + } - #[test] - fn test_levelfilter_show() { - assert_eq!("OFF", LevelFilter::Off.to_string()); - assert_eq!("ERROR", LevelFilter::Error.to_string()); - } + #[test] + fn test_levelfilter_show() { + assert_eq!("OFF", LevelFilter::Off.to_string()); + assert_eq!("ERROR", LevelFilter::Error.to_string()); + } - #[test] - fn test_cross_cmp() { - assert!(Level::Debug > LevelFilter::Error); - assert!(LevelFilter::Warn < Level::Trace); - assert!(LevelFilter::Off < Level::Error); - } + #[test] + fn test_cross_cmp() { + assert!(Level::Debug > LevelFilter::Error); + assert!(LevelFilter::Warn < Level::Trace); + assert!(LevelFilter::Off < Level::Error); + } - #[test] - fn test_cross_eq() { - assert!(Level::Error == LevelFilter::Error); - assert!(LevelFilter::Off != Level::Error); - assert!(Level::Trace == LevelFilter::Trace); - } + #[test] + fn test_cross_eq() { + assert!(Level::Error == LevelFilter::Error); + assert!(LevelFilter::Off != Level::Error); + assert!(Level::Trace == LevelFilter::Trace); + } - #[test] - fn test_to_level() { - assert_eq!(Some(Level::Error), LevelFilter::Error.to_level()); - assert_eq!(None, LevelFilter::Off.to_level()); - assert_eq!(Some(Level::Debug), LevelFilter::Debug.to_level()); - } + #[test] + fn test_to_level() { + assert_eq!(Some(Level::Error), LevelFilter::Error.to_level()); + assert_eq!(None, LevelFilter::Off.to_level()); + assert_eq!(Some(Level::Debug), LevelFilter::Debug.to_level()); + } - #[test] - fn test_to_level_filter() { - assert_eq!(LevelFilter::Error, Level::Error.to_level_filter()); - assert_eq!(LevelFilter::Trace, Level::Trace.to_level_filter()); - } + #[test] + fn test_to_level_filter() { + assert_eq!(LevelFilter::Error, Level::Error.to_level_filter()); + assert_eq!(LevelFilter::Trace, Level::Trace.to_level_filter()); + } - #[test] - #[cfg(feature = "use_std")] - fn test_error_trait() { - use std::error::Error; - use super::SetLoggerError; - let e = SetLoggerError(()); - assert_eq!(e.description(), "attempted to set a logger after the logging system \ + #[test] + #[cfg(feature = "use_std")] + fn test_error_trait() { + use std::error::Error; + use super::SetLoggerError; + let e = SetLoggerError(()); + assert_eq!(e.description(), + "attempted to set a logger after the logging system \ was already initialized"); - } + } } diff --git a/src/serde.rs b/src/serde.rs index 579237d..bfb9174 100644 --- a/src/serde.rs +++ b/src/serde.rs @@ -2,7 +2,8 @@ extern crate serde; use self::serde::ser::{Serialize, Serializer}; -use self::serde::de::{Deserialize, DeserializeSeed, Deserializer, Visitor, EnumAccess, VariantAccess, Error}; +use self::serde::de::{Deserialize, DeserializeSeed, Deserializer, Visitor, EnumAccess, + VariantAccess, Error}; use {Level, LevelFilter, LOG_LEVEL_NAMES}; @@ -42,9 +43,7 @@ impl<'de> Deserialize<'de> for Level { where E: Error { // Case insensitive. - FromStr::from_str(s).map_err(|_| { - Error::unknown_variant(s, &LOG_LEVEL_NAMES[1..]) - }) + FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES[1..])) } } @@ -113,9 +112,7 @@ impl<'de> Deserialize<'de> for LevelFilter { where E: Error { // Case insensitive. - FromStr::from_str(s).map_err(|_| { - Error::unknown_variant(s, &LOG_LEVEL_NAMES) - }) + FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES)) } } @@ -159,13 +156,27 @@ mod tests { use {Level, LevelFilter}; + fn level_token(variant: &'static str) -> Token { + Token::UnitVariant { + name: "Level", + variant: variant, + } + } + + fn level_filter_token(variant: &'static str) -> Token { + Token::UnitVariant { + name: "LevelFilter", + variant: variant, + } + } + #[test] fn test_level_ser_de() { - let cases = [(Level::Error, [Token::UnitVariant { name: "Level", variant: "ERROR" }]), - (Level::Warn, [Token::UnitVariant { name: "Level", variant: "WARN" }]), - (Level::Info, [Token::UnitVariant { name: "Level", variant: "INFO" }]), - (Level::Debug, [Token::UnitVariant { name: "Level", variant: "DEBUG" }]), - (Level::Trace, [Token::UnitVariant { name: "Level", variant: "TRACE" }])]; + let cases = [(Level::Error, [level_token("ERROR")]), + (Level::Warn, [level_token("WARN")]), + (Level::Info, [level_token("INFO")]), + (Level::Debug, [level_token("DEBUG")]), + (Level::Trace, [level_token("TRACE")])]; for &(s, expected) in &cases { assert_tokens(&s, &expected); @@ -174,11 +185,11 @@ mod tests { #[test] fn test_level_case_insensitive() { - let cases = [(Level::Error, [Token::UnitVariant { name: "Level", variant: "error" }]), - (Level::Warn, [Token::UnitVariant { name: "Level", variant: "warn" }]), - (Level::Info, [Token::UnitVariant { name: "Level", variant: "info" }]), - (Level::Debug, [Token::UnitVariant { name: "Level", variant: "debug" }]), - (Level::Trace, [Token::UnitVariant { name: "Level", variant: "trace" }])]; + let cases = [(Level::Error, [level_token("error")]), + (Level::Warn, [level_token("warn")]), + (Level::Info, [level_token("info")]), + (Level::Debug, [level_token("debug")]), + (Level::Trace, [level_token("trace")])]; for &(s, expected) in &cases { assert_de_tokens(&s, &expected); @@ -187,19 +198,19 @@ mod tests { #[test] fn test_level_de_error() { - assert_de_tokens_error::( - &[Token::UnitVariant { name: "Level", variant: "errorx" }], - "unknown variant `errorx`, expected one of `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`"); + let msg = "unknown variant `errorx`, expected one of \ + `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`"; + assert_de_tokens_error::(&[level_token("errorx")], msg); } #[test] fn test_level_filter_ser_de() { - let cases = [(LevelFilter::Off, [Token::UnitVariant { name: "LevelFilter", variant: "OFF" }]), - (LevelFilter::Error, [Token::UnitVariant { name: "LevelFilter", variant: "ERROR" }]), - (LevelFilter::Warn, [Token::UnitVariant { name: "LevelFilter", variant: "WARN" }]), - (LevelFilter::Info, [Token::UnitVariant { name: "LevelFilter", variant: "INFO" }]), - (LevelFilter::Debug, [Token::UnitVariant { name: "LevelFilter", variant: "DEBUG" }]), - (LevelFilter::Trace, [Token::UnitVariant { name: "LevelFilter", variant: "TRACE" }])]; + let cases = [(LevelFilter::Off, [level_filter_token("OFF")]), + (LevelFilter::Error, [level_filter_token("ERROR")]), + (LevelFilter::Warn, [level_filter_token("WARN")]), + (LevelFilter::Info, [level_filter_token("INFO")]), + (LevelFilter::Debug, [level_filter_token("DEBUG")]), + (LevelFilter::Trace, [level_filter_token("TRACE")])]; for &(s, expected) in &cases { assert_tokens(&s, &expected); @@ -208,12 +219,12 @@ mod tests { #[test] fn test_level_filter_case_insensitive() { - let cases = [(LevelFilter::Off, [Token::UnitVariant { name: "LevelFilter", variant: "off" }]), - (LevelFilter::Error, [Token::UnitVariant { name: "LevelFilter", variant: "error" }]), - (LevelFilter::Warn, [Token::UnitVariant { name: "LevelFilter", variant: "warn" }]), - (LevelFilter::Info, [Token::UnitVariant { name: "LevelFilter", variant: "info" }]), - (LevelFilter::Debug, [Token::UnitVariant { name: "LevelFilter", variant: "debug" }]), - (LevelFilter::Trace, [Token::UnitVariant { name: "LevelFilter", variant: "trace" }])]; + let cases = [(LevelFilter::Off, [level_filter_token("off")]), + (LevelFilter::Error, [level_filter_token("error")]), + (LevelFilter::Warn, [level_filter_token("warn")]), + (LevelFilter::Info, [level_filter_token("info")]), + (LevelFilter::Debug, [level_filter_token("debug")]), + (LevelFilter::Trace, [level_filter_token("trace")])]; for &(s, expected) in &cases { assert_de_tokens(&s, &expected); @@ -222,8 +233,8 @@ mod tests { #[test] fn test_level_filter_de_error() { - assert_de_tokens_error::( - &[Token::UnitVariant { name: "LevelFilter", variant: "errorx" }], - "unknown variant `errorx`, expected one of `OFF`, `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`"); + let msg = "unknown variant `errorx`, expected one of \ + `OFF`, `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`"; + assert_de_tokens_error::(&[level_filter_token("errorx")], msg); } } diff --git a/tests/filters.rs b/tests/filters.rs index 0497c11..fc8cac8 100644 --- a/tests/filters.rs +++ b/tests/filters.rs @@ -1,4 +1,5 @@ -#[macro_use] extern crate log; +#[macro_use] +extern crate log; use std::sync::{Arc, Mutex}; use log::{Level, LevelFilter, Log, Record, Metadata}; @@ -8,10 +9,9 @@ use log::MaxLevelFilter; use log::set_logger; #[cfg(not(feature = "use_std"))] fn set_logger(make_logger: M) -> Result<(), log::SetLoggerError> - where M: FnOnce(MaxLevelFilter) -> Box { - unsafe { - log::set_logger_raw(|x| std::mem::transmute(make_logger(x))) - } + where M: FnOnce(MaxLevelFilter) -> Box +{ + unsafe { log::set_logger_raw(|x| std::mem::transmute(make_logger(x))) } } struct State { @@ -34,13 +34,14 @@ impl Log for Logger { fn main() { let mut a = None; set_logger(|max| { - let me = Arc::new(State { - last_log: Mutex::new(None), - filter: max, - }); - a = Some(me.clone()); - Box::new(Logger(me)) - }).unwrap(); + let me = Arc::new(State { + last_log: Mutex::new(None), + filter: max, + }); + a = Some(me.clone()); + Box::new(Logger(me)) + }) + .unwrap(); let a = a.unwrap(); test(&a, LevelFilter::Off); @@ -65,7 +66,7 @@ fn test(a: &State, filter: LevelFilter) { last(&a, t(Level::Trace, filter)); fn t(lvl: Level, filter: LevelFilter) -> Option { - if lvl <= filter {Some(lvl)} else {None} + if lvl <= filter { Some(lvl) } else { None } } }