style: rustfmt everything

This is why I was so intent on clearing the PR queue. This will effectively invalidate all existing patches, so I wanted to start from a clean slate. We do make one little tweak: we put the default type definitions in their own file and tell rustfmt to keep its grubby mits off of it. We also sort it lexicographically and hopefully will enforce that from here on.
2025-08-04 14:12:06 -07:00 · 2020-02-17 18:08:47 -05:00
parent c95f29e3ba
commit 0bc4f0447b
67 changed files with 2707 additions and 2675 deletions
--- a/grep-cli/src/decompress.rs
+++ b/grep-cli/src/decompress.rs
@@ -38,10 +38,7 @@ impl Default for DecompressionMatcherBuilder {
 impl DecompressionMatcherBuilder {
    /// Create a new builder for configuring a decompression matcher.
    pub fn new() -> DecompressionMatcherBuilder {
-        DecompressionMatcherBuilder {
-            commands: vec![],
-            defaults: true,
-        }
+        DecompressionMatcherBuilder { commands: vec![], defaults: true }
    }

    /// Build a matcher for determining how to decompress files.
@@ -49,12 +46,11 @@ impl DecompressionMatcherBuilder {
    /// If there was a problem compiling the matcher, then an error is
    /// returned.
    pub fn build(&self) -> Result<DecompressionMatcher, CommandError> {
-        let defaults =
-            if !self.defaults {
-                vec![]
-            } else {
-                default_decompression_commands()
-            };
+        let defaults = if !self.defaults {
+            vec![]
+        } else {
+            default_decompression_commands()
+        };
        let mut glob_builder = GlobSetBuilder::new();
        let mut commands = vec![];
        for decomp_cmd in defaults.iter().chain(&self.commands) {
@@ -93,17 +89,15 @@ impl DecompressionMatcherBuilder {
        program: P,
        args: I,
    ) -> &mut DecompressionMatcherBuilder
-    where P: AsRef<OsStr>,
-          I: IntoIterator<Item=A>,
-          A: AsRef<OsStr>,
+    where
+        P: AsRef<OsStr>,
+        I: IntoIterator<Item = A>,
+        A: AsRef<OsStr>,
    {
-
        let glob = glob.to_string();
        let bin = program.as_ref().to_os_string();
-        let args = args
-            .into_iter()
-            .map(|a| a.as_ref().to_os_string())
-            .collect();
+        let args =
+            args.into_iter().map(|a| a.as_ref().to_os_string()).collect();
        self.commands.push(DecompressionCommand { glob, bin, args });
        self
    }
--- a/grep-cli/src/escape.rs
+++ b/grep-cli/src/escape.rs
@@ -95,51 +95,61 @@ pub fn unescape(s: &str) -> Vec<u8> {
    let mut state = Literal;
    for c in s.chars() {
        match state {
-            Escape => {
-                match c {
-                    '\\' => { bytes.push(b'\\'); state = Literal; }
-                    'n' => { bytes.push(b'\n'); state = Literal; }
-                    'r' => { bytes.push(b'\r'); state = Literal; }
-                    't' => { bytes.push(b'\t'); state = Literal; }
-                    'x' => { state = HexFirst; }
-                    c => {
-                        bytes.extend(format!(r"\{}", c).into_bytes());
-                        state = Literal;
-                    }
+            Escape => match c {
+                '\\' => {
+                    bytes.push(b'\\');
+                    state = Literal;
                }
-            }
-            HexFirst => {
-                match c {
-                    '0'..='9' | 'A'..='F' | 'a'..='f' => {
-                        state = HexSecond(c);
-                    }
-                    c => {
-                        bytes.extend(format!(r"\x{}", c).into_bytes());
-                        state = Literal;
-                    }
+                'n' => {
+                    bytes.push(b'\n');
+                    state = Literal;
                }
-            }
-            HexSecond(first) => {
-                match c {
-                    '0'..='9' | 'A'..='F' | 'a'..='f' => {
-                        let ordinal = format!("{}{}", first, c);
-                        let byte = u8::from_str_radix(&ordinal, 16).unwrap();
-                        bytes.push(byte);
-                        state = Literal;
-                    }
-                    c => {
-                        let original = format!(r"\x{}{}", first, c);
-                        bytes.extend(original.into_bytes());
-                        state = Literal;
-                    }
+                'r' => {
+                    bytes.push(b'\r');
+                    state = Literal;
                }
-            }
-            Literal => {
-                match c {
-                    '\\' => { state = Escape; }
-                    c => { bytes.extend(c.to_string().as_bytes()); }
+                't' => {
+                    bytes.push(b'\t');
+                    state = Literal;
                }
-            }
+                'x' => {
+                    state = HexFirst;
+                }
+                c => {
+                    bytes.extend(format!(r"\{}", c).into_bytes());
+                    state = Literal;
+                }
+            },
+            HexFirst => match c {
+                '0'..='9' | 'A'..='F' | 'a'..='f' => {
+                    state = HexSecond(c);
+                }
+                c => {
+                    bytes.extend(format!(r"\x{}", c).into_bytes());
+                    state = Literal;
+                }
+            },
+            HexSecond(first) => match c {
+                '0'..='9' | 'A'..='F' | 'a'..='f' => {
+                    let ordinal = format!("{}{}", first, c);
+                    let byte = u8::from_str_radix(&ordinal, 16).unwrap();
+                    bytes.push(byte);
+                    state = Literal;
+                }
+                c => {
+                    let original = format!(r"\x{}{}", first, c);
+                    bytes.extend(original.into_bytes());
+                    state = Literal;
+                }
+            },
+            Literal => match c {
+                '\\' => {
+                    state = Escape;
+                }
+                c => {
+                    bytes.extend(c.to_string().as_bytes());
+                }
+            },
        }
    }
    match state {
--- a/grep-cli/src/human.rs
+++ b/grep-cli/src/human.rs
@@ -46,7 +46,9 @@ impl ParseSizeError {
 }

 impl error::Error for ParseSizeError {
-    fn description(&self) -> &str { "invalid size" }
+    fn description(&self) -> &str {
+        "invalid size"
+    }
 }

 impl fmt::Display for ParseSizeError {
@@ -54,26 +56,19 @@ impl fmt::Display for ParseSizeError {
        use self::ParseSizeErrorKind::*;

        match self.kind {
-            InvalidFormat => {
-                write!(
-                    f,
-                    "invalid format for size '{}', which should be a sequence \
+            InvalidFormat => write!(
+                f,
+                "invalid format for size '{}', which should be a sequence \
                     of digits followed by an optional 'K', 'M' or 'G' \
                     suffix",
-                    self.original
-                )
-            }
-            InvalidInt(ref err) => {
-                write!(
-                    f,
-                    "invalid integer found in size '{}': {}",
-                    self.original,
-                    err
-                )
-            }
-            Overflow => {
-                write!(f, "size too big in '{}'", self.original)
-            }
+                self.original
+            ),
+            InvalidInt(ref err) => write!(
+                f,
+                "invalid integer found in size '{}': {}",
+                self.original, err
+            ),
+            Overflow => write!(f, "size too big in '{}'", self.original),
        }
    }
 }
@@ -104,17 +99,16 @@ pub fn parse_human_readable_size(size: &str) -> Result<u64, ParseSizeError> {
        Some(caps) => caps,
        None => return Err(ParseSizeError::format(size)),
    };
-    let value: u64 = caps[1].parse().map_err(|err| {
-        ParseSizeError::int(size, err)
-    })?;
+    let value: u64 =
+        caps[1].parse().map_err(|err| ParseSizeError::int(size, err))?;
    let suffix = match caps.get(2) {
        None => return Ok(value),
        Some(cap) => cap.as_str(),
    };
    let bytes = match suffix {
-        "K" => value.checked_mul(1<<10),
-        "M" => value.checked_mul(1<<20),
-        "G" => value.checked_mul(1<<30),
+        "K" => value.checked_mul(1 << 10),
+        "M" => value.checked_mul(1 << 20),
+        "G" => value.checked_mul(1 << 30),
        // Because if the regex matches this group, it must be [KMG].
        _ => unreachable!(),
    };
@@ -134,19 +128,19 @@ mod tests {
    #[test]
    fn suffix_k() {
        let x = parse_human_readable_size("123K").unwrap();
-        assert_eq!(123 * (1<<10), x);
+        assert_eq!(123 * (1 << 10), x);
    }

    #[test]
    fn suffix_m() {
        let x = parse_human_readable_size("123M").unwrap();
-        assert_eq!(123 * (1<<20), x);
+        assert_eq!(123 * (1 << 20), x);
    }

    #[test]
    fn suffix_g() {
        let x = parse_human_readable_size("123G").unwrap();
-        assert_eq!(123 * (1<<30), x);
+        assert_eq!(123 * (1 << 30), x);
    }

    #[test]
--- a/grep-cli/src/lib.rs
+++ b/grep-cli/src/lib.rs
@@ -179,20 +179,18 @@ mod process;
 mod wtr;

 pub use decompress::{
-    DecompressionMatcher, DecompressionMatcherBuilder,
-    DecompressionReader, DecompressionReaderBuilder,
+    DecompressionMatcher, DecompressionMatcherBuilder, DecompressionReader,
+    DecompressionReaderBuilder,
 };
 pub use escape::{escape, escape_os, unescape, unescape_os};
-pub use human::{ParseSizeError, parse_human_readable_size};
+pub use human::{parse_human_readable_size, ParseSizeError};
 pub use pattern::{
-    InvalidPatternError,
-    pattern_from_os, pattern_from_bytes,
-    patterns_from_path, patterns_from_reader, patterns_from_stdin,
+    pattern_from_bytes, pattern_from_os, patterns_from_path,
+    patterns_from_reader, patterns_from_stdin, InvalidPatternError,
 };
 pub use process::{CommandError, CommandReader, CommandReaderBuilder};
 pub use wtr::{
-    StandardStream,
-    stdout, stdout_buffered_line, stdout_buffered_block,
+    stdout, stdout_buffered_block, stdout_buffered_line, StandardStream,
 };

 /// Returns true if and only if stdin is believed to be readable.
@@ -205,8 +203,8 @@ pub use wtr::{
 pub fn is_readable_stdin() -> bool {
    #[cfg(unix)]
    fn imp() -> bool {
-        use std::os::unix::fs::FileTypeExt;
        use same_file::Handle;
+        use std::os::unix::fs::FileTypeExt;

        let ft = match Handle::stdin().and_then(|h| h.as_file().metadata()) {
            Err(_) => return false,
--- a/grep-cli/src/pattern.rs
+++ b/grep-cli/src/pattern.rs
@@ -29,7 +29,9 @@ impl InvalidPatternError {
 }

 impl error::Error for InvalidPatternError {
-    fn description(&self) -> &str { "invalid pattern" }
+    fn description(&self) -> &str {
+        "invalid pattern"
+    }
 }

 impl fmt::Display for InvalidPatternError {
@@ -39,8 +41,7 @@ impl fmt::Display for InvalidPatternError {
            "found invalid UTF-8 in pattern at byte offset {} \
             (use hex escape sequences to match arbitrary bytes \
             in a pattern, e.g., \\xFF): '{}'",
-            self.valid_up_to,
-            self.original,
+            self.valid_up_to, self.original,
        )
    }
 }
@@ -79,11 +80,9 @@ pub fn pattern_from_os(pattern: &OsStr) -> Result<&str, InvalidPatternError> {
 pub fn pattern_from_bytes(
    pattern: &[u8],
 ) -> Result<&str, InvalidPatternError> {
-    str::from_utf8(pattern).map_err(|err| {
-        InvalidPatternError {
-            original: escape(pattern),
-            valid_up_to: err.valid_up_to(),
-        }
+    str::from_utf8(pattern).map_err(|err| InvalidPatternError {
+        original: escape(pattern),
+        valid_up_to: err.valid_up_to(),
    })
 }

@@ -119,10 +118,7 @@ pub fn patterns_from_stdin() -> io::Result<Vec<String>> {
    let stdin = io::stdin();
    let locked = stdin.lock();
    patterns_from_reader(locked).map_err(|err| {
-        io::Error::new(
-            io::ErrorKind::Other,
-            format!("<stdin>:{}", err),
-        )
+        io::Error::new(io::ErrorKind::Other, format!("<stdin>:{}", err))
    })
 }

@@ -166,12 +162,10 @@ pub fn patterns_from_reader<R: io::Read>(rdr: R) -> io::Result<Vec<String>> {
                patterns.push(pattern.to_string());
                Ok(true)
            }
-            Err(err) => {
-                Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    format!("{}: {}", line_number, err),
-                ))
-            }
+            Err(err) => Err(io::Error::new(
+                io::ErrorKind::Other,
+                format!("{}: {}", line_number, err),
+            )),
        }
    })?;
    Ok(patterns)
@@ -191,8 +185,8 @@ mod tests {
    #[test]
    #[cfg(unix)]
    fn os() {
-        use std::os::unix::ffi::OsStrExt;
        use std::ffi::OsStr;
+        use std::os::unix::ffi::OsStrExt;

        let pat = OsStr::from_bytes(b"abc\xFFxyz");
        let err = pattern_from_os(pat).unwrap_err();
--- a/grep-cli/src/process.rs
+++ b/grep-cli/src/process.rs
@@ -33,7 +33,9 @@ impl CommandError {
 }

 impl error::Error for CommandError {
-    fn description(&self) -> &str { "command error" }
+    fn description(&self) -> &str {
+        "command error"
+    }
 }

 impl fmt::Display for CommandError {
@@ -46,7 +48,12 @@ impl fmt::Display for CommandError {
                    write!(f, "<stderr is empty>")
                } else {
                    let div = iter::repeat('-').take(79).collect::<String>();
-                    write!(f, "\n{div}\n{msg}\n{div}", div=div, msg=msg.trim())
+                    write!(
+                        f,
+                        "\n{div}\n{msg}\n{div}",
+                        div = div,
+                        msg = msg.trim()
+                    )
                }
            }
        }
@@ -101,12 +108,11 @@ impl CommandReaderBuilder {
            .stderr(process::Stdio::piped())
            .spawn()?;
        let stdout = child.stdout.take().unwrap();
-        let stderr =
-            if self.async_stderr {
-                StderrReader::async(child.stderr.take().unwrap())
-            } else {
-                StderrReader::sync(child.stderr.take().unwrap())
-            };
+        let stderr = if self.async_stderr {
+            StderrReader::async(child.stderr.take().unwrap())
+        } else {
+            StderrReader::sync(child.stderr.take().unwrap())
+        };
        Ok(CommandReader {
            child: child,
            stdout: stdout,
@@ -226,9 +232,8 @@ enum StderrReader {
 impl StderrReader {
    /// Create a reader for stderr that reads contents asynchronously.
    fn async(mut stderr: process::ChildStderr) -> StderrReader {
-        let handle = thread::spawn(move || {
-            stderr_to_command_error(&mut stderr)
-        });
+        let handle =
+            thread::spawn(move || stderr_to_command_error(&mut stderr));
        StderrReader::Async(Some(handle))
    }

@@ -247,9 +252,7 @@ impl StderrReader {
                let handle = handle
                    .take()
                    .expect("read_to_end cannot be called more than once");
-                handle
-                    .join()
-                    .expect("stderr reading thread does not panic")
+                handle.join().expect("stderr reading thread does not panic")
            }
            StderrReader::Sync(ref mut stderr) => {
                stderr_to_command_error(stderr)