add javaopts

Author: zahash

src/codegen/java.rs

@@ -1,13 +1,89 @@
 use crate::schema_extraction::{FieldType, Structure};
+use clap::{Parser, ValueEnum};
 use std::io::{Error, Write};
 
-pub fn java<W: Write>(schema: &[Structure], out: &mut W) -> Result<(), Error> {
+#[derive(Parser, Debug)]
+pub struct JavaOpts {
+    #[arg(short, long, default_value_t = JavaAccessModifier::Public)]
+    class_access_modifier: JavaAccessModifier,
+
+    #[arg(short, long, default_value_t = JavaAccessModifier::Public)]
+    attribute_access_modifier: JavaAccessModifier,
+
+    #[arg(short, long)]
+    final_attributes: bool,
+
+    #[arg(short, long)]
+    getters: bool,
+
+    #[arg(short, long)]
+    setters: bool,
+}
+
+#[derive(Debug, Clone, ValueEnum)]
+pub enum JavaAccessModifier {
+    Public,
+    Private,
+    Protected,
+    Default,
+}
+
+impl ToString for JavaAccessModifier {
+    fn to_string(&self) -> String {
+        match self {
+            JavaAccessModifier::Public => "public",
+            JavaAccessModifier::Private => "private",
+            JavaAccessModifier::Protected => "protected",
+            JavaAccessModifier::Default => "",
+        }
+        .into()
+    }
+}
+
+pub fn java<W: Write>(schema: &[Structure], opts: JavaOpts, out: &mut W) -> Result<(), Error> {
     for class in schema {
-        writeln!(out, "class {} {{", class.name)?;
+        writeln!(
+            out,
+            "{} class {} {{",
+            opts.class_access_modifier.to_string(),
+            class.name
+        )?;
 
         for field in &class.fields {
             let java_type = field_type_to_java_type(&field.type_);
-            writeln!(out, "    {} {};", java_type, field.name)?;
+            writeln!(
+                out,
+                "    {} {} {} {};",
+                opts.attribute_access_modifier.to_string(),
+                match opts.final_attributes {
+                    true => "final",
+                    false => "",
+                },
+                java_type,
+                field.name
+            )?;
+        }
+
+        if opts.getters {
+            for field in &class.fields {
+                let java_type = field_type_to_java_type(&field.type_);
+                writeln!(
+                    out,
+                    "    public {} get{}() {{ return {}; }}",
+                    java_type, &field.name, &field.name
+                )?;
+            }
+        }
+
+        if opts.setters {
+            for field in &class.fields {
+                let java_type = field_type_to_java_type(&field.type_);
+                writeln!(
+                    out,
+                    "    public void set{}({} {}) {{ this.{} = {}; }}",
+                    &field.name, java_type, &field.name, &field.name, &field.name
+                )?;
+            }
         }
 
         writeln!(out, "}}")?;

src/codegen/mod.rs

@@ -1,3 +1,3 @@
 mod java;
 
-pub use java::java;
+pub use java::{java, JavaOpts};

src/main.rs

@@ -1,6 +1,7 @@
 use std::{fs::File, io::BufReader};
 
-use clap::Parser;
+use clap::{Parser, Subcommand};
+use codegen::JavaOpts;
 use serde_json::Value;
 
 mod codegen;
@@ -11,6 +12,14 @@ struct JSONCodeGen {
     /// json filepath
     #[arg(short, long)]
     filepath: String,
+
+    #[command(subcommand)]
+    lang: LangOpts,
+}
+
+#[derive(Subcommand, Debug)]
+enum LangOpts {
+    Java(JavaOpts),
 }
 
 fn main() -> anyhow::Result<()> {
@@ -22,7 +31,10 @@ fn main() -> anyhow::Result<()> {
     let json: Value = serde_json::from_reader(reader)?;
     let schema = schema_extraction::process(json);
     let mut stdout = std::io::stdout().lock();
-    codegen::java(&schema, &mut stdout)?;
+
+    match args.lang {
+        LangOpts::Java(opts) => codegen::java(&schema, opts, &mut stdout)?,
+    }
 
     Ok(())
 }

src/schema_extraction.rs

@@ -71,21 +71,8 @@ fn determine_type(value: Value, name: String, structs: &mut Vec<Structure>) -> F
         Value::String(_) => FieldType::String,
         Value::Array(arr) => FieldType::Array(Box::new(process_array(arr, name, structs))),
         Value::Object(nested_obj) => {
-            let nested_obj_name = pascal_case(&name);
-            process_object(nested_obj, nested_obj_name.clone(), structs);
-            FieldType::Object(nested_obj_name)
+            process_object(nested_obj, name.clone(), structs);
+            FieldType::Object(name.clone())
         }
     }
 }
-
-fn pascal_case(text: &str) -> String {
-    text.into()
-}
-
-fn camel_case(text: &str) -> String {
-    text.into()
-}
-
-fn snake_case(text: &str) -> String {
-    text.into()
-}