From a1a102c1c9077192e20fa58e030c0ffe8dbfa550 Mon Sep 17 00:00:00 2001 From: Jose Narvaez Date: Wed, 7 Oct 2015 23:25:48 +0100 Subject: [PATCH] Rustfmt-ing liblog. --- src/liblog/directive.rs | 76 +++++++++++++++++++++-------------------- src/liblog/lib.rs | 68 ++++++++++++++++-------------------- 2 files changed, 69 insertions(+), 75 deletions(-) diff --git a/src/liblog/directive.rs b/src/liblog/directive.rs index 362303869d78d..9a8185bf2e9a0 100644 --- a/src/liblog/directive.rs +++ b/src/liblog/directive.rs @@ -17,15 +17,17 @@ pub struct LogDirective { pub level: u32, } -pub const LOG_LEVEL_NAMES: [&'static str; 4] = ["ERROR", "WARN", "INFO", - "DEBUG"]; +pub const LOG_LEVEL_NAMES: [&'static str; 4] = ["ERROR", "WARN", "INFO", "DEBUG"]; /// Parse an individual log level that is either a number or a symbolic log level fn parse_log_level(level: &str) -> Option { - level.parse::().ok().or_else(|| { - let pos = LOG_LEVEL_NAMES.iter().position(|&name| name.eq_ignore_ascii_case(level)); - pos.map(|p| p as u32 + 1) - }).map(|p| cmp::min(p, ::MAX_LOG_LEVEL)) + level.parse::() + .ok() + .or_else(|| { + let pos = LOG_LEVEL_NAMES.iter().position(|&name| name.eq_ignore_ascii_case(level)); + pos.map(|p| p as u32 + 1) + }) + .map(|p| cmp::min(p, ::MAX_LOG_LEVEL)) } /// Parse a logging specification string (e.g: "crate1,crate2::mod3,crate3::x=1/foo") @@ -40,44 +42,44 @@ pub fn parse_logging_spec(spec: &str) -> (Vec, Option) { let mods = parts.next(); let filter = parts.next(); if parts.next().is_some() { - println!("warning: invalid logging spec '{}', \ - ignoring it (too many '/'s)", spec); + println!("warning: invalid logging spec '{}', ignoring it (too many '/'s)", spec); return (dirs, None); } - mods.map(|m| { for s in m.split(',') { - if s.is_empty() { continue } - let mut parts = s.split('='); - let (log_level, name) = match (parts.next(), parts.next().map(|s| s.trim()), parts.next()) { - (Some(part0), None, None) => { + mods.map(|m| { + for s in m.split(',') { + if s.is_empty() { + continue + } + let mut parts = s.split('='); + let (log_level, name) = match (parts.next(), + parts.next().map(|s| s.trim()), + parts.next()) { + (Some(part0), None, None) => { // if the single argument is a log-level string or number, // treat that as a global fallback - match parse_log_level(part0) { - Some(num) => (num, None), - None => (::MAX_LOG_LEVEL, Some(part0)), + match parse_log_level(part0) { + Some(num) => (num, None), + None => (::MAX_LOG_LEVEL, Some(part0)), + } } - } - (Some(part0), Some(""), None) => (::MAX_LOG_LEVEL, Some(part0)), - (Some(part0), Some(part1), None) => { - match parse_log_level(part1) { - Some(num) => (num, Some(part0)), - _ => { - println!("warning: invalid logging spec '{}', \ - ignoring it", part1); - continue + (Some(part0), Some(""), None) => (::MAX_LOG_LEVEL, Some(part0)), + (Some(part0), Some(part1), None) => { + match parse_log_level(part1) { + Some(num) => (num, Some(part0)), + _ => { + println!("warning: invalid logging spec '{}', ignoring it", part1); + continue + } } } - }, - _ => { - println!("warning: invalid logging spec '{}', \ - ignoring it", s); - continue - } - }; - dirs.push(LogDirective { - name: name.map(str::to_owned), - level: log_level, - }); - }}); + _ => { + println!("warning: invalid logging spec '{}', ignoring it", s); + continue + } + }; + dirs.push(LogDirective { name: name.map(str::to_owned), level: log_level, }); + } + }); (dirs, filter.map(str::to_owned)) } diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index 2c91a88f6ec9e..5fe41a6368cf0 100644 --- a/src/liblog/lib.rs +++ b/src/liblog/lib.rs @@ -235,7 +235,9 @@ pub trait Logger { fn log(&mut self, record: &LogRecord); } -struct DefaultLogger { handle: Stderr } +struct DefaultLogger { + handle: Stderr, +} /// Wraps the log level with fmt implementations. #[derive(Copy, Clone, PartialEq, PartialOrd, Debug)] @@ -246,7 +248,7 @@ impl fmt::Display for LogLevel { let LogLevel(level) = *self; match LOG_LEVEL_NAMES.get(level as usize - 1) { Some(ref name) => fmt::Display::fmt(name, fmt), - None => fmt::Display::fmt(&level, fmt) + None => fmt::Display::fmt(&level, fmt), } } } @@ -301,11 +303,10 @@ pub fn log(level: u32, loc: &'static LogLocation, args: fmt::Arguments) { // Completely remove the local logger from TLS in case anyone attempts to // frob the slot while we're doing the logging. This will destroy any logger // set during logging. - let mut logger: Box = LOCAL_LOGGER.with(|s| { - s.borrow_mut().take() - }).unwrap_or_else(|| { - box DefaultLogger { handle: io::stderr() } - }); + let mut logger: Box = LOCAL_LOGGER.with(|s| s.borrow_mut().take()) + .unwrap_or_else(|| { + box DefaultLogger { handle: io::stderr() } + }); logger.log(&LogRecord { level: LogLevel(level), args: args, @@ -320,22 +321,21 @@ pub fn log(level: u32, loc: &'static LogLocation, args: fmt::Arguments) { /// safely #[doc(hidden)] #[inline(always)] -pub fn log_level() -> u32 { unsafe { LOG_LEVEL } } +pub fn log_level() -> u32 { + unsafe { LOG_LEVEL } +} /// Replaces the thread-local logger with the specified logger, returning the old /// logger. pub fn set_logger(logger: Box) -> Option> { let mut l = Some(logger); - LOCAL_LOGGER.with(|slot| { - mem::replace(&mut *slot.borrow_mut(), l.take()) - }) + LOCAL_LOGGER.with(|slot| mem::replace(&mut *slot.borrow_mut(), l.take())) } /// A LogRecord is created by the logging macros, and passed as the only /// argument to Loggers. #[derive(Debug)] pub struct LogRecord<'a> { - /// The module path of where the LogRecord originated. pub module_path: &'a str, @@ -373,7 +373,9 @@ pub fn mod_enabled(level: u32, module: &str) -> bool { // again to whether they should really be here or not. Hence, despite this // check being expanded manually in the logging macro, this function checks // the log level again. - if level > unsafe { LOG_LEVEL } { return false } + if level > unsafe { LOG_LEVEL } { + return false + } // This assertion should never get tripped unless we're in an at_exit // handler after logging has been torn down and a logging attempt was made. @@ -385,14 +387,11 @@ pub fn mod_enabled(level: u32, module: &str) -> bool { } } -fn enabled(level: u32, - module: &str, - iter: slice::Iter) - -> bool { +fn enabled(level: u32, module: &str, iter: slice::Iter) -> bool { // Search for the longest match, the vector is assumed to be pre-sorted. for directive in iter.rev() { match directive.name { - Some(ref name) if !module.starts_with(&name[..]) => {}, + Some(ref name) if !module.starts_with(&name[..]) => {} Some(..) | None => { return level <= directive.level } @@ -446,14 +445,8 @@ mod tests { #[test] fn match_full_path() { let dirs = [ - LogDirective { - name: Some("crate2".to_string()), - level: 3 - }, - LogDirective { - name: Some("crate1::mod1".to_string()), - level: 2 - } + LogDirective {name: Some("crate2".to_string()), level: 3, }, + LogDirective {name: Some("crate1::mod1".to_string()), level: 2, } ]; assert!(enabled(2, "crate1::mod1", dirs.iter())); assert!(!enabled(3, "crate1::mod1", dirs.iter())); @@ -464,8 +457,8 @@ mod tests { #[test] fn no_match() { let dirs = [ - LogDirective { name: Some("crate2".to_string()), level: 3 }, - LogDirective { name: Some("crate1::mod1".to_string()), level: 2 } + LogDirective { name: Some("crate2".to_string()), level: 3, }, + LogDirective { name: Some("crate1::mod1".to_string()), level: 2, } ]; assert!(!enabled(2, "crate3", dirs.iter())); } @@ -473,8 +466,8 @@ mod tests { #[test] fn match_beginning() { let dirs = [ - LogDirective { name: Some("crate2".to_string()), level: 3 }, - LogDirective { name: Some("crate1::mod1".to_string()), level: 2 } + LogDirective { name: Some("crate2".to_string()), level: 3, }, + LogDirective { name: Some("crate1::mod1".to_string()), level: 2, } ]; assert!(enabled(3, "crate2::mod1", dirs.iter())); } @@ -482,10 +475,9 @@ mod tests { #[test] fn match_beginning_longest_match() { let dirs = [ - LogDirective { name: Some("crate2".to_string()), level: 3 }, - LogDirective { name: Some("crate2::mod".to_string()), level: 4 }, - LogDirective { name: Some("crate1::mod1".to_string()), level: 2 } - ]; + LogDirective { name: Some("crate2".to_string()), level: 3, }, + LogDirective { name: Some("crate2::mod".to_string()), level: 4, }, + LogDirective { name: Some("crate1::mod1".to_string()), level: 2, }]; assert!(enabled(4, "crate2::mod1", dirs.iter())); assert!(!enabled(4, "crate2", dirs.iter())); } @@ -493,8 +485,8 @@ mod tests { #[test] fn match_default() { let dirs = [ - LogDirective { name: None, level: 3 }, - LogDirective { name: Some("crate1::mod1".to_string()), level: 2 } + LogDirective { name: None, level: 3, }, + LogDirective { name: Some("crate1::mod1".to_string()), level: 2, } ]; assert!(enabled(2, "crate1::mod1", dirs.iter())); assert!(enabled(3, "crate2::mod2", dirs.iter())); @@ -503,8 +495,8 @@ mod tests { #[test] fn zero_level() { let dirs = [ - LogDirective { name: None, level: 3 }, - LogDirective { name: Some("crate1::mod1".to_string()), level: 0 } + LogDirective { name: None, level: 3, }, + LogDirective { name: Some("crate1::mod1".to_string()), level: 0, } ]; assert!(!enabled(1, "crate1::mod1", dirs.iter())); assert!(enabled(3, "crate2::mod2", dirs.iter()));