From 8938f981999224996dd107e4d2560b1b8b71841a Mon Sep 17 00:00:00 2001
From: jutty <j@jutty.dev>
Date: Tue, 9 Dec 2025 23:45:30 -0300
Subject: [PATCH] Split graph population function into three

---
 src/formats.rs | 135 ++++++++++++++++++++++++++++---------------------
 1 file changed, 76 insertions(+), 59 deletions(-)

diff --git a/src/formats.rs b/src/formats.rs
index 3e434c5..5c7612e 100644
--- a/src/formats.rs
+++ b/src/formats.rs
@@ -2,6 +2,82 @@ use std::collections::HashMap;
 
 use crate::types::*;
 
+pub fn populate_graph() -> Graph {
+
+    let toml_source = match std::fs::read_to_string("./static/graph.toml") {
+        Ok(s) => s,
+        Err(e) => format!("Error: {e}"),
+    };
+    let graph = deserialize_graph(Format::Toml, &toml_source);
+
+    let nodes = modulate_nodes(graph.nodes.clone());
+
+    Graph {
+        nodes: nodes.clone(),
+        incoming: make_incoming(nodes.clone()),
+        ..graph
+    }
+}
+
+fn modulate_nodes(old_nodes: HashMap<String, Node>) -> HashMap<String, Node> {
+
+    let mut nodes: HashMap<String, Node> = HashMap::new();
+
+    for (key, node) in old_nodes.iter() {
+
+        let connections = node.connections.clone().unwrap_or_default();
+        let mut vec = connections.clone();
+
+        for (i, edge) in connections.iter().enumerate() {
+
+            let mut new_edge = edge.clone();
+
+            // Populate empty "from" IDs in edges with node's ID
+            if edge.from == "" {
+                new_edge.from = key.to_string();
+            }
+
+            // Flag detached edges
+            if ! old_nodes.contains_key(&edge.to) {
+                new_edge.detached = true;
+            }
+
+            vec[i] = new_edge;
+
+        }
+
+        let new_node = Node {
+            connections: Some(vec),
+            ..node.clone()
+        };
+        nodes.insert(key.to_string(), new_node);
+    }
+
+    nodes
+}
+
+// Construct a HashMap with incoming connections (reversed edges)
+fn make_incoming(nodes: HashMap<String, Node>) -> HashMap<String, Vec<Edge>> {
+
+    let mut incoming: HashMap<String, Vec<Edge>> = HashMap::new();
+    for node in nodes.clone().into_values() {
+
+        let empty_vec: Vec<Edge> = vec![];
+        for edge in node.connections.clone().unwrap_or_default().iter() {
+
+            let vec = incoming.get(&edge.to.clone()).unwrap_or(&empty_vec);
+            if vec.contains(edge) {
+                vec.clone().extend_from_slice(&[edge.clone()]);
+                incoming.insert(edge.to.clone(), vec.clone());
+            } else {
+                incoming.insert(edge.to.clone(), vec![edge.clone()]);
+            }
+        }
+    }
+
+    incoming
+}
+
 pub enum Format {
     Toml,
     Json
@@ -39,63 +115,4 @@ pub fn deserialize_graph(in_format: Format, serial: &String) -> Graph {
     }
 }
 
-pub fn populate_graph() -> Graph {
-    let toml_source = match std::fs::read_to_string("./static/graph.toml") {
-        Ok(s) => s,
-        Err(e) => format!("Error: {e}"),
-    };
-    let graph = deserialize_graph(Format::Toml, &toml_source);
-    let mut new_nodes: HashMap<String, Node> = HashMap::new();
-    let mut incoming: HashMap<String, Vec<Edge>> = HashMap::new();
 
-    for (key, node) in graph.nodes.iter() {
-
-        let connections = node.connections.clone().unwrap_or_default();
-        let mut vec = connections.clone();
-
-        for (i, edge) in connections.iter().enumerate() {
-
-            let mut new_edge = edge.clone();
-
-            if edge.from == "" {
-                new_edge.from = key.to_string();
-            }
-
-            if ! graph.nodes.contains_key(&edge.to) {
-                new_edge.detached = true;
-            }
-
-            vec[i] = new_edge;
-
-        }
-
-        let new_node = Node {
-            connections: Some(vec),
-            ..node.clone()
-        };
-        new_nodes.insert(key.to_string(), new_node);
-    }
-
-    // Construct a HashMap with incoming connections (reversed edges)
-    for node in new_nodes.clone().into_values() {
-
-        let empty_vec: Vec<Edge> = vec![];
-        for edge in node.connections.clone().unwrap_or_default().iter() {
-
-            let vec = incoming.get(&edge.to.clone()).unwrap_or(&empty_vec);
-            if vec.contains(edge) {
-                vec.clone().extend_from_slice(&[edge.clone()]);
-                incoming.insert(edge.to.clone(), vec.clone());
-            } else {
-                incoming.insert(edge.to.clone(), vec![edge.clone()]);
-            }
-        }
-    }
-
-    Graph {
-        nodes: new_nodes,
-        incoming: incoming,
-        ..graph
-    }
-
-}