Improve detecting whether default can be derived

src/analyzer.rs

@@ -225,6 +225,7 @@ fn analyze_enum_properties(
         level,
         docs: schema.description.clone(),
         is_enum: true,
+        ..Container::default()
     })
 }
 
@@ -333,6 +334,7 @@ fn extract_container(
         level,
         docs: schema.description.clone(),
         is_enum: false,
+        ..Container::default()
     })
 }
 

src/main.rs

@@ -121,6 +121,12 @@ struct Kopium {
     /// Type used to represent maps via additionalProperties
     #[arg(long, value_enum, default_value_t)]
     map_type: MapType,
+
+    /// Automatically removes #[derive(Default)] from structs that contain fields for which a default can not be automatically derived.
+    ///
+    /// This option only has an effect if `--derive Default` is set.
+    #[arg(long)]
+    smart_derive_elision: bool,
 }
 
 #[derive(Clone, Copy, Debug, Subcommand)]
@@ -246,7 +252,7 @@ impl Kopium {
             }
             self.print_docstr(&s.docs, "");
             if s.is_main_container() {
-                self.print_derives(s);
+                self.print_derives(s, &structs);
                 //root struct gets kube derives unless opted out
                 if !self.hide_kube {
                     println!(
@@ -268,6 +274,12 @@ impl Kopium {
                         if derive.derived_trait == "JsonSchema" {
                             continue;
                         }
+                        if derive.derived_trait == "Default"
+                            && self.smart_derive_elision
+                            && !s.can_derive_default(&structs)
+                        {
+                            continue;
+                        }
                         println!(r#"#[kube(derive="{}")]"#, derive.derived_trait);
                     }
                 }
@@ -277,7 +289,7 @@ impl Kopium {
                     println!("pub struct {} {{", s.name);
                 }
             } else {
-                self.print_derives(s);
+                self.print_derives(s, &structs);
                 let spec_trimmed_name = s.name.as_str().replace(&format!("{}Spec", kind), kind);
                 if s.is_enum {
                     println!("pub enum {} {{", spec_trimmed_name);
@@ -338,23 +350,24 @@ impl Kopium {
         }
     }
 
-    fn print_derives(&self, s: &Container) {
+    fn print_derives(&self, s: &Container, containers: &[Container]) {
         let mut derives = vec!["Serialize", "Deserialize", "Clone", "Debug"];
 
         if s.is_main_container() && !self.hide_kube {
             // CustomResource first for root struct
             derives.insert(0, "CustomResource");
         }
-        if self.builders {
+
+        // TypedBuilder does not work with enums
+        if self.builders && !s.is_enum {
             derives.push("TypedBuilder");
         }
 
         for derive in &self.derive {
-            if s.is_enum && derive.derived_trait == "Default" {
-                // Need to drop Default from enum as this cannot be derived.
-                // Enum defaults need to either be manually derived
-                // or we can insert enum defaults
-                continue;
+            if derive.derived_trait == "Default" {
+                if (self.smart_derive_elision && !s.can_derive_default(containers)) || !s.is_enum {
+                    continue;
+                }
             }
 
             if derive.is_applicable_to(s) && !derives.contains(&derive.derived_trait.as_str()) {

src/output.rs

@@ -1,3 +1,5 @@
+use std::cell::OnceCell;
+
 use heck::{ToPascalCase, ToSnakeCase};
 
 /// All found containers
@@ -16,6 +18,7 @@ pub struct Container {
     pub docs: Option<String>,
     /// Whether this container is an enum
     pub is_enum: bool,
+    pub supports_derive_default: OnceCell<bool>,
 }
 
 /// Output member belonging to an Container
@@ -80,6 +83,45 @@ impl Container {
     pub fn contains_conditions(&self) -> bool {
         self.members.iter().any(|m| m.type_.contains("Vec<Condition>"))
     }
+
+    /// Checks if default is implemented for all props, and if not, returns false
+    pub fn can_derive_default(&self, containers: &[Container]) -> bool {
+        if self.is_enum {
+            // Need to drop Default from enum as this cannot be derived.
+            // Enum defaults need to either be manually derived
+            // or we can insert enum defaults
+            return false;
+        }
+
+        if let Some(can_derive) = self.supports_derive_default.get() {
+            return *can_derive;
+        }
+
+        for m in &self.members {
+            // If the type contains a <, it's a container type. All container types kopium uses right now (Map, Vec, Option) have a default implementation.
+            if !m.type_.contains('<')
+                && m.type_ != "String"
+                && m.type_ != "IntOrString"
+                && m.type_ != "NaiveDate"
+                && m.type_ != "DateTime"
+                // If the first character is lowercase, assume it's a built-in type and skip the check.
+                && m.type_.chars().next().unwrap_or_default().is_uppercase()
+            {
+                if containers
+                    .iter()
+                    .find(|c| c.name == m.type_)
+                    .is_some_and(|c| !c.can_derive_default(containers))
+                {
+                    self.supports_derive_default.set(false).unwrap();
+                    return false;
+                }
+            }
+        }
+
+        // We can't fail here, because if it's set, we always return, and set only fails it the Cell is already set
+        self.supports_derive_default.set(true).unwrap();
+        true
+    }
 }
 
 impl Container {
@@ -247,8 +289,8 @@ mod test {
                 name_only_enum_member("jwksUri"),
                 name_only_enum_member("JwksUri"),
             ],
-            docs: None,
             is_enum: true,
+            ..Container::default()
         };
 
         c.rename();
@@ -272,13 +314,97 @@ mod test {
                 name_only_int_member("jwksUri"),
                 name_only_int_member("JwksUri"),
             ],
-            docs: None,
-            is_enum: false,
+            ..Container::default()
         };
         cs.rename();
         assert_eq!(&cs.members[0].name, "jwks_uri");
         assert_eq!(&cs.members[1].name, "jwks_uri_x");
         assert_eq!(&cs.members[2].name, "jwks_uri_x_x");
         assert_eq!(&cs.members[3].name, "jwks_uri_x_x_x");
     }
+
+    #[test]
+    fn can_derive_default() {
+        let containers = vec![
+            Container {
+                name: "Simple".to_string(),
+                level: 1,
+                ..Container::default()
+            },
+            Container {
+                name: "Enum".to_string(),
+                level: 1,
+                is_enum: true,
+                ..Container::default()
+            },
+            Container {
+                name: "Nested".to_string(),
+                level: 1,
+                members: vec![Member {
+                    name: "simple".to_string(),
+                    type_: "Simple".to_string(),
+                    ..Member::default()
+                }],
+                ..Container::default()
+            },
+            Container {
+                name: "ReferencesEnum".to_string(),
+                level: 1,
+                members: vec![Member {
+                    name: "enum".to_string(),
+                    type_: "Enum".to_string(),
+                    ..Member::default()
+                }],
+                ..Container::default()
+            },
+            Container {
+                name: "ReferencesEnumNested".to_string(),
+                level: 1,
+                members: vec![Member {
+                    name: "references_enum".to_string(),
+                    type_: "ReferencesEnum".to_string(),
+                    ..Member::default()
+                }],
+                ..Container::default()
+            },
+            Container {
+                name: "ReferencesEnumOption".to_string(),
+                level: 1,
+                members: vec![Member {
+                    name: "maybe_enum".to_string(),
+                    type_: "Option<Enum>".to_string(),
+                    ..Member::default()
+                }],
+                ..Container::default()
+            },
+            Container {
+                name: "ReferencesEnumVec".to_string(),
+                level: 1,
+                members: vec![Member {
+                    name: "enum_list".to_string(),
+                    type_: "Vec<Enum>".to_string(),
+                    ..Member::default()
+                }],
+                ..Container::default()
+            },
+            Container {
+                name: "ReferencesEnumNestedOption".to_string(),
+                level: 1,
+                members: vec![Member {
+                    name: "maybe_references_enum".to_string(),
+                    type_: "Option<ReferencesEnum>".to_string(),
+                    ..Member::default()
+                }],
+                ..Container::default()
+            },
+        ];
+        assert!(containers[0].can_derive_default(&containers)); // Simple
+        assert!(!containers[1].can_derive_default(&containers)); // Enum
+        assert!(containers[2].can_derive_default(&containers)); // Nested
+        assert!(!containers[3].can_derive_default(&containers)); // ReferencesEnum
+        assert!(!containers[4].can_derive_default(&containers)); // ReferencesEnumNested
+        assert!(containers[5].can_derive_default(&containers)); // ReferencesEnumOption
+        assert!(containers[6].can_derive_default(&containers)); // ReferencesEnumVec
+        assert!(containers[7].can_derive_default(&containers)); // ReferencesEnumNestedOption
+    }
 }