Auto merge of #28907 - SingingTree:rustfmt_libterm, r=nrc

Hey hey,

This is the result of running rustfmt over the libterm module. The first commit reflects the unaltered changes from rustfmt, and the commit message contains some notes on areas where I thought rustfmt had behaved strangely. The second commit attempts to fix the strange areas from the first commit.

Clarification edit: there are still some areas where I think rustfmt has made changes which may merit discussion (one is noted in the comments below). My second commit only undoes the changes that I figured would not warrant discussion (based on my opinion of the style, which is of course subjective).

r? @nrc

Author: bors

src/libterm/lib.rs

@@ -63,8 +63,12 @@
 #![feature(str_char)]
 #![feature(vec_push_all)]
 #![cfg_attr(windows, feature(libc))]
+// Handle rustfmt skips
+#![feature(custom_attribute)]
+#![allow(unused_attributes)]
 
-#[macro_use] extern crate log;
+#[macro_use]
+extern crate log;
 
 pub use terminfo::TerminfoTerminal;
 #[cfg(windows)]
@@ -100,53 +104,37 @@ impl Write for WriterWrapper {
 /// Return a Terminal wrapping stdout, or None if a terminal couldn't be
 /// opened.
 pub fn stdout() -> Option<Box<Terminal<WriterWrapper> + Send>> {
-    TerminfoTerminal::new(WriterWrapper {
-        wrapped: box std::io::stdout(),
-    })
+    TerminfoTerminal::new(WriterWrapper { wrapped: box std::io::stdout() })
 }
 
 #[cfg(windows)]
 /// Return a Terminal wrapping stdout, or None if a terminal couldn't be
 /// opened.
 pub fn stdout() -> Option<Box<Terminal<WriterWrapper> + Send>> {
-    let ti = TerminfoTerminal::new(WriterWrapper {
-        wrapped: box std::io::stdout(),
-    });
+    let ti = TerminfoTerminal::new(WriterWrapper { wrapped: box std::io::stdout() });
 
     match ti {
         Some(t) => Some(t),
-        None => {
-            WinConsole::new(WriterWrapper {
-                wrapped: box std::io::stdout(),
-            })
-        }
+        None => WinConsole::new(WriterWrapper { wrapped: box std::io::stdout() }),
     }
 }
 
 #[cfg(not(windows))]
 /// Return a Terminal wrapping stderr, or None if a terminal couldn't be
 /// opened.
 pub fn stderr() -> Option<Box<Terminal<WriterWrapper> + Send>> {
-    TerminfoTerminal::new(WriterWrapper {
-        wrapped: box std::io::stderr(),
-    })
+    TerminfoTerminal::new(WriterWrapper { wrapped: box std::io::stderr() })
 }
 
 #[cfg(windows)]
 /// Return a Terminal wrapping stderr, or None if a terminal couldn't be
 /// opened.
 pub fn stderr() -> Option<Box<Terminal<WriterWrapper> + Send>> {
-    let ti = TerminfoTerminal::new(WriterWrapper {
-        wrapped: box std::io::stderr(),
-    });
+    let ti = TerminfoTerminal::new(WriterWrapper { wrapped: box std::io::stderr() });
 
     match ti {
         Some(t) => Some(t),
-        None => {
-            WinConsole::new(WriterWrapper {
-                wrapped: box std::io::stderr(),
-            })
-        }
+        None => WinConsole::new(WriterWrapper { wrapped: box std::io::stderr() }),
     }
 }
 
@@ -157,23 +145,23 @@ pub mod color {
     /// Number for a terminal color
     pub type Color = u16;
 
-    pub const BLACK:   Color = 0;
-    pub const RED:     Color = 1;
-    pub const GREEN:   Color = 2;
-    pub const YELLOW:  Color = 3;
-    pub const BLUE:    Color = 4;
+    pub const BLACK: Color = 0;
+    pub const RED: Color = 1;
+    pub const GREEN: Color = 2;
+    pub const YELLOW: Color = 3;
+    pub const BLUE: Color = 4;
     pub const MAGENTA: Color = 5;
-    pub const CYAN:    Color = 6;
-    pub const WHITE:   Color = 7;
-
-    pub const BRIGHT_BLACK:   Color = 8;
-    pub const BRIGHT_RED:     Color = 9;
-    pub const BRIGHT_GREEN:   Color = 10;
-    pub const BRIGHT_YELLOW:  Color = 11;
-    pub const BRIGHT_BLUE:    Color = 12;
+    pub const CYAN: Color = 6;
+    pub const WHITE: Color = 7;
+
+    pub const BRIGHT_BLACK: Color = 8;
+    pub const BRIGHT_RED: Color = 9;
+    pub const BRIGHT_GREEN: Color = 10;
+    pub const BRIGHT_YELLOW: Color = 11;
+    pub const BRIGHT_BLUE: Color = 12;
     pub const BRIGHT_MAGENTA: Color = 13;
-    pub const BRIGHT_CYAN:    Color = 14;
-    pub const BRIGHT_WHITE:   Color = 15;
+    pub const BRIGHT_CYAN: Color = 14;
+    pub const BRIGHT_WHITE: Color = 15;
 }
 
 /// Terminal attributes
@@ -206,7 +194,7 @@ pub mod attr {
         /// Convenience attribute to set the foreground color
         ForegroundColor(super::color::Color),
         /// Convenience attribute to set the background color
-        BackgroundColor(super::color::Color)
+        BackgroundColor(super::color::Color),
     }
 }
 

src/libterm/terminfo/mod.rs

@@ -28,13 +28,13 @@ use self::parm::{expand, Number, Variables};
 #[derive(Debug)]
 pub struct TermInfo {
     /// Names for the terminal
-    pub names: Vec<String> ,
+    pub names: Vec<String>,
     /// Map of capability name to boolean value
     pub bools: HashMap<String, bool>,
     /// Map of capability name to numeric value
     pub numbers: HashMap<String, u16>,
     /// Map of capability name to raw (unexpanded) string
-    pub strings: HashMap<String, Vec<u8> >
+    pub strings: HashMap<String, Vec<u8>>,
 }
 
 pub mod searcher;
@@ -49,19 +49,19 @@ pub mod parm;
 
 fn cap_for_attr(attr: attr::Attr) -> &'static str {
     match attr {
-        attr::Bold               => "bold",
-        attr::Dim                => "dim",
-        attr::Italic(true)       => "sitm",
-        attr::Italic(false)      => "ritm",
-        attr::Underline(true)    => "smul",
-        attr::Underline(false)   => "rmul",
-        attr::Blink              => "blink",
-        attr::Standout(true)     => "smso",
-        attr::Standout(false)    => "rmso",
-        attr::Reverse            => "rev",
-        attr::Secure             => "invis",
+        attr::Bold => "bold",
+        attr::Dim => "dim",
+        attr::Italic(true) => "sitm",
+        attr::Italic(false) => "ritm",
+        attr::Underline(true) => "smul",
+        attr::Underline(false) => "rmul",
+        attr::Blink => "blink",
+        attr::Standout(true) => "smso",
+        attr::Standout(false) => "rmso",
+        attr::Reverse => "rev",
+        attr::Secure => "invis",
         attr::ForegroundColor(_) => "setaf",
-        attr::BackgroundColor(_) => "setab"
+        attr::BackgroundColor(_) => "setab",
     }
 }
 
@@ -70,7 +70,7 @@ fn cap_for_attr(attr: attr::Attr) -> &'static str {
 pub struct TerminfoTerminal<T> {
     num_colors: u16,
     out: T,
-    ti: Box<TermInfo>
+    ti: Box<TermInfo>,
 }
 
 impl<T: Write+Send+'static> Terminal<T> for TerminfoTerminal<T> {
@@ -80,12 +80,12 @@ impl<T: Write+Send+'static> Terminal<T> for TerminfoTerminal<T> {
             let s = expand(self.ti
                                .strings
                                .get("setaf")
-                               .unwrap()
-                               ,
-                           &[Number(color as isize)], &mut Variables::new());
+                               .unwrap(),
+                           &[Number(color as isize)],
+                           &mut Variables::new());
             if s.is_ok() {
                 try!(self.out.write_all(&s.unwrap()));
-                return Ok(true)
+                return Ok(true);
             }
         }
         Ok(false)
@@ -97,12 +97,12 @@ impl<T: Write+Send+'static> Terminal<T> for TerminfoTerminal<T> {
             let s = expand(self.ti
                                .strings
                                .get("setab")
-                               .unwrap()
-                               ,
-                           &[Number(color as isize)], &mut Variables::new());
+                               .unwrap(),
+                           &[Number(color as isize)],
+                           &mut Variables::new());
             if s.is_ok() {
                 try!(self.out.write_all(&s.unwrap()));
-                return Ok(true)
+                return Ok(true);
             }
         }
         Ok(false)
@@ -116,12 +116,10 @@ impl<T: Write+Send+'static> Terminal<T> for TerminfoTerminal<T> {
                 let cap = cap_for_attr(attr);
                 let parm = self.ti.strings.get(cap);
                 if parm.is_some() {
-                    let s = expand(parm.unwrap(),
-                                   &[],
-                                   &mut Variables::new());
+                    let s = expand(parm.unwrap(), &[], &mut Variables::new());
                     if s.is_ok() {
                         try!(self.out.write_all(&s.unwrap()));
-                        return Ok(true)
+                        return Ok(true);
                     }
                 }
                 Ok(false)
@@ -131,9 +129,7 @@ impl<T: Write+Send+'static> Terminal<T> for TerminfoTerminal<T> {
 
     fn supports_attr(&self, attr: attr::Attr) -> bool {
         match attr {
-            attr::ForegroundColor(_) | attr::BackgroundColor(_) => {
-                self.num_colors > 0
-            }
+            attr::ForegroundColor(_) | attr::BackgroundColor(_) => self.num_colors > 0,
             _ => {
                 let cap = cap_for_attr(attr);
                 self.ti.strings.get(cap).is_some()
@@ -151,28 +147,33 @@ impl<T: Write+Send+'static> Terminal<T> for TerminfoTerminal<T> {
                 cap = self.ti.strings.get("op");
             }
         }
-        let s = cap.map_or(Err("can't find terminfo capability `sgr0`".to_owned()), |op| {
-            expand(op, &[], &mut Variables::new())
-        });
+        let s = cap.map_or(Err("can't find terminfo capability `sgr0`".to_owned()),
+                           |op| expand(op, &[], &mut Variables::new()));
         if s.is_ok() {
-            return self.out.write_all(&s.unwrap())
+            return self.out.write_all(&s.unwrap());
         }
         Ok(())
     }
 
-    fn get_ref<'a>(&'a self) -> &'a T { &self.out }
+    fn get_ref<'a>(&'a self) -> &'a T {
+        &self.out
+    }
 
-    fn get_mut<'a>(&'a mut self) -> &'a mut T { &mut self.out }
+    fn get_mut<'a>(&'a mut self) -> &'a mut T {
+        &mut self.out
+    }
 }
 
 impl<T: Write+Send+'static> UnwrappableTerminal<T> for TerminfoTerminal<T> {
-    fn unwrap(self) -> T { self.out }
+    fn unwrap(self) -> T {
+        self.out
+    }
 }
 
 impl<T: Write+Send+'static> TerminfoTerminal<T> {
     /// Returns `None` whenever the terminal cannot be created for some
     /// reason.
-    pub fn new(out: T) -> Option<Box<Terminal<T>+Send+'static>> {
+    pub fn new(out: T) -> Option<Box<Terminal<T> + Send + 'static>> {
         let term = match env::var("TERM") {
             Ok(t) => t,
             Err(..) => {
@@ -183,20 +184,22 @@ impl<T: Write+Send+'static> TerminfoTerminal<T> {
 
         let mut file = match open(&term[..]) {
             Ok(f) => f,
-            Err(err) => return match env::var("MSYSCON") {
-                Ok(ref val) if &val[..] == "mintty.exe" => {
-                    // msys terminal
-                    Some(box TerminfoTerminal{
-                        out: out,
-                        ti: msys_terminfo(),
-                        num_colors: 8,
-                    })
-                },
-                _ => {
-                    debug!("error finding terminfo entry: {:?}", err);
-                    None
-                },
-            },
+            Err(err) => {
+                return match env::var("MSYSCON") {
+                    Ok(ref val) if &val[..] == "mintty.exe" => {
+                        // msys terminal
+                        Some(box TerminfoTerminal {
+                            out: out,
+                            ti: msys_terminfo(),
+                            num_colors: 8,
+                        })
+                    }
+                    _ => {
+                        debug!("error finding terminfo entry: {:?}", err);
+                        None
+                    }
+                };
+            }
         };
 
         let ti = parse(&mut file, false);
@@ -206,20 +209,25 @@ impl<T: Write+Send+'static> TerminfoTerminal<T> {
         }
 
         let inf = ti.unwrap();
-        let nc = if inf.strings.get("setaf").is_some()
-                 && inf.strings.get("setab").is_some() {
-                     inf.numbers.get("colors").map_or(0, |&n| n)
-                 } else { 0 };
-
-        Some(box TerminfoTerminal {out: out,
-                                   ti: inf,
-                                   num_colors: nc})
+        let nc = if inf.strings.get("setaf").is_some() && inf.strings.get("setab").is_some() {
+            inf.numbers.get("colors").map_or(0, |&n| n)
+        } else {
+            0
+        };
+
+        Some(box TerminfoTerminal {
+            out: out,
+            ti: inf,
+            num_colors: nc,
+        })
     }
 
     fn dim_if_necessary(&self, color: color::Color) -> color::Color {
         if color >= self.num_colors && color >= 8 && color < 16 {
-            color-8
-        } else { color }
+            color - 8
+        } else {
+            color
+        }
     }
 }