From 413ae710b16fcc05f8fad06ba9f4bf5e9cf14e3a Mon Sep 17 00:00:00 2001
From: a2x <45197573+a2x@users.noreply.github.com>
Date: Fri, 29 Mar 2024 18:26:44 +1000
Subject: [PATCH] Modify JSON file generation for easier parsing

---
 src/output/buttons.rs    | 14 ++++++
 src/output/interfaces.rs | 17 ++++++++
 src/output/mod.rs        | 37 +++++++++++-----
 src/output/offsets.rs    | 17 ++++++++
 src/output/schemas.rs    | 92 +++++++++++++++++++++++++++++++++++++---
 5 files changed, 160 insertions(+), 17 deletions(-)

diff --git a/src/output/buttons.rs b/src/output/buttons.rs
index 288840b..e8f65e0 100644
--- a/src/output/buttons.rs
+++ b/src/output/buttons.rs
@@ -1,3 +1,4 @@
+use std::collections::BTreeMap;
 use std::env;
 use std::fmt::Write;
 
@@ -53,6 +54,19 @@ impl CodeGen for Vec<Button> {
         })
     }
 
+    fn to_json(&self, _results: &Results, _indent_size: usize) -> Result<String> {
+        let content = {
+            let buttons: BTreeMap<_, _> = self
+                .iter()
+                .map(|button| (&button.name, button.value))
+                .collect();
+
+            BTreeMap::from_iter([(get_module_name(), buttons)])
+        };
+
+        serde_json::to_string_pretty(&content).map_err(Into::into)
+    }
+
     fn to_rs(&self, results: &Results, indent_size: usize) -> Result<String> {
         self.write_content(results, indent_size, |fmt| {
             writeln!(fmt, "#![allow(non_upper_case_globals, unused)]\n")?;
diff --git a/src/output/interfaces.rs b/src/output/interfaces.rs
index 0589cdd..f124c05 100644
--- a/src/output/interfaces.rs
+++ b/src/output/interfaces.rs
@@ -1,3 +1,4 @@
+use std::collections::BTreeMap;
 use std::fmt::Write;
 
 use heck::{AsPascalCase, AsSnakeCase};
@@ -73,6 +74,22 @@ impl CodeGen for InterfaceMap {
         })
     }
 
+    fn to_json(&self, _results: &Results, _indent_size: usize) -> Result<String> {
+        let content: BTreeMap<_, _> = self
+            .iter()
+            .map(|(module_name, ifaces)| {
+                let ifaces: BTreeMap<_, _> = ifaces
+                    .iter()
+                    .map(|iface| (&iface.name, iface.value))
+                    .collect();
+
+                (module_name, ifaces)
+            })
+            .collect();
+
+        serde_json::to_string_pretty(&content).map_err(Into::into)
+    }
+
     fn to_rs(&self, results: &Results, indent_size: usize) -> Result<String> {
         self.write_content(results, indent_size, |fmt| {
             writeln!(fmt, "#![allow(non_upper_case_globals, unused)]\n")?;
diff --git a/src/output/mod.rs b/src/output/mod.rs
index eacbd1b..265beeb 100644
--- a/src/output/mod.rs
+++ b/src/output/mod.rs
@@ -30,20 +30,28 @@ enum Item<'a> {
 }
 
 impl<'a> Item<'a> {
-    fn generate(&self, results: &Results, indent_size: usize, file_type: &str) -> Result<String> {
-        match file_type {
+    fn generate(&self, results: &Results, indent_size: usize, file_ext: &str) -> Result<String> {
+        match file_ext {
             "cs" => self.to_cs(results, indent_size),
             "hpp" => self.to_hpp(results, indent_size),
+            "json" => self.to_json(results, indent_size),
             "rs" => self.to_rs(results, indent_size),
-            "json" => serde_json::to_string_pretty(self).map_err(Into::into),
             _ => unreachable!(),
         }
     }
 }
 
 trait CodeGen {
+    /// Converts an [`Item`] to formatted C# code.
     fn to_cs(&self, results: &Results, indent_size: usize) -> Result<String>;
+
+    /// Converts an [`Item`] to formatted C++ code.
     fn to_hpp(&self, results: &Results, indent_size: usize) -> Result<String>;
+
+    /// Converts an [`Item`] to formatted JSON.
+    fn to_json(&self, results: &Results, indent_size: usize) -> Result<String>;
+
+    /// Converts an [`Item`] to formatted Rust code.
     fn to_rs(&self, results: &Results, indent_size: usize) -> Result<String>;
 
     fn write_content<F>(&self, results: &Results, indent_size: usize, callback: F) -> Result<String>
@@ -80,6 +88,15 @@ impl<'a> CodeGen for Item<'a> {
         }
     }
 
+    fn to_json(&self, results: &Results, indent_size: usize) -> Result<String> {
+        match self {
+            Item::Buttons(buttons) => buttons.to_json(results, indent_size),
+            Item::Interfaces(interfaces) => interfaces.to_json(results, indent_size),
+            Item::Offsets(offsets) => offsets.to_json(results, indent_size),
+            Item::Schemas(schemas) => schemas.to_json(results, indent_size),
+        }
+    }
+
     fn to_rs(&self, results: &Results, indent_size: usize) -> Result<String> {
         match self {
             Item::Buttons(buttons) => buttons.to_rs(results, indent_size),
@@ -138,13 +155,13 @@ impl Results {
         ];
 
         // TODO: Make this user-configurable.
-        let file_types = ["cs", "hpp", "json", "rs"];
+        let file_exts = ["cs", "hpp", "json", "rs"];
 
         for (file_name, item) in &items {
-            for &file_type in &file_types {
-                let content = item.generate(self, indent_size, file_type)?;
+            for ext in file_exts {
+                let content = item.generate(self, indent_size, ext)?;
 
-                self.dump_file(out_dir.as_ref(), file_name, file_type, &content)?;
+                self.dump_file(out_dir.as_ref(), file_name, ext, &content)?;
             }
         }
 
@@ -157,12 +174,10 @@ impl Results {
         &self,
         out_dir: P,
         file_name: &str,
-        file_type: &str,
+        file_ext: &str,
         content: &str,
     ) -> Result<()> {
-        let file_path = out_dir
-            .as_ref()
-            .join(format!("{}.{}", file_name, file_type));
+        let file_path = out_dir.as_ref().join(format!("{}.{}", file_name, file_ext));
 
         fs::write(file_path, content)?;
 
diff --git a/src/output/offsets.rs b/src/output/offsets.rs
index a34aded..d23eaac 100644
--- a/src/output/offsets.rs
+++ b/src/output/offsets.rs
@@ -1,3 +1,4 @@
+use std::collections::BTreeMap;
 use std::fmt::Write;
 
 use heck::{AsPascalCase, AsSnakeCase};
@@ -73,6 +74,22 @@ impl CodeGen for OffsetMap {
         })
     }
 
+    fn to_json(&self, _results: &Results, _indent_size: usize) -> Result<String> {
+        let content: BTreeMap<_, _> = self
+            .iter()
+            .map(|(module_name, offsets)| {
+                let offsets: BTreeMap<_, _> = offsets
+                    .iter()
+                    .map(|offset| (&offset.name, offset.value))
+                    .collect();
+
+                (module_name, offsets)
+            })
+            .collect();
+
+        serde_json::to_string_pretty(&content).map_err(Into::into)
+    }
+
     fn to_rs(&self, results: &Results, indent_size: usize) -> Result<String> {
         self.write_content(results, indent_size, |fmt| {
             writeln!(fmt, "#![allow(non_upper_case_globals, unused)]\n")?;
diff --git a/src/output/schemas.rs b/src/output/schemas.rs
index 86d963a..53d6f4f 100644
--- a/src/output/schemas.rs
+++ b/src/output/schemas.rs
@@ -1,7 +1,10 @@
+use std::collections::BTreeMap;
 use std::fmt::{self, Write};
 
 use heck::{AsPascalCase, AsSnakeCase};
 
+use serde_json::json;
+
 use super::{format_module_name, sanitize_name, CodeGen, Formatter, Results, SchemaMap};
 
 use crate::analysis::ClassMetadata;
@@ -37,13 +40,13 @@ impl CodeGen for SchemaMap {
                                 fmt.block(
                                     &format!("public enum {} : {}", sanitize_name(&enum_.name), ty),
                                     |fmt| {
-                                        let members = enum_
+                                        let members: Vec<_> = enum_
                                             .members
                                             .iter()
                                             .map(|member| {
                                                 format!("{} = {}", member.name, member.value)
                                             })
-                                            .collect::<Vec<_>>()
+                                            .collect()
                                             .join(",\n");
 
                                         writeln!(fmt, "{}", members)
@@ -125,13 +128,13 @@ impl CodeGen for SchemaMap {
                                             ty
                                         ),
                                         |fmt| {
-                                            let members = enum_
+                                            let members: Vec<_> = enum_
                                                 .members
                                                 .iter()
                                                 .map(|member| {
                                                     format!("{} = {}", member.name, member.value)
                                                 })
-                                                .collect::<Vec<_>>()
+                                                .collect()
                                                 .join(",\n");
 
                                             writeln!(fmt, "{}", members)
@@ -180,6 +183,83 @@ impl CodeGen for SchemaMap {
         })
     }
 
+    fn to_json(&self, _results: &Results, _indent_size: usize) -> Result<String> {
+        let content: BTreeMap<_, _> = self
+            .iter()
+            .map(|(module_name, (classes, enums))| {
+                let classes: BTreeMap<_, _> = classes
+                    .iter()
+                    .map(|class| {
+                        let fields: BTreeMap<_, _> = class
+                            .fields
+                            .iter()
+                            .map(|field| (&field.name, field.offset))
+                            .collect();
+
+                        let metadata: Vec<_> = class
+                            .metadata
+                            .iter()
+                            .map(|metadata| match metadata {
+                                ClassMetadata::NetworkChangeCallback { name } => json!({
+                                    "type": "NetworkChangeCallback",
+                                    "name": name,
+                                }),
+                                ClassMetadata::NetworkVarNames { name, ty } => json!({
+                                    "type": "NetworkVarNames",
+                                    "name": name,
+                                    "ty": ty,
+                                }),
+                                ClassMetadata::Unknown { name } => json!({
+                                    "type": "Unknown",
+                                    "name": name,
+                                }),
+                            })
+                            .collect();
+
+                        (
+                            sanitize_name(&class.name),
+                            json!({
+                                "parent": class.parent.as_ref().map(|parent| &parent.name),
+                                "fields": fields,
+                                "metadata": metadata
+                            }),
+                        )
+                    })
+                    .collect();
+
+                let enums: BTreeMap<_, _> = enums
+                    .iter()
+                    .map(|enum_| {
+                        let members: BTreeMap<_, _> = enum_
+                            .members
+                            .iter()
+                            .map(|member| (&member.name, member.value))
+                            .collect();
+
+                        (
+                            sanitize_name(&enum_.name),
+                            json!({
+                                "alignment": enum_.alignment,
+                                "type": enum_.ty,
+                                "members": members,
+                            }),
+                        )
+                    })
+                    .collect();
+
+                (
+                    module_name,
+                    json!({
+                        "classes": classes,
+                        "enums": enums,
+                    }),
+                )
+            })
+            .collect();
+
+        serde_json::to_string_pretty(&content).map_err(Into::into)
+    }
+
     fn to_rs(&self, results: &Results, indent_size: usize) -> Result<String> {
         self.write_content(results, indent_size, |fmt| {
             writeln!(fmt, "#![allow(non_upper_case_globals, unused)]\n")?;
@@ -215,13 +295,13 @@ impl CodeGen for SchemaMap {
                                         |fmt| {
                                             // TODO: Handle the case where multiple members share
                                             // the same value.
-                                            let members = enum_
+                                            let members: Vec<_> = enum_
                                                 .members
                                                 .iter()
                                                 .map(|member| {
                                                     format!("{} = {}", member.name, member.value)
                                                 })
-                                                .collect::<Vec<_>>()
+                                                .collect()
                                                 .join(",\n");
 
                                             writeln!(fmt, "{}", members)