Ref: Move parse into Playfield

Ref: Move playfield in separate file

src/main.rs

@@ -1,5 +1,9 @@
 use clap::Parser;
 
+mod playfield;
+
+use playfield::Playfield;
+
 #[derive(Parser)]
 #[command(version, about, long_about = None)]
 struct Cli {
@@ -12,157 +16,10 @@ struct Cli {
     field_size: usize,
 }
 
-#[derive(PartialEq, Debug, Clone)]
-struct Playfield {
-    fields: Vec<Vec<Field>>,
-    open_fields: Vec<u32>,
-}
-
-#[derive(Clone, PartialEq, Debug)]
-struct Field {
-    possible_values: Vec<u32>,
-    value: Option<u32>,
-}
-
-use std::fmt;
-impl Playfield {
-    fn new(size: usize) -> Playfield {
-        Self {
-            fields: vec![vec![Field::default(); size]; size],
-            open_fields: Vec::<u32>::new(),
-        }
-    }
-}
-
-impl fmt::Display for Playfield {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut result = String::new();
-        for row in &self.fields {
-            for field in row {
-                result += &field.value.unwrap_or_else(|| 0).to_string();
-                result += " ";
-            }
-            result += "\n";
-        }
-        write!(f, "{}", result)
-    }
-}
-
-impl Field {
-    fn default() -> Field {
-        Self {
-            possible_values: Vec::<u32>::new(),
-            value: None,
-        }
-    }
-}
-
 fn main() {
     let cli = Cli::parse();
 
-    let playfield = parse_playfield(&cli.field, cli.field_size);
+    let playfield = Playfield::new(&cli.field, cli.field_size);
 
     println!("Input:\n{}", playfield)
 }
-
-fn parse_playfield(field: &String, field_size: usize) -> Playfield {
-    let mut playfield = Playfield::new(field_size);
-
-    let chars = field.split(" ").collect::<Vec<&str>>();
-
-    if !is_right_field_size(&chars, field_size) {
-        panic!(
-            "Input must have dimension of size {size}x{size}",
-            size = field_size
-        );
-    }
-
-    for row in 0..field_size {
-        for col in 0..field_size {
-            let field = &mut playfield.fields[row][col];
-            let char_field = chars.get(row * field_size + col).unwrap();
-
-            if *char_field == "0" {
-                continue;
-            }
-
-            field.value = Some(char_field.parse().unwrap_or_else(|char_field| {
-                panic!(
-                    "Input must contain only digits followed by space. Disallowed character: {}",
-                    char_field
-                )
-            }));
-        }
-    }
-
-    return playfield;
-}
-
-fn is_right_field_size(field: &Vec<&str>, field_size: usize) -> bool {
-    return field.len() == field_size * field_size;
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    impl Field {
-        fn new(value: u32) -> Field {
-            Self {
-                possible_values: Vec::<u32>::new(),
-                value: Some(value),
-            }
-        }
-    }
-
-    mod parse_field {
-        use super::super::*;
-
-        #[test]
-        fn simple() {
-            let input = "1 2 3 0 0 0 3 2 1";
-            let field_size = 3;
-
-            let playfield = parse_playfield(&input.to_string(), field_size);
-
-            assert_eq!(
-                playfield,
-                Playfield {
-                    fields: vec![
-                        vec![Field::new(1), Field::new(2), Field::new(3)],
-                        vec![Field::default(), Field::default(), Field::default()],
-                        vec![Field::new(3), Field::new(2), Field::new(1)]
-                    ],
-                    open_fields: vec![]
-                }
-            )
-        }
-
-        #[test]
-        #[should_panic(expected = "Input must have dimension of size 2x2")]
-        fn too_long_input() {
-            let input = "1 2 3 0 0 0 3 2 1";
-            let field_size = 2;
-
-            let _ = parse_playfield(&input.to_string(), field_size);
-        }
-
-        #[test]
-        #[should_panic(expected = "Input must have dimension of size 3x3")]
-        fn too_short_input() {
-            let input = "1 2 3";
-            let field_size = 3;
-
-            let _ = parse_playfield(&input.to_string(), field_size);
-        }
-
-        #[test]
-        #[should_panic(expected = "Input must contain only digits followed by space")]
-        fn wrong_character() {
-            let input = "1 2 3 0 0 0 3 2 a";
-            let field_size = 3;
-
-            let _ = parse_playfield(&input.to_string(), field_size);
-        }
-    }
-}