From 58186bb96e38b92e426e75e08b0e0c95d05d319c Mon Sep 17 00:00:00 2001
From: metamuffin <metamuffin@disroot.org>
Date: Thu, 13 Mar 2025 19:50:50 +0100
Subject: main file finder helper

---
 src/bin/typegraph.rs | 88 +++++++++++++++++++++++++---------------------------
 1 file changed, 42 insertions(+), 46 deletions(-)

(limited to 'src/bin/typegraph.rs')

diff --git a/src/bin/typegraph.rs b/src/bin/typegraph.rs
index 79c096b..b8e26d2 100644
--- a/src/bin/typegraph.rs
+++ b/src/bin/typegraph.rs
@@ -17,58 +17,54 @@ fn main() -> anyhow::Result<()> {
     let filter_prims = args().any(|a| a == "no_primitives");
 
     let mut edges = BTreeSet::new();
-    for node in fs.nodes().to_vec() {
-        if node.name.ends_with(".resource") || node.name.ends_with(".resS") {
-            continue;
-        }
-        let mut cab = fs.read(&node)?;
-        let file = read_serialized_file(&mut cab)?;
+    let node = fs.find_main_file().unwrap().to_owned();
+    let mut cab = fs.read(&node)?;
+    let file = read_serialized_file(&mut cab)?;
 
-        for ob in file.objects {
-            let typetree = if ob.type_id < 0 {
-                unimplemented!()
-            } else {
-                &file.types[ob.type_id as usize]
-            };
-            fn print_types(
-                edges: &mut BTreeSet<(String, String)>,
-                filter_prims: bool,
-                tt: TypeTreeNode,
-            ) {
-                for c in tt.children {
-                    let mut c = vec![c];
-                    loop {
-                        let mut nc = Vec::new();
-                        let mut f = false;
-                        for mut c in c {
-                            if let Some(inner) = c.type_string.strip_prefix("PPtr<") {
-                                c.type_string = inner.strip_suffix(">").unwrap().to_owned();
-                                f = true;
-                            } else if matches!(c.type_string.as_str(), "Array" | "pair" | "map") {
-                                nc.extend(c.children);
-                                f = true
-                            } else {
-                                nc.push(c);
-                            };
-                        }
-                        c = nc;
-                        if !f {
-                            break;
-                        }
+    for ob in file.objects {
+        let typetree = if ob.type_id < 0 {
+            unimplemented!()
+        } else {
+            &file.types[ob.type_id as usize]
+        };
+        fn print_types(
+            edges: &mut BTreeSet<(String, String)>,
+            filter_prims: bool,
+            tt: TypeTreeNode,
+        ) {
+            for c in tt.children {
+                let mut c = vec![c];
+                loop {
+                    let mut nc = Vec::new();
+                    let mut f = false;
+                    for mut c in c {
+                        if let Some(inner) = c.type_string.strip_prefix("PPtr<") {
+                            c.type_string = inner.strip_suffix(">").unwrap().to_owned();
+                            f = true;
+                        } else if matches!(c.type_string.as_str(), "Array" | "pair" | "map") {
+                            nc.extend(c.children);
+                            f = true
+                        } else {
+                            nc.push(c);
+                        };
+                    }
+                    c = nc;
+                    if !f {
+                        break;
                     }
-                    for c in c {
-                        if filter_prims && is_primitive(&c.type_string) {
-                            continue;
-                        }
-                        edges.insert((tt.type_string.to_owned(), c.type_string.to_owned()));
-                        print_types(edges, filter_prims, c);
+                }
+                for c in c {
+                    if filter_prims && is_primitive(&c.type_string) {
+                        continue;
                     }
+                    edges.insert((tt.type_string.to_owned(), c.type_string.to_owned()));
+                    print_types(edges, filter_prims, c);
                 }
             }
+        }
 
-            if let Some(tree) = &typetree.type_tree {
-                print_types(&mut edges, filter_prims, tree.clone());
-            }
+        if let Some(tree) = &typetree.type_tree {
+            print_types(&mut edges, filter_prims, tree.clone());
         }
     }
     let nodes = edges
-- 
cgit v1.2.3-70-g09d2