Cleaned up runner

src/main.rs

@@ -1,40 +1,20 @@
 mod solutions;
 mod utils;
 
-use std::{error::Error, time::SystemTime};
+use std::error::Error;
 
 use solutions::*;
 
-use crate::utils::get_input;
-
 fn main() -> Result<(), Box<dyn Error>> {
-    let days: Vec<Box<dyn Solution>> = vec![Box::new(day01::Day01 {}), Box::new(day02::Day02 {})];
+    let days: Vec<Box<dyn Solution>> = vec![
+        Box::new(day01::Day01 {}),
+        Box::new(day02::Day02 {}),
+        Box::new(day03::Day03 {}),
+    ];
 
     // Run through and generate solutions
     for day in days.iter().rev() {
-        println!("========== Day {} ==========", day.get_day());
+        day.run()?;
-        let start_time = SystemTime::now();
-        println!(
-            "Part1 Test: {}",
-            day.part1(get_input(day.get_day(), utils::InputType::Test1)?.as_mut())?
-        );
-        println!(
-            "Part1 Result: {}",
-            day.part1(get_input(day.get_day(), utils::InputType::Actual)?.as_mut())?
-        );
-
-        println!(
-            "Part2 Test: {}",
-            day.part2(get_input(day.get_day(), utils::InputType::Test2)?.as_mut())?
-        );
-        println!(
-            "Part2 Result: {}",
-            day.part2(get_input(day.get_day(), utils::InputType::Actual)?.as_mut())?
-        );
-        println!(
-            "========= {}ms =========",
-            SystemTime::now().duration_since(start_time)?.as_millis()
-        );
     }
 
     Ok(())

src/solutions/day01.rs

@@ -1,6 +1,6 @@
 use super::Solution;
-use std::str::FromStr;
 use fancy_regex::Regex;
+use std::str::FromStr;
 use strum_macros::EnumString;
 
 #[allow(non_camel_case_types)]
@@ -15,7 +15,7 @@ enum WrittenNumbers {
     six = 6,
     seven = 7,
     eight = 8,
-    nine = 9
+    nine = 9,
 }
 
 pub struct Day01 {}
@@ -53,9 +53,13 @@ impl Solution for Day01 {
 }
 
 impl Day01 {
-    fn regex_get_num(&self, regex: &str, input: &mut String) -> Result<u32, Box<dyn std::error::Error>> {
+    fn regex_get_num(
+        &self,
+        regex: &str,
+        input: &mut String,
+    ) -> Result<u32, Box<dyn std::error::Error>> {
         let re = Regex::new(regex).unwrap();
-        
+
         // Really don't like this :(
         let input = input.replace("oneight", "oneeight");
         let input = input.replace("threeight", "threeeight");
@@ -66,17 +70,14 @@ impl Day01 {
         let input = input.replace("eightwo", "eighttwo");
 
         // Get all single digits out of string
-        let matches: Vec<&str> = re
+        let matches: Vec<&str> = re.find_iter(&input).map(|m| m.unwrap().as_str()).collect();
-            .find_iter(&input)
-            .map(|m| m.unwrap().as_str())
-            .collect();
 
         // Convert everything to a number
         let mut nums: Vec<u32> = vec![];
         for m in matches.clone() {
             match Day01::convert_written_number(m) {
                 Some(n) => nums.push(n),
-                None => nums.push(m.parse::<u32>()?)
+                None => nums.push(m.parse::<u32>()?),
             }
         }
 
@@ -98,29 +99,39 @@ impl Day01 {
 /// Test from puzzle input
 #[cfg(test)]
 mod test {
-    use crate::*;
     use super::*;
+    use crate::*;
 
     #[test]
     fn part1() {
-        let challenge = day01::Day01{};
+        let challenge = day01::Day01 {};
 
         //Complete the Challenge
-        let answer = challenge.part1(
+        let answer = challenge
-            get_input(challenge.get_day(), utils::InputType::Test1).unwrap().as_mut()
+            .part1(
-        ).unwrap().to_string();
+                get_input(challenge.get_day(), utils::InputType::Test1)
+                    .unwrap()
+                    .as_mut(),
+            )
+            .unwrap()
+            .to_string();
 
         assert_eq!(answer, "142");
     }
 
     #[test]
     fn part2() {
-        let challenge = day01::Day01{};
+        let challenge = day01::Day01 {};
 
         //Complete the Challenge
-        let answer = challenge.part2(
+        let answer = challenge
-            get_input(challenge.get_day(), utils::InputType::Test2).unwrap().as_mut()
+            .part2(
-        ).unwrap().to_string();
+                get_input(challenge.get_day(), utils::InputType::Test2)
+                    .unwrap()
+                    .as_mut(),
+            )
+            .unwrap()
+            .to_string();
 
         assert_eq!(answer, "281");
     }

src/solutions/mod.rs

@@ -2,10 +2,38 @@ pub mod day01;
 pub mod day02;
 pub mod day03;
 
-use std::{error::Error, fmt::Display};
+use crate::utils::{self, get_input};
+use std::{error::Error, fmt::Display, time::SystemTime};
 
 pub trait Solution {
     fn part1(&self, input: &mut Vec<String>) -> Result<Box<dyn Display>, Box<dyn Error>>;
     fn part2(&self, input: &mut Vec<String>) -> Result<Box<dyn Display>, Box<dyn Error>>;
     fn get_day(&self) -> u8;
+
+    fn run(&self) -> Result<(), Box<dyn std::error::Error>> {
+        println!("========== Day {} ==========", self.get_day());
+        let start_time = SystemTime::now();
+        println!(
+            "Part1 Test: {}",
+            self.part1(get_input(self.get_day(), utils::InputType::Test1)?.as_mut())?
+        );
+        println!(
+            "Part1 Result: {}",
+            self.part1(get_input(self.get_day(), utils::InputType::Actual)?.as_mut())?
+        );
+
+        println!(
+            "Part2 Test: {}",
+            self.part2(get_input(self.get_day(), utils::InputType::Test2)?.as_mut())?
+        );
+        println!(
+            "Part2 Result: {}",
+            self.part2(get_input(self.get_day(), utils::InputType::Actual)?.as_mut())?
+        );
+        println!(
+            "========= {}ms =========",
+            SystemTime::now().duration_since(start_time)?.as_millis()
+        );
+        Ok(())
+    }
 }