From 3db501268010caf4bc072453ef832c5cec25570e Mon Sep 17 00:00:00 2001 From: Jose Narvaez Date: Mon, 12 Oct 2015 11:28:54 +0100 Subject: [PATCH 1/3] rustfmt suggested changes. --- src/liblog/directive.rs | 86 +++++++++++++++-------------- src/liblog/lib.rs | 118 +++++++++++++++++++++++----------------- 2 files changed, 115 insertions(+), 89 deletions(-) diff --git a/src/liblog/directive.rs b/src/liblog/directive.rs index 362303869d7..82e93fa9e3a 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,48 @@ 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) => { - // 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)), - } - } - (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); + mods.map(|m| { + for s in m.split(',') { + if s.is_empty() { continue } - }; - dirs.push(LogDirective { - name: name.map(str::to_owned), - level: log_level, - }); - }}); + 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)), + } + } + (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, + }); + } + }); (dirs, filter.map(str::to_owned)) } diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index 2c91a88f6ec..7b846e0bf57 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 } @@ -445,16 +444,14 @@ 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 - } - ]; + let dirs = [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())); assert!(enabled(3, "crate2", dirs.iter())); @@ -463,49 +460,72 @@ 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 } - ]; + let dirs = [LogDirective { + name: Some("crate2".to_string()), + level: 3, + }, + LogDirective { + name: Some("crate1::mod1".to_string()), + level: 2, + }]; assert!(!enabled(2, "crate3", dirs.iter())); } #[test] fn match_beginning() { - let dirs = [ - LogDirective { name: Some("crate2".to_string()), level: 3 }, - LogDirective { name: Some("crate1::mod1".to_string()), level: 2 } - ]; + let dirs = [LogDirective { + name: Some("crate2".to_string()), + level: 3, + }, + LogDirective { + name: Some("crate1::mod1".to_string()), + level: 2, + }]; assert!(enabled(3, "crate2::mod1", dirs.iter())); } #[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 } - ]; + 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, + }]; assert!(enabled(4, "crate2::mod1", dirs.iter())); assert!(!enabled(4, "crate2", dirs.iter())); } #[test] fn match_default() { - let dirs = [ - LogDirective { name: None, level: 3 }, - LogDirective { name: Some("crate1::mod1".to_string()), level: 2 } - ]; + let dirs = [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())); } #[test] fn zero_level() { - let dirs = [ - LogDirective { name: None, level: 3 }, - LogDirective { name: Some("crate1::mod1".to_string()), level: 0 } - ]; + let dirs = [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())); } From 5943af31e7adbb6a713755dbfd4f60158d12b91e Mon Sep 17 00:00:00 2001 From: Jose Narvaez Date: Tue, 13 Oct 2015 10:44:09 +0100 Subject: [PATCH 2/3] Re-running updated rustfmt on liblog. --- src/liblog/lib.rs | 78 +++++++++++++++++++++++------------------------ 1 file changed, 39 insertions(+), 39 deletions(-) diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index 7b846e0bf57..b3268c32f18 100644 --- a/src/liblog/lib.rs +++ b/src/liblog/lib.rs @@ -445,13 +445,13 @@ mod tests { #[test] fn match_full_path() { let dirs = [LogDirective { - name: Some("crate2".to_string()), - level: 3, - }, + name: Some("crate2".to_string()), + level: 3, + }, LogDirective { - name: Some("crate1::mod1".to_string()), - level: 2, - }]; + name: Some("crate1::mod1".to_string()), + level: 2, + }]; assert!(enabled(2, "crate1::mod1", dirs.iter())); assert!(!enabled(3, "crate1::mod1", dirs.iter())); assert!(enabled(3, "crate2", dirs.iter())); @@ -461,43 +461,43 @@ mod tests { #[test] fn no_match() { let dirs = [LogDirective { - name: Some("crate2".to_string()), - level: 3, - }, + name: Some("crate2".to_string()), + level: 3, + }, LogDirective { - name: Some("crate1::mod1".to_string()), - level: 2, - }]; + name: Some("crate1::mod1".to_string()), + level: 2, + }]; assert!(!enabled(2, "crate3", dirs.iter())); } #[test] fn match_beginning() { let dirs = [LogDirective { - name: Some("crate2".to_string()), - level: 3, - }, + name: Some("crate2".to_string()), + level: 3, + }, LogDirective { - name: Some("crate1::mod1".to_string()), - level: 2, - }]; + name: Some("crate1::mod1".to_string()), + level: 2, + }]; assert!(enabled(3, "crate2::mod1", dirs.iter())); } #[test] fn match_beginning_longest_match() { let dirs = [LogDirective { - name: Some("crate2".to_string()), - level: 3, - }, + name: Some("crate2".to_string()), + level: 3, + }, LogDirective { - name: Some("crate2::mod".to_string()), - level: 4, - }, + name: Some("crate2::mod".to_string()), + level: 4, + }, LogDirective { - name: Some("crate1::mod1".to_string()), - level: 2, - }]; + name: Some("crate1::mod1".to_string()), + level: 2, + }]; assert!(enabled(4, "crate2::mod1", dirs.iter())); assert!(!enabled(4, "crate2", dirs.iter())); } @@ -505,13 +505,13 @@ mod tests { #[test] fn match_default() { let dirs = [LogDirective { - name: None, - level: 3, - }, + name: None, + level: 3, + }, LogDirective { - name: Some("crate1::mod1".to_string()), - level: 2, - }]; + name: Some("crate1::mod1".to_string()), + level: 2, + }]; assert!(enabled(2, "crate1::mod1", dirs.iter())); assert!(enabled(3, "crate2::mod2", dirs.iter())); } @@ -519,13 +519,13 @@ mod tests { #[test] fn zero_level() { let dirs = [LogDirective { - name: None, - level: 3, - }, + name: None, + level: 3, + }, LogDirective { - name: Some("crate1::mod1".to_string()), - level: 0, - }]; + name: Some("crate1::mod1".to_string()), + level: 0, + }]; assert!(!enabled(1, "crate1::mod1", dirs.iter())); assert!(enabled(3, "crate2::mod2", dirs.iter())); } From 94946db60d84d1a6a5d45dc7be7e778882637367 Mon Sep 17 00:00:00 2001 From: Jose Narvaez Date: Tue, 13 Oct 2015 10:46:41 +0100 Subject: [PATCH 3/3] Manually alligned comments. --- src/liblog/directive.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/liblog/directive.rs b/src/liblog/directive.rs index 82e93fa9e3a..12a5c131170 100644 --- a/src/liblog/directive.rs +++ b/src/liblog/directive.rs @@ -56,8 +56,8 @@ pub fn parse_logging_spec(spec: &str) -> (Vec, Option) { 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 + // 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)),