config: add flag to output derap'd configs as json (#1021)

* Change config visibility

* add json formatting of configs

* clippy suggestions

* change to feature flag locked derive

* change feature flag to be less overarching

* add custom serialization of fields

* format

* Apply suggestions from code review

Co-authored-by: Copilot <[email protected]>

* fmt, fix copilot being wrong

* add __parent

* and fmt

---------

Co-authored-by: BrettMayson <[email protected]>
Co-authored-by: Copilot <[email protected]>

Author: 3 people

Cargo.lock

@@ -21,7 +21,7 @@ bench = false
 [dependencies]
 hemtt-common = { path = "../libs/common" }
 
-hemtt-config = { path = "../libs/config" }
+hemtt-config = { path = "../libs/config", features=["serde"] }
 hemtt-p3d = { path = "../libs/p3d" }
 hemtt-paa = { path = "../libs/paa" }
 hemtt-pbo = { path = "../libs/pbo" }

bin/Cargo.toml

@@ -1,32 +1,60 @@
+use serde_json;
 use std::{io::Write as _, path::PathBuf};
 
 use hemtt_config::rapify::Derapify;
 
 use crate::Error;
 
+#[derive(Debug, Copy, Clone, clap::ValueEnum)]
+pub enum OutputFormat {
+    Debin,
+    Json,
+    JsonPretty,
+}
+
+impl OutputFormat {
+    fn default_extension(&self) -> &str {
+        match self {
+            Self::Debin => "cpp",
+            Self::JsonPretty | Self::Json => "json",
+        }
+    }
+}
+
 #[derive(clap::Args)]
 #[allow(clippy::module_name_repetitions)]
 pub struct DerapifyArgs {
     /// file to derapify
     pub(crate) file: String,
+    /// output format
+    #[arg(short = 'f', long = "format", default_value = "debin")]
+    pub(crate) output_format: OutputFormat,
     /// output file
     pub(crate) output: Option<String>,
 }
 
 /// Derapify a config file
-pub fn derapify(path: &PathBuf, output: Option<&str>) -> Result<(), Error> {
+pub fn derapify(path: &PathBuf, output: Option<&str>, format: OutputFormat) -> Result<(), Error> {
     let mut file = std::fs::File::open(path)?;
     let config = hemtt_config::Config::derapify(&mut file)?;
     let output = output.map_or_else(
         || {
             let mut path = path.clone();
-            path.set_extension("cpp");
+            path.set_extension(format.default_extension());
             path
         },
         PathBuf::from,
     );
     let mut output = std::fs::File::create(output)?;
-    output.write_all(config.to_string().as_bytes())?;
+    match format {
+        OutputFormat::Debin => output.write_all(config.to_string().as_bytes())?,
+        OutputFormat::Json => {
+            output.write_all(serde_json::to_string(&config)?.as_bytes())?;
+        }
+        OutputFormat::JsonPretty => {
+            output.write_all(serde_json::to_string_pretty(&config)?.as_bytes())?;
+        }
+    }
     output.flush()?;
     Ok(())
 }

bin/src/utils/config/derapify.rs

@@ -32,9 +32,11 @@ enum Subcommands {
 /// If the args are not present from clap
 pub fn execute(cmd: &Command) -> Result<(), Error> {
     match &cmd.commands {
-        Subcommands::Derapify(args) => {
-            derapify::derapify(&PathBuf::from(&args.file), args.output.as_deref())
-        }
+        Subcommands::Derapify(args) => derapify::derapify(
+            &PathBuf::from(&args.file),
+            args.output.as_deref(),
+            args.output_format,
+        ),
         Subcommands::Inspect(args) => inspect::inspect(&PathBuf::from(&args.config)),
     }
 }

bin/src/utils/config/mod.rs

@@ -25,7 +25,10 @@ lsp-types = { workspace = true }
 toml = { workspace = true }
 vfs = { workspace = true }
 
+serde = { version = "1.0.219", features = ["derive"], optional = true }
+
 [dev-dependencies]
 hemtt-preprocessor = { path = "../preprocessor" }
 insta = { workspace = true }
 paste = { workspace = true }
+

libs/config/Cargo.toml

@@ -22,3 +22,40 @@ pub enum Item {
     /// An invalid value
     Invalid(Range<usize>),
 }
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for Array {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeSeq;
+        let mut state = serializer.serialize_seq(Some(self.items.len()))?;
+        for item in &self.items {
+            state.serialize_element(&item)?;
+        }
+        state.end()
+    }
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for Item {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            Self::Str(str) => str.serialize(serializer),
+            Self::Number(number) => number.serialize(serializer),
+            Self::Array(items) => {
+                use serde::ser::SerializeSeq;
+                let mut state = serializer.serialize_seq(Some(items.len()))?;
+                for item in items {
+                    state.serialize_element(item)?;
+                }
+                state.end()
+            }
+            Self::Invalid(_) => serializer.serialize_none(),
+        }
+    }
+}

libs/config/src/model/array.rs

@@ -74,3 +74,33 @@ impl Class {
         }
     }
 }
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for Class {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            Self::Local { properties, .. } | Self::Root { properties } => {
+                use serde::ser::SerializeMap;
+                let mut state = serializer.serialize_map(Some(properties.len()))?;
+                if let Self::Local { parent, .. } = self
+                    && let Some(parent) = parent
+                {
+                    state.serialize_entry("__parent", parent.as_str())?;
+                }
+                for property in properties {
+                    state.serialize_entry(property.name().as_str(), property)?;
+                }
+                state.end()
+            }
+            Self::External { name } => {
+                use serde::ser::SerializeMap;
+                let mut state = serializer.serialize_map(Some(1))?;
+                state.serialize_entry(name.as_str(), &{})?;
+                state.end()
+            }
+        }
+    }
+}

libs/config/src/model/class.rs

@@ -51,3 +51,13 @@ impl Config {
         patches
     }
 }
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for Config {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        self.to_class().serialize(serializer)
+    }
+}

libs/config/src/model/config.rs

@@ -6,3 +6,13 @@ pub struct Expression {
     pub(crate) value: String,
     pub(crate) span: Range<usize>,
 }
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for Expression {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&self.value)
+    }
+}

libs/config/src/model/expression.rs

@@ -79,3 +79,17 @@ impl Number {
         }
     }
 }
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for Number {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            Self::Int32 { value, .. } => serializer.serialize_i32(*value),
+            Self::Int64 { value, .. } => serializer.serialize_i64(*value),
+            Self::Float32 { value, .. } => serializer.serialize_f32(*value),
+        }
+    }
+}