clippy fix

Author: tbali0524

src/aoc/cli.rs

@@ -14,7 +14,7 @@ const ARG_VERSION: &str = "--version";
 
 /// The main CLI runner.
 pub fn run() -> ExitCode {
-    println!("{}\n", MSG_TITLE);
+    println!("{MSG_TITLE}\n");
     let args = env::args().collect::<Vec<_>>();
     match parse_args(&args) {
         Err(msg) => {
@@ -25,7 +25,7 @@ pub fn run() -> ExitCode {
             if msg == ARG_HELP {
                 return ExitCode::SUCCESS;
             }
-            println!("{ANSI_RED_INV}[ERROR]{ANSI_RESET} {}\n", msg);
+            println!("{ANSI_RED_INV}[ERROR]{ANSI_RESET} {msg}\n");
             ExitCode::from(2)
         }
         Ok((year, day)) => {

src/aoc/runner.rs

@@ -92,34 +92,19 @@ pub fn run_puzzles(year: Option<usize>, day: Option<usize>, parallel: bool) -> b
         }
         let season = puzzle_list[idx].0.year;
         if season != prev_season {
-            println!(
-                "======= {} ===================================================",
-                season
-            );
+            println!("======= {season} ===================================================");
         }
         prev_season = season;
-        print!("{}", message);
+        print!("{message}");
     }
     let msg_skip_fail = if count_skipped_puzzles > 0 && count_failed_puzzles > 0 {
         format!(
-            " ({}{}{} skipped, {}{}{} failed)",
-            ANSI_YELLOW,
-            count_skipped_puzzles,
-            ANSI_RESET,
-            ANSI_RED,
-            count_failed_puzzles,
-            ANSI_RESET
+            " ({ANSI_YELLOW}{count_skipped_puzzles}{ANSI_RESET} skipped, {ANSI_RED}{count_failed_puzzles}{ANSI_RESET} failed)"
         )
     } else if count_skipped_puzzles > 0 {
-        format!(
-            " ({}{}{} skipped)",
-            ANSI_YELLOW, count_skipped_puzzles, ANSI_RESET
-        )
+        format!(" ({ANSI_YELLOW}{count_skipped_puzzles}{ANSI_RESET} skipped)")
     } else if count_failed_puzzles > 0 {
-        format!(
-            " ({}{}{} failed)",
-            ANSI_RED, count_failed_puzzles, ANSI_RESET
-        )
+        format!(" ({ANSI_RED}{count_failed_puzzles}{ANSI_RESET} failed)")
     } else {
         String::new()
     };
@@ -142,7 +127,7 @@ pub fn run_puzzles(year: Option<usize>, day: Option<usize>, parallel: bool) -> b
         MSG_FAIL_TOTAL
     };
     if count_puzzles > 0 {
-        println!("{}\n", msg);
+        println!("{msg}\n");
     }
     all_passed
 }
@@ -155,7 +140,7 @@ pub fn run_puzzle(puzzle: &PuzzleMetaData, solve: Solver, to_skip: bool) -> (boo
     let mut all_passed = true;
     let mut all_message = String::new();
     if to_skip {
-        all_message = format!("{}\n", MSG_SKIP);
+        all_message = format!("{MSG_SKIP}\n");
     } else {
         let count_examples = puzzle.example_solutions.len();
         let mut cases = (1..=count_examples).collect::<Vec<_>>();
@@ -228,7 +213,7 @@ pub fn run_case(puzzle: &PuzzleMetaData, solve: Solver, case: usize) -> (bool, S
             } else {
                 all_passed = false;
                 pre_msg = MSG_FAIL;
-                ans_msg = format!("{ANSI_YELLOW}{}{ANSI_RESET}", ans_case);
+                ans_msg = format!("{ANSI_YELLOW}{ans_case}{ANSI_RESET}");
                 post_msg = format!(
                     "{}[expected: {}]",
                     " ".repeat(20 - min(20, ans_case.to_string().len())),
@@ -244,15 +229,10 @@ pub fn run_case(puzzle: &PuzzleMetaData, solve: Solver, case: usize) -> (bool, S
             ans_msg = format!("{ANSI_YELLOW}n/a{ANSI_RESET}");
         }
         if case == 0 {
-            all_message += &format!(
-                "{} Puzzle     part #{} : {}{}\n",
-                pre_msg, part, ans_msg, post_msg
-            );
+            all_message += &format!("{pre_msg} Puzzle     part #{part} : {ans_msg}{post_msg}\n");
         } else {
-            all_message += &format!(
-                "{} Example #{} part #{} : {}{}\n",
-                pre_msg, case, part, ans_msg, post_msg
-            );
+            all_message +=
+                &format!("{pre_msg} Example #{case} part #{part} : {ans_msg}{post_msg}\n");
         }
     }
     (all_passed, all_message)
@@ -270,9 +250,9 @@ fn get_plural(item: usize) -> String {
 // ------------------------------------------------------------
 fn get_case_error(case: usize, e: PuzzleError) -> String {
     if case == 0 {
-        format!("{MSG_FAIL} Puzzle             : {:?}\n", e)
+        format!("{MSG_FAIL} Puzzle             : {e:?}\n")
     } else {
-        format!("{MSG_FAIL} Example #{}         : {:?}\n", case, e)
+        format!("{MSG_FAIL} Example #{case}         : {e:?}\n")
     }
 }
 
@@ -292,7 +272,7 @@ fn get_expected<'a>(puzzle: &'a PuzzleMetaData, case: usize) -> PuzzleExpected<'
 /// * `case == 1, 2, ...` for example inputs
 pub fn read_input(puzzle: &PuzzleMetaData, case: usize) -> Result<String, PuzzleError> {
     if case > puzzle.example_solutions.len() {
-        Err(format!("missing expected solution for example #{}", case))?;
+        Err(format!("missing expected solution for example #{case}"))?;
     }
     let input_path = if case == 0 {
         format!(
@@ -306,7 +286,7 @@ pub fn read_input(puzzle: &PuzzleMetaData, case: usize) -> Result<String, Puzzle
         )
     };
     let input = fs::read_to_string(path::Path::new(&input_path))
-        .map_err(|_| format!("cannot read input file: {}", input_path))?;
+        .map_err(|_| format!("cannot read input file: {input_path}"))?;
     if input.is_empty() {
         Err("empty input")?;
     }
@@ -370,15 +350,12 @@ pub mod tests {
 
     /// Similar to `test_invalid()`, but also checks if the error message contains the givent string slice.
     pub fn test_invalid_msg(input: PuzzleInput, solve: Solver, msg: &str) {
-        let result = solve(&input);
+        let result = solve(input);
         assert!(result.is_err());
         if !msg.is_empty() {
             let e = result.unwrap_err().0;
             if !e.contains(msg) {
-                eprintln!(
-                    "*** Error message does not match the expected: {} != {}",
-                    e, msg
-                );
+                eprintln!("*** Error message does not match the expected: {e} != {msg}");
             }
             assert!(e.contains(msg));
         }

src/aoc2015/aoc2015day01.rs

@@ -23,8 +23,7 @@ pub fn solve(input: PuzzleInput) -> PuzzleResult {
     for c in line.chars() {
         if c != '(' && c != ')' {
             Err(format!(
-                "input must contain only `(` or `)` chars, found `{}`",
-                c
+                "input must contain only `(` or `)` chars, found `{c}`"
             ))?;
         }
     }
@@ -69,11 +68,11 @@ mod tests {
 
     #[test]
     fn invalid_single_line() {
-        test_invalid_msg(&[&"(())", &"()"], solve, "input must have a single line");
+        test_invalid_msg(&["(())", "()"], solve, "input must have a single line");
     }
 
     #[test]
     fn invalid_only_parentheses() {
-        test_invalid_msg(&[&"(a)"], solve, "input must contain only `(` or `)`");
+        test_invalid_msg(&["(a)"], solve, "input must contain only `(` or `)`");
     }
 }

src/aoc2015/aoc2015day02.rs

@@ -22,7 +22,7 @@ pub fn solve(input: PuzzleInput) -> PuzzleResult {
             line.split('x')
                 .map(|x| {
                     x.parse::<ItemType>()
-                        .map_err(|_| format!("input must contain only integers, found `{}`", x))
+                        .map_err(|_| format!("input must contain only integers, found `{x}`"))
                 })
                 .collect::<Result<Vec<_>, _>>()
         })
@@ -71,7 +71,7 @@ mod tests {
     #[test]
     fn invalid_only_2d_array_of_ints() {
         test_invalid_msg(
-            &[&"1x2x3", &"4xax6"],
+            &["1x2x3", "4xax6"],
             solve,
             "input must contain only integers",
         );
@@ -80,7 +80,7 @@ mod tests {
     #[test]
     fn invalid_only_triplets_of_ints() {
         test_invalid_msg(
-            &[&"1x2x3x4"],
+            &["1x2x3x4"],
             solve,
             "input must contain 3 integers per line",
         );

src/aoc2015/aoc2015day03.rs

@@ -58,7 +58,7 @@ pub fn delta(dir: char) -> Result<(i32, i32), PuzzleError> {
         'v' => Ok((0, 1)),
         '<' => Ok((-1, 0)),
         '^' => Ok((0, -1)),
-        _ => Err(format!("direction must be >v<^, found `{}`", dir))?,
+        _ => Err(format!("direction must be >v<^, found `{dir}`"))?,
     }
 }
 
@@ -85,11 +85,11 @@ mod tests {
 
     #[test]
     fn invalid_single_line() {
-        test_invalid(&[&"<>", &"><"], solve);
+        test_invalid(&["<>", "><"], solve);
     }
 
     #[test]
     fn invalid_only_directions() {
-        test_invalid(&[&"<a>"], solve);
+        test_invalid(&["<a>"], solve);
     }
 }

src/aoc2015/aoc2015day04.rs

@@ -68,6 +68,6 @@ mod tests {
 
     #[test]
     fn invalid_single_line() {
-        test_invalid(&[&"a", &"b"], solve);
+        test_invalid(&["a", "b"], solve);
     }
 }

src/aoc2015/aoc2015day06.rs

@@ -136,21 +136,21 @@ mod tests {
 
     #[test]
     fn invalid_number_of_words() {
-        test_invalid(&[&"a"], solve);
+        test_invalid(&["a"], solve);
     }
 
     #[test]
     fn invalid_position_number() {
-        test_invalid(&[&"turn on 0,0,1 through 0,0"], solve);
+        test_invalid(&["turn on 0,0,1 through 0,0"], solve);
     }
 
     #[test]
     fn invalid_positions_must_be_integers() {
-        test_invalid(&[&"turn on 0,a through 0,0"], solve);
+        test_invalid(&["turn on 0,a through 0,0"], solve);
     }
 
     #[test]
     fn invalid_verb() {
-        test_invalid(&[&"discard 0,0 through 0,0"], solve);
+        test_invalid(&["discard 0,0 through 0,0"], solve);
     }
 }

src/aoc2015/aoc2015day07.rs

@@ -107,7 +107,7 @@ impl Circuit {
         let gate = self
             .gates
             .get(id)
-            .ok_or(format!("invalid wire id `{}`", id))?;
+            .ok_or(format!("invalid wire id `{id}`"))?;
         if let Some(x) = gate.value {
             return Ok(x);
         }
@@ -132,7 +132,7 @@ impl Circuit {
                     "OR" => a | b,
                     "LSHIFT" => a << b,
                     "RSHIFT" => a >> b,
-                    _ => Err(format!("invalid operator `{}`", operator))?,
+                    _ => Err(format!("invalid operator `{operator}`"))?,
                 }
             }
         };
@@ -160,26 +160,26 @@ mod tests {
 
     #[test]
     fn invalid_must_have_arrow() {
-        test_invalid(&[&"a"], solve);
+        test_invalid(&["a"], solve);
     }
 
     #[test]
     fn invalid_too_many_operands() {
-        test_invalid(&[&"x LSHIFT 2 3 -> y"], solve);
+        test_invalid(&["x LSHIFT 2 3 -> y"], solve);
     }
 
     #[test]
     fn invalid_unary_operator() {
-        test_invalid(&[&"AND x -> y"], solve);
+        test_invalid(&["AND x -> y"], solve);
     }
 
     #[test]
     fn invalid_binary_operator() {
-        test_invalid(&[&"x XOR y -> z"], solve);
+        test_invalid(&["x XOR y -> z"], solve);
     }
 
     #[test]
     fn invalid_wire_id() {
-        test_invalid(&[&"x AND 1 -> y"], solve);
+        test_invalid(&["x AND 1 -> y"], solve);
     }
 }

src/aoc2015/aoc2015day09.rs

@@ -111,21 +111,21 @@ mod tests {
 
     #[test]
     fn invalid_missing_equal_sign() {
-        test_invalid(&[&"a"], solve);
+        test_invalid(&["a"], solve);
     }
 
     #[test]
     fn invalid_missing_to() {
-        test_invalid(&[&"a = 1"], solve);
+        test_invalid(&["a = 1"], solve);
     }
 
     #[test]
     fn invalid_distance_must_be_integer() {
-        test_invalid(&[&"a to b = c"], solve);
+        test_invalid(&["a to b = c"], solve);
     }
 
     #[test]
     fn invalid_source_and_destination_must_be_different() {
-        test_invalid(&[&"a to a = 1"], solve);
+        test_invalid(&["a to a = 1"], solve);
     }
 }

src/aoc2015/aoc2015day10.rs

@@ -72,6 +72,6 @@ mod tests {
 
     #[test]
     fn invalid_single_line() {
-        test_invalid(&[&"a", &"b"], solve);
+        test_invalid(&["a", "b"], solve);
     }
 }