refactor: add rustfmt.toml

Author: wfxr

rustfmt.toml

@@ -0,0 +1,6 @@
+edition = "2018"
+struct_field_align_threshold = 40
+max_width = 120
+comment_width = 120
+reorder_imports = true
+fn_single_line = false

src/bin/code-minimap/main.rs

@@ -8,12 +8,9 @@ use cli::{CompletionOpt, Opt, StructOpt, Subcommand};
 use code_minimap::LossyReader;
 
 fn main() {
-    if let Err(e) = try_main()
-    {
-        if let Some(ioerr) = e.root_cause().downcast_ref::<io::Error>()
-        {
-            if ioerr.kind() == io::ErrorKind::BrokenPipe
-            {
+    if let Err(e) = try_main() {
+        if let Some(ioerr) = e.root_cause().downcast_ref::<io::Error>() {
+            if ioerr.kind() == io::ErrorKind::BrokenPipe {
                 std::process::exit(0);
             }
         }
@@ -24,28 +21,18 @@ fn main() {
 
 fn try_main() -> anyhow::Result<()> {
     let opt: Opt = Opt::from_args();
-    match &opt.subcommand
-    {
-        Some(Subcommand::Completion(CompletionOpt {
-            shell,
-        })) =>
-        {
-            Opt::clap().gen_completions_to(
-                env!("CARGO_PKG_NAME"),
-                *shell,
-                &mut std::io::stdout(),
-            );
-        },
-        None =>
-        {
+    match &opt.subcommand {
+        Some(Subcommand::Completion(CompletionOpt { shell })) => {
+            Opt::clap().gen_completions_to(env!("CARGO_PKG_NAME"), *shell, &mut std::io::stdout());
+        }
+        None => {
             let stdin = io::stdin();
-            let reader: Box<dyn BufRead> = match &opt.file
-            {
+            let reader: Box<dyn BufRead> = match &opt.file {
                 Some(path) => Box::new(LossyReader::open(path)?),
                 None => Box::new(stdin.lock()),
             };
             code_minimap::print(reader, opt.hscale, opt.vscale, opt.padding)?;
-        },
+        }
     }
     Ok(())
 }

src/core.rs

@@ -16,9 +16,7 @@ impl LossyReader {
         let file = File::open(path)?;
         let reader = BufReader::new(file);
 
-        Ok(Self {
-            reader,
-        })
+        Ok(Self { reader })
     }
 }
 
@@ -40,8 +38,7 @@ impl BufRead for LossyReader {
     fn read_line(&mut self, buf: &mut String) -> std::io::Result<usize> {
         let mut append_buf = Vec::new();
         let res = self.read_until(0x0a, &mut append_buf);
-        if let Err(err) = res
-        {
+        if let Err(err) = res {
             return Err(err);
         }
         buf.push_str(&String::from_utf8_lossy(&append_buf));
@@ -62,9 +59,7 @@ pub fn write(
         .lines()
         .map(|line| {
             line.map(|line| {
-                let beg = line
-                    .find(|c: char| !c.is_whitespace())
-                    .unwrap_or(usize::max_value());
+                let beg = line.find(|c: char| !c.is_whitespace()).unwrap_or(usize::max_value());
                 let end = line.rfind(|c: char| !c.is_whitespace()).unwrap_or(0);
                 (beg, end)
             })
@@ -77,21 +72,16 @@ pub fn write(
         .into_iter()
         .try_for_each(|chunk| {
             let mut chunk_size = 0;
-            for (i, (_, group)) in chunk.enumerate()
-            {
-                let (beg, end) = group.into_iter().try_fold(
-                    (usize::max_value(), 0),
-                    |(beg, end), (_, line)| {
+            for (i, (_, group)) in chunk.enumerate() {
+                let (beg, end) = group
+                    .into_iter()
+                    .try_fold((usize::max_value(), 0), |(beg, end), (_, line)| {
                         line.map(|(b, e)| (beg.min(b), end.max(e)))
-                    },
-                )?;
+                    })?;
                 frame[i] = beg..(end + 1);
                 chunk_size += 1;
             }
-            frame
-                .iter_mut()
-                .skip(chunk_size)
-                .for_each(|row| *row = 0..0);
+            frame.iter_mut().skip(chunk_size).for_each(|row| *row = 0..0);
             scale_frame(&mut frame, hscale);
             write_frame(&mut writer, &frame, padding)
         })
@@ -109,12 +99,7 @@ pub fn write(
 /// let stdin = io::stdin();
 /// code_minimap::print(stdin.lock(), 1.0, 1.0, None).unwrap();
 /// ```
-pub fn print(
-    reader: impl BufRead,
-    hscale: f64,
-    vscale: f64,
-    padding: Option<usize>,
-) -> io::Result<()> {
+pub fn print(reader: impl BufRead, hscale: f64, vscale: f64, padding: Option<usize>) -> io::Result<()> {
     write(io::stdout(), reader, hscale, vscale, padding)
 }
 
@@ -132,49 +117,32 @@ pub fn print(
 ///     code_minimap::write_to_string(stdin.lock(), 1.0, 1.0, None).unwrap();
 /// print!("{}", s);
 /// ```
-pub fn write_to_string(
-    reader: impl BufRead,
-    hscale: f64,
-    vscale: f64,
-    padding: Option<usize>,
-) -> io::Result<String> {
+pub fn write_to_string(reader: impl BufRead, hscale: f64, vscale: f64, padding: Option<usize>) -> io::Result<String> {
     let mut buf = Vec::new();
     write(&mut buf, reader, hscale, vscale, padding)?;
     Ok(String::from_utf8(buf).unwrap())
 }
 
-fn write_frame(
-    mut writer: impl Write,
-    frame: &[Range<usize>],
-    padding: Option<usize>,
-) -> std::io::Result<()> {
+fn write_frame(mut writer: impl Write, frame: &[Range<usize>], padding: Option<usize>) -> std::io::Result<()> {
     let idx = |pos| {
-        frame.iter().enumerate().fold(0, |acc, (i, x)| {
-            if x.contains(&pos)
-            {
-                acc + (1 << i)
-            }
-            else
-            {
-                acc
-            }
-        })
+        frame
+            .iter()
+            .enumerate()
+            .fold(0, |acc, (i, x)| if x.contains(&pos) { acc + (1 << i) } else { acc })
     };
     let end = frame.iter().max_by_key(|range| range.end).unwrap().end;
     let line: String = (0..end)
         .step_by(2)
         .map(|i| BRAILLE_MATRIX[(idx(i)) + (idx(i + 1) << 4)])
         .collect();
-    match padding
-    {
+    match padding {
         Some(padding) => writeln!(writer, "{0:<1$}", line, padding),
         None => writeln!(writer, "{}", line),
     }
 }
 
 fn scale_frame(frame: &mut [Range<usize>], factor: f64) {
-    for x in frame
-    {
+    for x in frame {
         *x = scale(x.start, factor)..scale(x.end, factor);
     }
 }