Run rustfmt on the code.

2017-03-24 21:53:05 +01:00 · 2017-03-24 21:53:05 +01:00 · 15c65dc5f9
parent 7351aa3f16
commit 15c65dc5f9
19 changed files with 314 additions and 264 deletions
--- a/examples/alternate_screen_raw.rs
+++ b/examples/alternate_screen_raw.rs
@ -27,12 +27,12 @@ fn main() {
            Key::Char('q') => break,
            Key::Char('1') => {
                write!(screen, "{}", ToMainScreen).unwrap();
-            },
+            }
            Key::Char('2') => {
                write!(screen, "{}", ToAlternateScreen).unwrap();
                write_alt_screen_msg(&mut screen);
-            },
-            _ => {},
+            }
+            _ => {}
        }
        screen.flush().unwrap();
    }
--- a/examples/async.rs
+++ b/examples/async.rs
@ -11,7 +11,11 @@ fn main() {
    let mut stdout = stdout.lock().into_raw_mode().unwrap();
    let mut stdin = async_stdin().bytes();

-    write!(stdout, "{}{}", termion::clear::All, termion::cursor::Goto(1, 1)).unwrap();
+    write!(stdout,
+           "{}{}",
+           termion::clear::All,
+           termion::cursor::Goto(1, 1))
+            .unwrap();

    loop {
        write!(stdout, "{}", termion::clear::CurrentLine).unwrap();
--- a/examples/click.rs
+++ b/examples/click.rs
@ -9,7 +9,11 @@ fn main() {
    let stdin = stdin();
    let mut stdout = MouseTerminal::from(stdout().into_raw_mode().unwrap());

-    write!(stdout, "{}{}q to exit. Click, click, click!", termion::clear::All, termion::cursor::Goto(1, 1)).unwrap();
+    write!(stdout,
+           "{}{}q to exit. Click, click, click!",
+           termion::clear::All,
+           termion::cursor::Goto(1, 1))
+            .unwrap();
    stdout.flush().unwrap();

    for c in stdin.events() {
@ -20,7 +24,7 @@ fn main() {
                match me {
                    MouseEvent::Press(_, x, y) => {
                        write!(stdout, "{}x", termion::cursor::Goto(x, y)).unwrap();
-                    },
+                    }
                    _ => (),
                }
            }
--- a/examples/commie.rs
+++ b/examples/commie.rs
@ -28,10 +28,20 @@ const COMMUNISM: &'static str = r#"
 fn main() {
    let mut state = 0;

-    println!("\n{}{}{}{}{}{}", cursor::Hide, clear::All, cursor::Goto(1, 1), color::Fg(color::Black), color::Bg(color::Red), COMMUNISM);
+    println!("\n{}{}{}{}{}{}",
+             cursor::Hide,
+             clear::All,
+             cursor::Goto(1, 1),
+             color::Fg(color::Black),
+             color::Bg(color::Red),
+             COMMUNISM);
    loop {
-        println!("{}{}           ☭ GAY ☭ SPACE ☭ COMMUNISM ☭           ", cursor::Goto(1, 1), color::Bg(color::AnsiValue(state)));
-        println!("{}{}             WILL PREVAIL, COMRADES!             ", cursor::Goto(1, 20), color::Bg(color::AnsiValue(state)));
+        println!("{}{}           ☭ GAY ☭ SPACE ☭ COMMUNISM ☭           ",
+                 cursor::Goto(1, 1),
+                 color::Bg(color::AnsiValue(state)));
+        println!("{}{}             WILL PREVAIL, COMRADES!             ",
+                 cursor::Goto(1, 20),
+                 color::Bg(color::AnsiValue(state)));

        state += 1;
        state %= 8;
--- a/examples/keys.rs
+++ b/examples/keys.rs
@ -9,14 +9,20 @@ fn main() {
    let stdin = stdin();
    let mut stdout = stdout().into_raw_mode().unwrap();

-    write!(stdout, "{}{}q to exit. Type stuff, use alt, and so on.{}",
+    write!(stdout,
+           "{}{}q to exit. Type stuff, use alt, and so on.{}",
           termion::clear::All,
           termion::cursor::Goto(1, 1),
-           termion::cursor::Hide).unwrap();
+           termion::cursor::Hide)
+            .unwrap();
    stdout.flush().unwrap();

    for c in stdin.keys() {
-        write!(stdout, "{}{}", termion::cursor::Goto(1, 1), termion::clear::CurrentLine).unwrap();
+        write!(stdout,
+               "{}{}",
+               termion::cursor::Goto(1, 1),
+               termion::clear::CurrentLine)
+                .unwrap();

        match c.unwrap() {
            Key::Char('q') => break,
@ -29,7 +35,7 @@ fn main() {
            Key::Up => println!("↑"),
            Key::Down => println!("↓"),
            Key::Backspace => println!("×"),
-            _ => {},
+            _ => {}
        }
        stdout.flush().unwrap();
    }
--- a/examples/mouse.rs
+++ b/examples/mouse.rs
@ -33,7 +33,8 @@ fn main() {
                               termion::clear::UntilNewline,
                               x,
                               y,
-                               cursor::Goto(a, b)).unwrap();
+                               cursor::Goto(a, b))
+                                .unwrap();
                    }
                }
            }
--- a/examples/rainbow.rs
+++ b/examples/rainbow.rs
@ -6,13 +6,20 @@ use termion::raw::IntoRawMode;
 use std::io::{Write, stdout, stdin};

 fn rainbow<W: Write>(stdout: &mut W, blue: u8) {
-    write!(stdout, "{}{}", termion::cursor::Goto(1, 1), termion::clear::All).unwrap();
+    write!(stdout,
+           "{}{}",
+           termion::cursor::Goto(1, 1),
+           termion::clear::All)
+            .unwrap();

    for red in 0..32 {
        let red = red * 8;
        for green in 0..64 {
            let green = green * 4;
-            write!(stdout, "{} ", termion::color::Bg(termion::color::Rgb(red, green, blue))).unwrap();
+            write!(stdout,
+                   "{} ",
+                   termion::color::Bg(termion::color::Rgb(red, green, blue)))
+                    .unwrap();
        }
        write!(stdout, "\n\r").unwrap();
    }
@ -24,10 +31,12 @@ fn main() {
    let stdin = stdin();
    let mut stdout = stdout().into_raw_mode().unwrap();

-    writeln!(stdout, "{}{}{}Use the up/down arrow keys to change the blue in the rainbow.",
+    writeln!(stdout,
+             "{}{}{}Use the up/down arrow keys to change the blue in the rainbow.",
             termion::clear::All,
             termion::cursor::Goto(1, 1),
-           termion::cursor::Hide).unwrap();
+             termion::cursor::Hide)
+            .unwrap();

    let mut blue = 172u8;

@ -36,13 +45,13 @@ fn main() {
            Key::Up => {
                blue = blue.saturating_add(4);
                rainbow(&mut stdout, blue);
-            },
+            }
            Key::Down => {
                blue = blue.saturating_sub(4);
                rainbow(&mut stdout, blue);
-            },
+            }
            Key::Char('q') => break,
-            _ => {},
+            _ => {}
        }
        stdout.flush().unwrap();
    }
--- a/examples/rustc_fun.rs
+++ b/examples/rustc_fun.rs
@ -12,13 +12,13 @@ fn main() {
              {line_num_fg}{line_num_bg}84 {reset}     }};\n\
              {line_num_fg}{line_num_bg}85 {reset} }}\n\
              {line_num_fg}{line_num_bg}{info_line}{reset} {red}^{reset} {error_fg}borrow from first closure ends here",
-                  lighgreen=color::Fg(color::LightGreen),
-                  red=color::Fg(color::Red),
-                  bold=style::Bold,
-                  reset=style::Reset,
-                  magenta=color::Fg(color::Magenta),
-                  line_num_bg=color::Bg(color::AnsiValue::grayscale(3)),
-                  line_num_fg=color::Fg(color::AnsiValue::grayscale(18)),
-                  info_line="|  ",
-                  error_fg=color::Fg(color::AnsiValue::grayscale(17)))
+             lighgreen = color::Fg(color::LightGreen),
+             red = color::Fg(color::Red),
+             bold = style::Bold,
+             reset = style::Reset,
+             magenta = color::Fg(color::Magenta),
+             line_num_bg = color::Bg(color::AnsiValue::grayscale(3)),
+             line_num_fg = color::Fg(color::AnsiValue::grayscale(18)),
+             info_line = "|  ",
+             error_fg = color::Fg(color::AnsiValue::grayscale(17)))
 }
--- a/examples/simple.rs
+++ b/examples/simple.rs
@ -11,8 +11,14 @@ fn main() {
    let stdin = stdin();
    let stdin = stdin.lock();

-    write!(stdout, "{}{}{}yo, 'q' will exit.{}{}", termion::clear::All, termion::cursor::Goto(5, 5),
-           termion::style::Bold, termion::style::Reset, termion::cursor::Goto(20, 10)).unwrap();
+    write!(stdout,
+           "{}{}{}yo, 'q' will exit.{}{}",
+           termion::clear::All,
+           termion::cursor::Goto(5, 5),
+           termion::style::Bold,
+           termion::style::Reset,
+           termion::cursor::Goto(20, 10))
+            .unwrap();
    stdout.flush().unwrap();

    let mut bytes = stdin.bytes();
@ -28,7 +34,8 @@ fn main() {
                b'r' => write!(stdout, "{}", color::Fg(color::Rgb(5, 0, 0))),
                // Write it to stdout.
                a => write!(stdout, "{}", a),
-        }.unwrap();
+            }
+            .unwrap();

        stdout.flush().unwrap();
    }
--- a/src/async.rs
+++ b/src/async.rs
@ -17,17 +17,13 @@ use tty;
 pub fn async_stdin() -> AsyncReader {
    let (send, recv) = mpsc::channel();

-    thread::spawn(move || {
-        for i in tty::get_tty().unwrap().bytes() {
+    thread::spawn(move || for i in tty::get_tty().unwrap().bytes() {
                      if send.send(i).is_err() {
                          return;
                      }
-        }
                  });

-    AsyncReader {
-        recv: recv,
-    }
+    AsyncReader { recv: recv }
 }

 /// An asynchronous reader.
@ -59,7 +55,7 @@ impl Read for AsyncReader {
                Ok(Ok(b)) => {
                    buf[total] = b;
                    total += 1;
-                },
+                }
                Ok(Err(e)) => return Err(e),
                Err(_) => break,
            }
--- a/src/color.rs
+++ b/src/color.rs
@ -83,9 +83,15 @@ pub struct AnsiValue(pub u8);
 impl AnsiValue {
    /// 216-color (r, g, b ≤ 5) RGB.
    pub fn rgb(r: u8, g: u8, b: u8) -> AnsiValue {
-        debug_assert!(r <= 5, "Red color fragment (r = {}) is out of bound. Make sure r ≤ 5.", r);
-        debug_assert!(g <= 5, "Green color fragment (g = {}) is out of bound. Make sure g ≤ 5.", g);
-        debug_assert!(b <= 5, "Blue color fragment (b = {}) is out of bound. Make sure b ≤ 5.", b);
+        debug_assert!(r <= 5,
+                      "Red color fragment (r = {}) is out of bound. Make sure r ≤ 5.",
+                      r);
+        debug_assert!(g <= 5,
+                      "Green color fragment (g = {}) is out of bound. Make sure g ≤ 5.",
+                      g);
+        debug_assert!(b <= 5,
+                      "Blue color fragment (b = {}) is out of bound. Make sure b ≤ 5.",
+                      b);

        AnsiValue(16 + 36 * r + 6 * g + b)
    }
@ -95,8 +101,10 @@ impl AnsiValue {
    /// There are 24 shades of gray.
    pub fn grayscale(shade: u8) -> AnsiValue {
        // Unfortunately, there are a little less than fifty shades.
-        debug_assert!(shade < 24, "Grayscale out of bound (shade = {}). There are only 24 shades of \
-                      gray.", shade);
+        debug_assert!(shade < 24,
+                      "Grayscale out of bound (shade = {}). There are only 24 shades of \
+                      gray.",
+                      shade);

        AnsiValue(0xE8 + shade)
    }
@ -211,10 +219,7 @@ impl<W: Write> DetectColors for W {
 }

 /// Detect a color using OSC 4.
-fn detect_color(stdout: &mut Write,
-                stdin: &mut Read,
-                color: u16)
-                -> io::Result<bool> {
+fn detect_color(stdout: &mut Write, stdin: &mut Read, color: u16) -> io::Result<bool> {
    // Is the color available?
    // Use `ESC ] 4 ; color ; ? BEL`.
    write!(stdout, "\x1B]4;{};?\x07", color)?;
--- a/src/cursor.rs
+++ b/src/cursor.rs
@ -30,7 +30,9 @@ derive_csi_sequence!("Show the cursor.", Show, "?25h");
 pub struct Goto(pub u16, pub u16);

 impl Default for Goto {
-    fn default() -> Goto { Goto(1, 1) }
+    fn default() -> Goto {
+        Goto(1, 1)
+    }
 }

 impl fmt::Display for Goto {
@ -118,11 +120,17 @@ impl<W: Write> DetectCursorPos for W {
        read_chars.pop(); // remove trailing R.
        let read_str = String::from_utf8(read_chars).unwrap();
        let beg = read_str.rfind('[').unwrap();
-        let coords: String = read_str.chars().skip(beg+1).collect();
+        let coords: String = read_str.chars().skip(beg + 1).collect();
        let mut nums = coords.split(';');

-        let cy = nums.next().unwrap().parse::<u16>().unwrap();
-        let cx = nums.next().unwrap().parse::<u16>().unwrap();
+        let cy = nums.next()
+            .unwrap()
+            .parse::<u16>()
+            .unwrap();
+        let cx = nums.next()
+            .unwrap()
+            .parse::<u16>()
+            .unwrap();

        Ok((cx, cy))
    }
--- a/src/event.rs
+++ b/src/event.rs
@ -195,9 +195,18 @@ fn parse_csi<I>(iter: &mut I) -> Option<Event>
        let str_buf = String::from_utf8(buf).unwrap();
        let nums = &mut str_buf.split(';');

-            let cb = nums.next().unwrap().parse::<u16>().unwrap();
-            let cx = nums.next().unwrap().parse::<u16>().unwrap();
-            let cy = nums.next().unwrap().parse::<u16>().unwrap();
+        let cb = nums.next()
+            .unwrap()
+            .parse::<u16>()
+            .unwrap();
+        let cx = nums.next()
+            .unwrap()
+            .parse::<u16>()
+            .unwrap();
+        let cy = nums.next()
+            .unwrap()
+            .parse::<u16>()
+            .unwrap();

        let event = match cb {
            0...2 | 64...65 => {
@ -240,10 +249,7 @@ fn parse_csi<I>(iter: &mut I) -> Option<Event>
            b'M' => {
                let str_buf = String::from_utf8(buf).unwrap();

-                    let nums: Vec<u16> = str_buf
-                        .split(';')
-                        .map(|n| n.parse().unwrap())
-                        .collect();
+                let nums: Vec<u16> = str_buf.split(';').map(|n| n.parse().unwrap()).collect();

                let cb = nums[0];
                let cx = nums[1];
@ -267,10 +273,7 @@ fn parse_csi<I>(iter: &mut I) -> Option<Event>

                // This CSI sequence can be a list of semicolon-separated
                // numbers.
-                    let nums: Vec<u8> = str_buf
-                        .split(';')
-                        .map(|n| n.parse().unwrap())
-                        .collect();
+                let nums: Vec<u8> = str_buf.split(';').map(|n| n.parse().unwrap()).collect();

                if nums.is_empty() {
                    return None;
--- a/src/input.rs
+++ b/src/input.rs
@ -216,7 +216,8 @@ mod test {

    #[test]
    fn test_events() {
-        let mut i = b"\x1B[\x00bc\x7F\x1B[D\
+        let mut i =
+            b"\x1B[\x00bc\x7F\x1B[D\
                    \x1B[M\x00\x22\x24\x1B[<0;2;4;M\x1B[32;2;4M\x1B[<0;2;4;m\x1B[35;2;4Mb"
                    .events();

--- a/src/raw.rs
+++ b/src/raw.rs
@ -129,9 +129,7 @@ impl<W: Write> IntoRawMode for W {

    #[cfg(target_os = "redox")]
    fn into_raw_mode(mut self) -> io::Result<RawTerminal<W>> {
-        write!(self, csi!("?82h")).map(|_| {
-            RawTerminal { output: self }
-        })
+        write!(self, csi!("?82h")).map(|_| RawTerminal { output: self })
    }
 }

--- a/src/screen.rs
+++ b/src/screen.rs
@ -56,9 +56,7 @@ impl<W: Write> AlternateScreen<W> {
    /// to the alternate screen.
    pub fn from(mut output: W) -> Self {
        write!(output, "{}", ToAlternateScreen).expect("switch to alternate screen");
-        AlternateScreen {
-            output: output,
-        }
+        AlternateScreen { output: output }
    }
 }

--- a/src/style.rs
+++ b/src/style.rs
@ -16,5 +16,7 @@ derive_csi_sequence!("Undo italic text.", NoItalic, "23m");
 derive_csi_sequence!("Undo underlined text.", NoUnderline, "24m");
 derive_csi_sequence!("Undo blinking text (not widely supported).", NoBlink, "25m");
 derive_csi_sequence!("Undo inverted colors (negative mode).", NoInvert, "27m");
-derive_csi_sequence!("Undo crossed out text (not widely supported).", NoCrossedOut, "29m");
+derive_csi_sequence!("Undo crossed out text (not widely supported).",
+                     NoCrossedOut,
+                     "29m");
 derive_csi_sequence!("Framed text (not widely supported).", Framed, "51m");
--- a/src/termios.rs
+++ b/src/termios.rs
@ -9,7 +9,7 @@ pub const TIOCGWINSZ: usize = 0x00005413;
 #[cfg(not(target_os = "linux"))]
 pub const TIOCGWINSZ: usize = 0x40087468;

-extern {
+extern "C" {
    pub fn tcgetattr(fd: c_int, termptr: *mut Termios) -> c_int;
    pub fn tcsetattr(fd: c_int, opt: c_int, termptr: *mut Termios) -> c_int;
    pub fn cfmakeraw(termptr: *mut Termios);
@ -24,9 +24,7 @@ pub fn get_terminal_attr() -> (Termios, c_int) {
 }

 pub fn set_terminal_attr(ios: *mut Termios) -> c_int {
-    unsafe {
-        tcsetattr(0, 0, ios)
-    }
+    unsafe { tcsetattr(0, 0, ios) }
 }

 #[cfg(test)]
--- a/src/tty.rs
+++ b/src/tty.rs
@ -6,7 +6,7 @@ use std::os::unix::io::AsRawFd;
 pub fn is_tty<T: AsRawFd>(stream: &T) -> bool {
    use libc;

-    unsafe { libc::isatty(stream.as_raw_fd()) == 1}
+    unsafe { libc::isatty(stream.as_raw_fd()) == 1 }
 }

 /// This will panic.