clippy

15 files changed, 94 insertions, 102 deletions

diff --git a/examples/fuzz.rs b/examples/fuzz.rs
index 6283102..576af2c 100644
--- a/examples/fuzz.rs
+++ b/examples/fuzz.rs
@@ -90,7 +90,7 @@ fn read_byte() -> Option<u8> {
             }
         }
         Err(e) => {
-            eprintln!("{}", e);
+            eprintln!("{e}");
             return None;
         }
     }
diff --git a/examples/generate_fixture.rs b/examples/generate_fixture.rs
index 5cbf8d0..2f82617 100644
--- a/examples/generate_fixture.rs
+++ b/examples/generate_fixture.rs
@@ -6,11 +6,11 @@ mod helpers;
 
 fn main() {
     let name = std::env::args().nth(1).unwrap();
-    let _ = std::fs::remove_dir_all(format!("tests/data/fixtures/{}", name));
-    std::fs::create_dir_all(format!("tests/data/fixtures/{}", name)).unwrap();
+    let _ = std::fs::remove_dir_all(format!("tests/data/fixtures/{name}"));
+    std::fs::create_dir_all(format!("tests/data/fixtures/{name}")).unwrap();
 
     let inputs =
-        std::fs::File::open(format!("tests/data/fixtures/{}.in", name))
+        std::fs::File::open(format!("tests/data/fixtures/{name}.in"))
             .unwrap();
     let inputs = std::io::BufReader::new(inputs);
 
@@ -21,8 +21,7 @@ fn main() {
 
         let input = helpers::unhex(line.as_bytes());
         let mut input_file = std::fs::File::create(format!(
-            "tests/data/fixtures/{}/{}.typescript",
-            name, i
+            "tests/data/fixtures/{name}/{i}.typescript"
         ))
         .unwrap();
         input_file.write_all(&input).unwrap();
@@ -33,8 +32,7 @@ fn main() {
         let screen = helpers::FixtureScreen::from_screen(term.screen());
 
         let output_file = std::fs::File::create(format!(
-            "tests/data/fixtures/{}/{}.json",
-            name, i
+            "tests/data/fixtures/{name}/{i}.json"
         ))
         .unwrap();
         serde_json::to_writer_pretty(output_file, &screen).unwrap();
diff --git a/examples/generate_fuzz.rs b/examples/generate_fuzz.rs
index 92c983b..c51402b 100644
--- a/examples/generate_fuzz.rs
+++ b/examples/generate_fuzz.rs
@@ -6,10 +6,10 @@ mod helpers;
 
 fn main() {
     let name = std::env::args().nth(1).unwrap();
-    let _ = std::fs::remove_file(format!("fuzz/in/{}", name));
+    let _ = std::fs::remove_file(format!("fuzz/in/{name}"));
 
     let inputs =
-        std::fs::File::open(format!("tests/data/fixtures/{}.in", name))
+        std::fs::File::open(format!("tests/data/fixtures/{name}.in"))
             .unwrap();
     let inputs = std::io::BufReader::new(inputs);
 
@@ -20,6 +20,6 @@ fn main() {
         bytes.extend(input.iter());
     }
     let mut input_file =
-        std::fs::File::create(format!("fuzz/in/{}", name)).unwrap();
+        std::fs::File::create(format!("fuzz/in/{name}")).unwrap();
     input_file.write_all(&bytes).unwrap();
 }
diff --git a/examples/process.rs b/examples/process.rs
index 333f124..aae215c 100644
--- a/examples/process.rs
+++ b/examples/process.rs
@@ -3,7 +3,7 @@ use std::io::Read as _;
 fn read_frames() -> impl Iterator<Item = Vec<u8>> {
     (1..=7625).map(|i| {
         let mut file =
-            std::fs::File::open(format!("tests/data/crawl/crawl{}", i))
+            std::fs::File::open(format!("tests/data/crawl/crawl{i}"))
                 .unwrap();
         let mut frame = vec![];
         file.read_to_end(&mut frame).unwrap();
@@ -29,5 +29,5 @@ fn main() {
             break;
         }
     }
-    eprintln!("{} iterations", i);
+    eprintln!("{i} iterations");
 }
diff --git a/examples/process_diff.rs b/examples/process_diff.rs
index 84ab71c..e9d68a9 100644
--- a/examples/process_diff.rs
+++ b/examples/process_diff.rs
@@ -3,7 +3,7 @@ use std::io::{Read as _, Write as _};
 fn read_frames() -> impl Iterator<Item = Vec<u8>> {
     (1..=7625).map(|i| {
         let mut file =
-            std::fs::File::open(format!("tests/data/crawl/crawl{}", i))
+            std::fs::File::open(format!("tests/data/crawl/crawl{i}"))
                 .unwrap();
         let mut frame = vec![];
         file.read_to_end(&mut frame).unwrap();
@@ -35,5 +35,5 @@ fn main() {
             break;
         }
     }
-    eprintln!("{} iterations", i);
+    eprintln!("{i} iterations");
 }
diff --git a/examples/process_full.rs b/examples/process_full.rs
index fca87c7..5b733eb 100644
--- a/examples/process_full.rs
+++ b/examples/process_full.rs
@@ -3,7 +3,7 @@ use std::io::{Read as _, Write as _};
 fn read_frames() -> impl Iterator<Item = Vec<u8>> {
     (1..=7625).map(|i| {
         let mut file =
-            std::fs::File::open(format!("tests/data/crawl/crawl{}", i))
+            std::fs::File::open(format!("tests/data/crawl/crawl{i}"))
                 .unwrap();
         let mut frame = vec![];
         file.read_to_end(&mut frame).unwrap();
@@ -32,5 +32,5 @@ fn main() {
             break;
         }
     }
-    eprintln!("{} iterations", i);
+    eprintln!("{i} iterations");
 }
diff --git a/examples/real_terminal_compare.rs b/examples/real_terminal_compare.rs
index e9ac92b..ce87a70 100644
--- a/examples/real_terminal_compare.rs
+++ b/examples/real_terminal_compare.rs
@@ -126,7 +126,7 @@ fn main() {
                 }
             }
             Err(e) => {
-                eprintln!("{}", e);
+                eprintln!("{e}");
                 std::process::exit(1);
             }
         }
diff --git a/examples/vte.rs b/examples/vte.rs
index e7db674..e6d0f55 100644
--- a/examples/vte.rs
+++ b/examples/vte.rs
@@ -9,7 +9,7 @@ impl vte::Perform for Log {
     }
 
     fn execute(&mut self, byte: u8) {
-        println!("[execute] {:02x}", byte);
+        println!("[execute] {byte:02x}");
     }
 
     fn hook(
@@ -26,7 +26,7 @@ impl vte::Perform for Log {
     }
 
     fn put(&mut self, byte: u8) {
-        println!("[put] {:02x}", byte);
+        println!("[put] {byte:02x}");
     }
 
     fn unhook(&mut self) {
@@ -35,8 +35,7 @@ impl vte::Perform for Log {
 
     fn osc_dispatch(&mut self, params: &[&[u8]], bell_terminated: bool) {
         println!(
-            "[osc_dispatch] params={:?} bell_terminated={}",
-            params, bell_terminated
+            "[osc_dispatch] params={params:?} bell_terminated={bell_terminated}"
         );
     }
 
@@ -56,8 +55,7 @@ impl vte::Perform for Log {
 
     fn esc_dispatch(&mut self, intermediates: &[u8], ignore: bool, byte: u8) {
         println!(
-            "[esc_dispatch] intermediates={:?}, ignore={:?}, byte={:02x}",
-            intermediates, ignore, byte
+            "[esc_dispatch] intermediates={intermediates:?}, ignore={ignore:?}, byte={byte:02x}"
         );
     }
 }
@@ -77,7 +75,7 @@ fn main() {
                 }
             }
             Err(err) => {
-                eprintln!("err: {}", err);
+                eprintln!("err: {err}");
                 std::process::exit(1);
             }
         }
diff --git a/src/row.rs b/src/row.rs
index 1f65b90..6ef0a80 100644
--- a/src/row.rs
+++ b/src/row.rs
@@ -147,16 +147,16 @@ impl Row {
         let mut prev_was_wide = false;
         let default_cell = crate::cell::Cell::default();
 
-        let mut prev_pos = if let Some(prev_pos) = prev_pos {
-            prev_pos
-        } else if wrapping {
-            crate::grid::Pos {
-                row: row - 1,
-                col: self.cols(),
+        let mut prev_pos = prev_pos.unwrap_or_else(|| {
+            if wrapping {
+                crate::grid::Pos {
+                    row: row - 1,
+                    col: self.cols(),
+                }
+            } else {
+                crate::grid::Pos { row, col: start }
             }
-        } else {
-            crate::grid::Pos { row, col: start }
-        };
+        });
         let mut prev_attrs = prev_attrs.unwrap_or_default();
 
         let first_cell = &self.cells[usize::from(start)];
@@ -228,8 +228,7 @@ impl Row {
                         if !wrapping
                             || prev_pos.row + 1 != pos.row
                             || prev_pos.col
-                                < self.cols()
-                                    - if cell.is_wide() { 1 } else { 0 }
+                                < self.cols() - u16::from(cell.is_wide())
                             || pos.col != 0
                         {
                             crate::term::MoveFromTo::new(prev_pos, pos)
@@ -304,7 +303,7 @@ impl Row {
             && first_cell == prev_first_cell
             && prev_pos.row + 1 == row
             && prev_pos.col
-                >= self.cols() - if prev_first_cell.is_wide() { 1 } else { 0 }
+                >= self.cols() - u16::from(prev_first_cell.is_wide())
         {
             let first_cell_attrs = first_cell.attrs();
             if &prev_attrs != first_cell_attrs {
@@ -387,8 +386,7 @@ impl Row {
                         if !wrapping
                             || prev_pos.row + 1 != pos.row
                             || prev_pos.col
-                                < self.cols()
-                                    - if cell.is_wide() { 1 } else { 0 }
+                                < self.cols() - u16::from(cell.is_wide())
                             || pos.col != 0
                         {
                             crate::term::MoveFromTo::new(prev_pos, pos)
diff --git a/src/screen.rs b/src/screen.rs
index 13e71eb..a50671f 100644
--- a/src/screen.rs
+++ b/src/screen.rs
@@ -222,7 +222,7 @@ impl Screen {
                 if start_col < end_col {
                     self.rows(start_col, end_col - start_col)
                         .nth(usize::from(start_row))
-                        .unwrap_or_else(String::new)
+                        .unwrap_or_default()
                 } else {
                     String::new()
                 }
@@ -1175,7 +1175,7 @@ impl Screen {
             1 => self.grid_mut().erase_all_backward(attrs),
             2 => self.grid_mut().erase_all(attrs),
             n => {
-                log::debug!("unhandled ED mode: {}", n);
+                log::debug!("unhandled ED mode: {n}");
             }
         }
     }
@@ -1193,7 +1193,7 @@ impl Screen {
             1 => self.grid_mut().erase_row_backward(attrs),
             2 => self.grid_mut().erase_row(attrs),
             n => {
-                log::debug!("unhandled EL mode: {}", n);
+                log::debug!("unhandled EL mode: {n}");
             }
         }
     }
@@ -1286,9 +1286,9 @@ impl Screen {
                                 ns[0]
                             )
                         } else {
-                            format!("{:?}", ns)
+                            format!("{ns:?}")
                         };
-                        log::debug!("unhandled DECSET mode: {}", n);
+                        log::debug!("unhandled DECSET mode: {n}");
                     }
                 }
             }
@@ -1345,9 +1345,9 @@ impl Screen {
                                 ns[0]
                             )
                         } else {
-                            format!("{:?}", ns)
+                            format!("{ns:?}")
                         };
-                        log::debug!("unhandled DECRST mode: {}", n);
+                        log::debug!("unhandled DECRST mode: {n}");
                     }
                 }
             }
@@ -1442,9 +1442,9 @@ impl Screen {
                                     ns[0]
                                 )
                             } else {
-                                format!("{:?}", ns)
+                                format!("{ns:?}")
                             };
-                            log::debug!("unhandled SGR mode: 38 {}", n);
+                            log::debug!("unhandled SGR mode: 38 {n}");
                         }
                         return;
                     }
@@ -1488,9 +1488,9 @@ impl Screen {
                                     ns[0]
                                 )
                             } else {
-                                format!("{:?}", ns)
+                                format!("{ns:?}")
                             };
-                            log::debug!("unhandled SGR mode: 48 {}", n);
+                            log::debug!("unhandled SGR mode: 48 {n}");
                         }
                         return;
                     }
@@ -1516,9 +1516,9 @@ impl Screen {
                                 ns[0]
                             )
                         } else {
-                            format!("{:?}", ns)
+                            format!("{ns:?}")
                         };
-                        log::debug!("unhandled SGR mode: {}", n);
+                        log::debug!("unhandled SGR mode: {n}");
                     }
                 }
             }
@@ -1572,14 +1572,14 @@ impl vte::Perform for Screen {
             14 | 15 => {}
             _ => {
                 self.errors = self.errors.saturating_add(1);
-                log::debug!("unhandled control character: {}", b);
+                log::debug!("unhandled control character: {b}");
             }
         }
     }
 
     fn esc_dispatch(&mut self, intermediates: &[u8], _ignore: bool, b: u8) {
-        match intermediates.get(0) {
-            None => match b {
+        intermediates.first().map_or_else(
+            || match b {
                 b'7' => self.decsc(),
                 b'8' => self.decrc(),
                 b'=' => self.deckpam(),
@@ -1588,13 +1588,13 @@ impl vte::Perform for Screen {
                 b'c' => self.ris(),
                 b'g' => self.vb(),
                 _ => {
-                    log::debug!("unhandled escape code: ESC {}", b);
+                    log::debug!("unhandled escape code: ESC {b}");
                 }
             },
-            Some(i) => {
-                log::debug!("unhandled escape code: ESC {} {}", i, b);
-            }
-        }
+            |i| {
+                log::debug!("unhandled escape code: ESC {i} {b}");
+            },
+        );
     }
 
     fn csi_dispatch(
@@ -1604,7 +1604,7 @@ impl vte::Perform for Screen {
         _ignore: bool,
         c: char,
     ) {
-        match intermediates.get(0) {
+        match intermediates.first() {
             None => match c {
                 '@' => self.ich(canonicalize_params_1(params, 1)),
                 'A' => self.cuu(canonicalize_params_1(params, 1)),
@@ -1691,25 +1691,29 @@ impl vte::Perform for Screen {
         action: char,
     ) {
         if log::log_enabled!(log::Level::Debug) {
-            match intermediates.get(0) {
-                None => log::debug!(
-                    "unhandled dcs sequence: DCS {} {}",
-                    param_str(params),
-                    action,
-                ),
-                Some(i) => log::debug!(
-                    "unhandled dcs sequence: DCS {} {} {}",
-                    i,
-                    param_str(params),
-                    action,
-                ),
-            }
+            intermediates.first().map_or_else(
+                || {
+                    log::debug!(
+                        "unhandled dcs sequence: DCS {} {}",
+                        param_str(params),
+                        action,
+                    );
+                },
+                |i| {
+                    log::debug!(
+                        "unhandled dcs sequence: DCS {} {} {}",
+                        i,
+                        param_str(params),
+                        action,
+                    );
+                },
+            );
         }
     }
 }
 
 fn canonicalize_params_1(params: &vte::Params, default: u16) -> u16 {
-    let first = params.iter().next().map_or(0, |x| *x.get(0).unwrap_or(&0));
+    let first = params.iter().next().map_or(0, |x| *x.first().unwrap_or(&0));
     if first == 0 {
         default
     } else {
@@ -1723,10 +1727,10 @@ fn canonicalize_params_2(
     default2: u16,
 ) -> (u16, u16) {
     let mut iter = params.iter();
-    let first = iter.next().map_or(0, |x| *x.get(0).unwrap_or(&0));
+    let first = iter.next().map_or(0, |x| *x.first().unwrap_or(&0));
     let first = if first == 0 { default1 } else { first };
 
-    let second = iter.next().map_or(0, |x| *x.get(0).unwrap_or(&0));
+    let second = iter.next().map_or(0, |x| *x.first().unwrap_or(&0));
     let second = if second == 0 { default2 } else { second };
 
     (first, second)
@@ -1737,10 +1741,10 @@ fn canonicalize_params_decstbm(
     size: crate::grid::Size,
 ) -> (u16, u16) {
     let mut iter = params.iter();
-    let top = iter.next().map_or(0, |x| *x.get(0).unwrap_or(&0));
+    let top = iter.next().map_or(0, |x| *x.first().unwrap_or(&0));
     let top = if top == 0 { 1 } else { top };
 
-    let bottom = iter.next().map_or(0, |x| *x.get(0).unwrap_or(&0));
+    let bottom = iter.next().map_or(0, |x| *x.first().unwrap_or(&0));
     let bottom = if bottom == 0 { size.rows } else { bottom };
 
     (top, bottom)
@@ -1772,7 +1776,7 @@ fn param_str(params: &vte::Params) -> String {
 fn osc_param_str(params: &[&[u8]]) -> String {
     let strs: Vec<_> = params
         .iter()
-        .map(|b| format!("\"{}\"", std::string::String::from_utf8_lossy(*b)))
+        .map(|b| format!("\"{}\"", std::string::String::from_utf8_lossy(b)))
         .collect();
     strs.join(" ; ")
 }
diff --git a/tests/helpers/fixtures.rs b/tests/helpers/fixtures.rs
index c0f8b75..bc39926 100644
--- a/tests/helpers/fixtures.rs
+++ b/tests/helpers/fixtures.rs
@@ -96,7 +96,7 @@ impl FixtureScreen {
                 let cell = screen.cell(row, col).unwrap();
                 if cell != &vt100::Cell::default() {
                     cells.insert(
-                        format!("{},{}", row, col),
+                        format!("{row},{col}"),
                         FixtureCell::from_cell(cell),
                     );
                 }
@@ -159,8 +159,8 @@ where
 {
     let s = match color {
         vt100::Color::Default => unreachable!(),
-        vt100::Color::Idx(n) => format!("{}", n),
-        vt100::Color::Rgb(r, g, b) => format!("#{:02x}{:02x}{:02x}", r, g, b),
+        vt100::Color::Idx(n) => format!("{n}"),
+        vt100::Color::Rgb(r, g, b) => format!("#{r:02x}{g:02x}{b:02x}"),
     };
     serializer.serialize_str(&s)
 }
@@ -231,8 +231,7 @@ where
 
 fn load_input(name: &str, i: usize) -> Option<Vec<u8>> {
     let mut file = std::fs::File::open(format!(
-        "tests/data/fixtures/{}/{}.typescript",
-        name, i
+        "tests/data/fixtures/{name}/{i}.typescript"
     ))
     .ok()?;
     let mut input = vec![];
@@ -241,11 +240,9 @@ fn load_input(name: &str, i: usize) -> Option<Vec<u8>> {
 }
 
 fn load_screen(name: &str, i: usize) -> Option<FixtureScreen> {
-    let mut file = std::fs::File::open(format!(
-        "tests/data/fixtures/{}/{}.json",
-        name, i
-    ))
-    .ok()?;
+    let mut file =
+        std::fs::File::open(format!("tests/data/fixtures/{name}/{i}.json"))
+            .ok()?;
     Some(FixtureScreen::load(&mut file))
 }
 
@@ -281,7 +278,7 @@ fn assert_produces(input: &[u8], expected: &FixtureScreen) {
         for col in 0..cols {
             let expected_cell = expected
                 .cells
-                .get(&format!("{},{}", row, col))
+                .get(&format!("{row},{col}"))
                 .cloned()
                 .unwrap_or_default();
             let got_cell = parser.screen().cell(row, col).unwrap();
diff --git a/tests/helpers/mod.rs b/tests/helpers/mod.rs
index dc08ce5..67bb1f4 100644
--- a/tests/helpers/mod.rs
+++ b/tests/helpers/mod.rs
@@ -46,7 +46,7 @@ impl<'a> std::fmt::Debug for Bytes<'a> {
                 13 => f.write_str("\\r")?,
                 92 => f.write_str("\\\\")?,
                 32..=126 => f.write_str(&char::from(*c).to_string())?,
-                _ => f.write_fmt(format_args!("\\x{:02x}", c))?,
+                _ => f.write_fmt(format_args!("\\x{c:02x}"))?,
             }
         }
         f.write_str("\"")?;
@@ -267,7 +267,7 @@ pub fn format_bytes(bytes: &[u8]) -> String {
             13 => v.extend(b"\\r"),
             27 => v.extend(b"\\e"),
             c if c < 32 || c == 127 => {
-                v.extend(format!("\\x{:02x}", c).as_bytes())
+                v.extend(format!("\\x{c:02x}").as_bytes())
             }
             b => v.push(b),
         }
diff --git a/tests/quickcheck.rs b/tests/quickcheck.rs
index efb6f63..3591285 100644
--- a/tests/quickcheck.rs
+++ b/tests/quickcheck.rs
@@ -13,8 +13,7 @@ impl quickcheck::Arbitrary for TerminalInput {
         };
         TerminalInput(
             (0..size)
-                .map(|_| choose_terminal_input_fragment(g))
-                .flatten()
+                .flat_map(|_| choose_terminal_input_fragment(g))
                 .collect(),
         )
     }
@@ -59,7 +58,7 @@ fn choose_terminal_input_fragment<G: quickcheck::Gen>(g: &mut G) -> Vec<u8> {
             let c: Result<char, _> = std::convert::TryFrom::try_from(u);
             let c = match c {
                 Ok(c) => c,
-                Err(e) => panic!("failed to create char from {}: {}", u, e),
+                Err(e) => panic!("failed to create char from {u}: {e}"),
             };
             let mut b = [0; 4];
             let s = c.encode_utf8(&mut b);
diff --git a/tests/split-escapes.rs b/tests/split-escapes.rs
index fa5b6b1..36fb647 100644
--- a/tests/split-escapes.rs
+++ b/tests/split-escapes.rs
@@ -7,7 +7,7 @@ fn get_file_contents(name: &str) -> Vec<u8> {
     buf
 }
 
-fn write_to_parser(chunks: &mut Vec<Vec<u8>>) -> (String, Vec<u8>) {
+fn write_to_parser(chunks: &mut [Vec<u8>]) -> (String, Vec<u8>) {
     let mut parser = vt100::Parser::new(37, 193, 0);
     for chunk in chunks.iter_mut() {
         parser.process(chunk);
@@ -21,7 +21,7 @@ fn write_to_parser(chunks: &mut Vec<Vec<u8>>) -> (String, Vec<u8>) {
 fn test_splits(filename: &str, limit: Option<usize>) {
     let bytes = get_file_contents(filename);
     let len = bytes.len();
-    let expected = write_to_parser(&mut vec![bytes.clone()]);
+    let expected = write_to_parser(&mut [bytes.clone()]);
     for i in 0..(len - 1) {
         if let Some(limit) = limit {
             if i > limit {
@@ -34,9 +34,7 @@ fn test_splits(filename: &str, limit: Option<usize>) {
         let got = write_to_parser(&mut chunks);
         assert!(
             got == expected,
-            "failed to render {} when split at byte {}",
-            filename,
-            i
+            "failed to render {filename} when split at byte {i}"
         );
     }
 }
diff --git a/tests/window_contents.rs b/tests/window_contents.rs
index a300438..a3df341 100644
--- a/tests/window_contents.rs
+++ b/tests/window_contents.rs
@@ -556,7 +556,7 @@ fn diff_crawl(i: usize) {
     let screens: Vec<_> = (1..=i)
         .map(|i| {
             let mut file =
-                std::fs::File::open(format!("tests/data/crawl/crawl{}", i))
+                std::fs::File::open(format!("tests/data/crawl/crawl{i}"))
                     .unwrap();
             let mut frame = vec![];
             file.read_to_end(&mut frame).unwrap();