modernize rust code

* rustfmt
* try -> questionmark

Author: Stebalien

src/lib.rs

@@ -58,8 +58,7 @@
 
 #![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
-       html_root_url = "https://stebalien.github.io/doc/term/term/",
-       test(attr(deny(warnings))))]
+       html_root_url = "https://stebalien.github.io/doc/term/term/", test(attr(deny(warnings))))]
 #![deny(missing_docs)]
 #![cfg_attr(test, deny(warnings))]
 
@@ -71,7 +70,7 @@ pub use terminfo::TerminfoTerminal;
 #[cfg(windows)]
 pub use win::WinConsole;
 
-use std::io::{self, Stdout, Stderr};
+use std::io::{self, Stderr, Stdout};
 
 pub mod terminfo;
 
@@ -96,7 +95,11 @@ pub fn stdout() -> Option<Box<StdoutTerminal>> {
 pub fn stdout() -> Option<Box<StdoutTerminal>> {
     TerminfoTerminal::new(io::stdout())
         .map(|t| Box::new(t) as Box<StdoutTerminal>)
-        .or_else(|| WinConsole::new(io::stdout()).ok().map(|t| Box::new(t) as Box<StdoutTerminal>))
+        .or_else(|| {
+            WinConsole::new(io::stdout())
+                .ok()
+                .map(|t| Box::new(t) as Box<StdoutTerminal>)
+        })
 }
 
 #[cfg(not(windows))]
@@ -112,10 +115,13 @@ pub fn stderr() -> Option<Box<StderrTerminal>> {
 pub fn stderr() -> Option<Box<StderrTerminal>> {
     TerminfoTerminal::new(io::stderr())
         .map(|t| Box::new(t) as Box<StderrTerminal>)
-        .or_else(|| WinConsole::new(io::stderr()).ok().map(|t| Box::new(t) as Box<StderrTerminal>))
+        .or_else(|| {
+            WinConsole::new(io::stderr())
+                .ok()
+                .map(|t| Box::new(t) as Box<StderrTerminal>)
+        })
 }
 
-
 /// Terminal color definitions
 #[allow(missing_docs)]
 pub mod color {
@@ -204,54 +210,38 @@ impl std::cmp::PartialEq for Error {
         use Error::*;
         match *self {
             Io(_) => false,
-            TerminfoParsing(ref inner1) => {
-                match *other {
-                    TerminfoParsing(ref inner2) => inner1 == inner2,
-                    _ => false,
-                }
-            }
-            ParameterizedExpansion(ref inner1) => {
-                match *other {
-                    ParameterizedExpansion(ref inner2) => inner1 == inner2,
-                    _ => false,
-                }
-            }
-            NotSupported => {
-                match *other {
-                    NotSupported => true,
-                    _ => false,
-                }
-            }
-            TermUnset => {
-                match *other {
-                    TermUnset => true,
-                    _ => false,
-                }
-            }
-            TerminfoEntryNotFound => {
-                match *other {
-                    TerminfoEntryNotFound => true,
-                    _ => false,
-                }
-            }
-            CursorDestinationInvalid => {
-                match *other {
-                    CursorDestinationInvalid => true,
-                    _ => false,
-                }
-            }
-            ColorOutOfRange => {
-                match *other {
-                    ColorOutOfRange => true,
-                    _ => false,
-                }
-            }
-            __Nonexhaustive => {
-                match *other {
-                    __Nonexhaustive => true,
-                    _ => false,
-                }
-            }
+            TerminfoParsing(ref inner1) => match *other {
+                TerminfoParsing(ref inner2) => inner1 == inner2,
+                _ => false,
+            },
+            ParameterizedExpansion(ref inner1) => match *other {
+                ParameterizedExpansion(ref inner2) => inner1 == inner2,
+                _ => false,
+            },
+            NotSupported => match *other {
+                NotSupported => true,
+                _ => false,
+            },
+            TermUnset => match *other {
+                TermUnset => true,
+                _ => false,
+            },
+            TerminfoEntryNotFound => match *other {
+                TerminfoEntryNotFound => true,
+                _ => false,
+            },
+            CursorDestinationInvalid => match *other {
+                CursorDestinationInvalid => true,
+                _ => false,
+            },
+            ColorOutOfRange => match *other {
+                ColorOutOfRange => true,
+                _ => false,
+            },
+            __Nonexhaustive => match *other {
+                __Nonexhaustive => true,
+                _ => false,
+            },
         }
     }
 }
@@ -399,5 +389,7 @@ pub trait Terminal: Write {
     fn get_mut(&mut self) -> &mut Self::Output;
 
     /// Returns the contained stream, destroying the `Terminal`
-    fn into_inner(self) -> Self::Output where Self: Sized;
+    fn into_inner(self) -> Self::Output
+    where
+        Self: Sized;
 }

src/terminfo/mod.rs

@@ -24,26 +24,15 @@ use Terminal;
 use Result;
 use self::searcher::get_dbpath_for_term;
 use self::parser::compiled::parse;
-use self::parm::{expand, Variables, Param};
+use self::parm::{expand, Param, Variables};
 use self::Error::*;
 
-
 /// Returns true if the named terminal supports basic ANSI escape codes.
 fn is_ansi(name: &str) -> bool {
     // SORTED! We binary search this.
     static ANSI_TERM_PREFIX: &'static [&'static str] = &[
-        "Eterm",
-        "ansi",
-        "eterm",
-        "iterm",
-        "konsole",
-        "linux",
-        "mrxvt",
-        "msyscon",
-        "rxvt",
-        "screen",
-        "tmux",
-        "xterm",
+        "Eterm", "ansi", "eterm", "iterm", "konsole", "linux", "mrxvt", "msyscon", "rxvt",
+        "screen", "tmux", "xterm",
     ];
     match ANSI_TERM_PREFIX.binary_search(&name) {
         Ok(_) => true,
@@ -52,7 +41,6 @@ fn is_ansi(name: &str) -> bool {
     }
 }
 
-
 /// A parsed terminfo database entry.
 #[derive(Debug, Clone)]
 pub struct TermInfo {
@@ -70,16 +58,15 @@ impl TermInfo {
     /// Create a `TermInfo` based on current environment.
     pub fn from_env() -> Result<TermInfo> {
         let term_var = env::var("TERM").ok();
-        let term_name = term_var
-            .as_ref()
-            .map(|s| &**s)
-            .or_else(|| env::var("MSYSCON")
-                     .ok()
-                     .and_then(|s| if s == "mintty.exe" {
-                         Some("msyscon")
-                     } else {
-                         None
-                     }));
+        let term_name = term_var.as_ref().map(|s| &**s).or_else(|| {
+            env::var("MSYSCON").ok().and_then(|s| {
+                if s == "mintty.exe" {
+                    Some("msyscon")
+                } else {
+                    None
+                }
+            })
+        });
         if let Some(term_name) = term_name {
             return TermInfo::from_name(term_name);
         } else {
@@ -93,7 +80,7 @@ impl TermInfo {
             match TermInfo::from_path(&path) {
                 Ok(term) => return Ok(term),
                 // Skip IO Errors (e.g., permission denied).
-                Err(::Error::Io(_)) => {},
+                Err(::Error::Io(_)) => {}
                 // Don't ignore malformed terminfo databases.
                 Err(e) => return Err(e),
             }
@@ -131,23 +118,21 @@ impl TermInfo {
     // might do this for
     // us. Alas. )
     fn _from_path(path: &Path) -> Result<TermInfo> {
-        let file = try!(File::open(path).map_err(::Error::Io));
+        let file = File::open(path).map_err(::Error::Io)?;
         let mut reader = BufReader::new(file);
         parse(&mut reader, false)
     }
 
     /// Retrieve a capability `cmd` and expand it with `params`, writing result to `out`.
     pub fn apply_cap(&self, cmd: &str, params: &[Param], out: &mut io::Write) -> Result<()> {
         match self.strings.get(cmd) {
-            Some(cmd) => {
-                match expand(cmd, params, &mut Variables::new()) {
-                    Ok(s) => {
-                        try!(out.write_all(&s));
-                        Ok(())
-                    }
-                    Err(e) => Err(e.into()),
+            Some(cmd) => match expand(cmd, params, &mut Variables::new()) {
+                Ok(s) => {
+                    out.write_all(&s)?;
+                    Ok(())
                 }
-            }
+                Err(e) => Err(e.into()),
+            },
             None => Err(::Error::NotSupported),
         }
     }
@@ -156,24 +141,23 @@ impl TermInfo {
     pub fn reset(&self, out: &mut io::Write) -> Result<()> {
         // are there any terminals that have color/attrs and not sgr0?
         // Try falling back to sgr, then op
-        let cmd = match [("sgr0", &[] as &[Param]), ("sgr", &[Param::Number(0)]), ("op", &[])]
-                            .iter()
-                            .filter_map(|&(cap, params)| {
-                                self.strings.get(cap).map(|c| (c, params))
-                            })
-                            .next() {
-            Some((op, params)) => {
-                match expand(op, params, &mut Variables::new()) {
-                    Ok(cmd) => cmd,
-                    Err(e) => return Err(e.into()),
-                }
-            }
+        let cmd = match [
+            ("sgr0", &[] as &[Param]),
+            ("sgr", &[Param::Number(0)]),
+            ("op", &[]),
+        ].iter()
+            .filter_map(|&(cap, params)| self.strings.get(cap).map(|c| (c, params)))
+            .next()
+        {
+            Some((op, params)) => match expand(op, params, &mut Variables::new()) {
+                Ok(cmd) => cmd,
+                Err(e) => return Err(e.into()),
+            },
             None => return Err(::Error::NotSupported),
         };
-        try!(out.write_all(&cmd));
+        out.write_all(&cmd)?;
         Ok(())
     }
-
 }
 
 #[derive(Debug, Eq, PartialEq)]
@@ -255,7 +239,6 @@ pub mod parser {
 }
 pub mod parm;
 
-
 fn cap_for_attr(attr: Attr) -> &'static str {
     match attr {
         Attr::Bold => "bold",
@@ -288,15 +271,17 @@ impl<T: Write> Terminal for TerminfoTerminal<T> {
     fn fg(&mut self, color: color::Color) -> Result<()> {
         let color = self.dim_if_necessary(color);
         if self.num_colors > color {
-            return self.ti.apply_cap("setaf", &[Param::Number(color as i32)], &mut self.out);
+            return self.ti
+                .apply_cap("setaf", &[Param::Number(color as i32)], &mut self.out);
         }
         Err(::Error::ColorOutOfRange)
     }
 
     fn bg(&mut self, color: color::Color) -> Result<()> {
         let color = self.dim_if_necessary(color);
         if self.num_colors > color {
-            return self.ti.apply_cap("setab", &[Param::Number(color as i32)], &mut self.out);
+            return self.ti
+                .apply_cap("setab", &[Param::Number(color as i32)], &mut self.out);
         }
         Err(::Error::ColorOutOfRange)
     }
@@ -324,7 +309,9 @@ impl<T: Write> Terminal for TerminfoTerminal<T> {
     }
 
     fn supports_reset(&self) -> bool {
-        ["sgr0", "sgr", "op"].iter().any(|&cap| self.ti.strings.get(cap).is_some())
+        ["sgr0", "sgr", "op"]
+            .iter()
+            .any(|&cap| self.ti.strings.get(cap).is_some())
     }
 
     fn supports_color(&self) -> bool {
@@ -352,7 +339,8 @@ impl<T: Write> Terminal for TerminfoTerminal<T> {
     }
 
     fn into_inner(self) -> T
-        where Self: Sized
+    where
+        Self: Sized,
     {
         self.out
     }
@@ -361,8 +349,8 @@ impl<T: Write> Terminal for TerminfoTerminal<T> {
 impl<T: Write> TerminfoTerminal<T> {
     /// Create a new TerminfoTerminal with the given TermInfo and Write.
     pub fn new_with_terminfo(out: T, terminfo: TermInfo) -> TerminfoTerminal<T> {
-        let nc = if terminfo.strings.contains_key("setaf") &&
-                    terminfo.strings.contains_key("setab") {
+        let nc = if terminfo.strings.contains_key("setaf") && terminfo.strings.contains_key("setab")
+        {
             terminfo.numbers.get("colors").map_or(0, |&n| n)
         } else {
             0
@@ -379,7 +367,9 @@ impl<T: Write> TerminfoTerminal<T> {
     ///
     /// Returns `None` when the terminfo cannot be found or parsed.
     pub fn new(out: T) -> Option<TerminfoTerminal<T>> {
-        TermInfo::from_env().map(move |ti| TerminfoTerminal::new_with_terminfo(out, ti)).ok()
+        TermInfo::from_env()
+            .map(move |ti| TerminfoTerminal::new_with_terminfo(out, ti))
+            .ok()
     }
 
     fn dim_if_necessary(&self, color: color::Color) -> color::Color {
@@ -391,7 +381,6 @@ impl<T: Write> TerminfoTerminal<T> {
     }
 }
 
-
 impl<T: Write> Write for TerminfoTerminal<T> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         self.out.write(buf)