From 5fe3d1caa86e76e31217360d176067ba60f2224e Mon Sep 17 00:00:00 2001
From: Evie Litherland-Smith <evie@xenia.me.uk>
Date: Sat, 6 Jan 2024 07:19:13 +0000
Subject: [PATCH] Make functions public

Move valid number filtering to separate function for more granular testing
---
 day3/src/part1.rs | 41 +++++++++++++++++++++--------------------
 1 file changed, 21 insertions(+), 20 deletions(-)

diff --git a/day3/src/part1.rs b/day3/src/part1.rs
index a752836..613b700 100644
--- a/day3/src/part1.rs
+++ b/day3/src/part1.rs
@@ -2,7 +2,7 @@ use regex::{Match, Regex};
 use std::{fmt::Display, num::ParseIntError};
 
 #[derive(Debug)]
-struct Symbol {
+pub struct Symbol {
     value: char,
     row: usize,
     col: usize,
@@ -15,7 +15,7 @@ impl Display for Symbol {
 }
 
 #[derive(Debug)]
-struct Number {
+pub struct Number {
     value: u32,
     row: usize,
     start: usize,
@@ -36,7 +36,7 @@ impl Display for Number {
 }
 
 impl Number {
-    fn valid(&self, symbols: &[Symbol]) -> bool {
+    pub fn is_valid(&self, symbols: &[Symbol]) -> bool {
         let adjacent: Vec<usize> = symbols
             .iter()
             .filter_map(|m| {
@@ -68,7 +68,7 @@ impl TryFrom<Match<'_>> for Number {
     }
 }
 
-fn get_symbols(input: &str) -> Vec<Symbol> {
+pub fn get_symbols(input: &str) -> Vec<Symbol> {
     let mut items: Vec<Symbol> = Vec::new();
     for (row, line) in input.lines().enumerate() {
         for (col, value) in line.chars().enumerate() {
@@ -80,40 +80,38 @@ fn get_symbols(input: &str) -> Vec<Symbol> {
     items
 }
 
-fn get_numbers(input: &str) -> Vec<Number> {
+pub fn get_numbers(input: &str, predicate: Option<&dyn Fn(&Number) -> bool>) -> Vec<Number> {
     let rstring = r"(\d)+";
     let mut items: Vec<Number> = Vec::new();
     for (row, line) in input.lines().enumerate() {
         for item in Regex::new(rstring).unwrap().find_iter(line) {
             let mut number = Number::try_from(item).unwrap();
             number.row = row;
-            items.push(number);
+            if predicate.unwrap_or(&|_| true)(&number) {
+                items.push(number);
+            };
         }
     }
     items
 }
 
+pub fn get_valid_numbers(input: &str, symbols: &[Symbol]) -> Vec<u32> {
+    get_numbers(input, Some(&|number| number.is_valid(symbols)))
+        .iter()
+        .map(|m| m.value)
+        .collect()
+}
+
 pub fn main(input: &str) -> u32 {
     let symbols = get_symbols(input);
-    get_numbers(input)
-        .iter()
-        .filter_map(|m| {
-            if m.valid(&symbols) {
-                Some(m.value)
-            } else {
-                None
-            }
-        })
-        .sum()
+    get_valid_numbers(input, &symbols).iter().sum()
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    #[test]
-    fn example() {
-        let input = "467..114..
+    const INPUT: &str = "467..114..
 ...*......
 ..35..633.
 ......#...
@@ -123,6 +121,9 @@ mod tests {
 ......755.
 ...$.*....
 .664.598..";
-        assert_eq!(main(input), 4361);
+
+    #[test]
+    fn example() {
+        assert_eq!(main(INPUT), 4361);
     }
 }