use inferred union variant names in more places (#894)

Author: arlyon

typify-impl/src/enums.rs

@@ -609,7 +609,14 @@ impl TypeSpace {
             // account for types such as Uuid whose names come from outside of
             // the schema... but you can't win them all.
             .map(schema_is_named)
+            // Fall back to `VariantN` naming if any variants do not have names
+            // inferred.
             .collect::<Option<Vec<_>>>()
+            // Fall back to `VariantN` naming if any variants have the same
+            // name.
+            .filter(|variant_names| {
+                variant_names.len() == variant_names.iter().collect::<HashSet<_>>().len()
+            })
             // Prune the common prefixes from all variant names. If this
             // results in any of them being empty, we don't use these names.
             .and_then(|variant_names| {

typify-impl/src/util.rs

@@ -2,6 +2,7 @@
 
 use std::collections::{BTreeMap, BTreeSet, HashSet};
 
+use heck::ToPascalCase;
 use log::debug;
 use schemars::schema::{
     ArrayValidation, InstanceType, Metadata, ObjectValidation, Schema, SchemaObject, SingleOrVec,
@@ -622,6 +623,22 @@ pub(crate) fn schema_is_named(schema: &Schema) -> Option<String> {
             extensions: _,
         }) => singleton_subschema(subschemas).and_then(schema_is_named),
 
+        // Best-effort fallback for things with raw types that can be easily inferred
+        Schema::Object(SchemaObject {
+            instance_type: Some(SingleOrVec::Single(single)),
+            format,
+            ..
+        }) => match (**single, format.as_deref()) {
+            (_, Some(format)) => Some(format.to_pascal_case()),
+            (InstanceType::Boolean, _) => Some("Boolean".to_string()),
+            (InstanceType::Integer, _) => Some("Integer".to_string()),
+            (InstanceType::Number, _) => Some("Number".to_string()),
+            (InstanceType::String, _) => Some("String".to_string()),
+            (InstanceType::Array, _) => Some("Array".to_string()),
+            (InstanceType::Object, _) => Some("Object".to_string()),
+            (InstanceType::Null, _) => Some("Null".to_string()),
+        },
+
         _ => None,
     }?;
 

typify-impl/src/value.rs

@@ -1089,7 +1089,7 @@ mod tests {
                 .map(|x| x.to_string()),
             Some(
                 quote! {
-                    super::Test::Variant0
+                    super::Test::Null
                 }
                 .to_string()
             )
@@ -1100,7 +1100,7 @@ mod tests {
                 .map(|x| x.to_string()),
             Some(
                 quote! {
-                    super::Test::Variant1("xx".to_string(), "yy".to_string())
+                    super::Test::Array("xx".to_string(), "yy".to_string())
                 }
                 .to_string()
             )
@@ -1117,7 +1117,7 @@ mod tests {
                 .map(|x| x.to_string()),
             Some(
                 quote! {
-                    super::Test::Variant2 {
+                    super::Test::Object {
                         cc: "xx".to_string(),
                         dd: "yy".to_string()
                     }
@@ -1147,7 +1147,7 @@ mod tests {
                 .map(|x| x.to_string()),
             Some(
                 quote! {
-                    Test::Variant0
+                    Test::Null
                 }
                 .to_string()
             )
@@ -1158,7 +1158,7 @@ mod tests {
                 .map(|x| x.to_string()),
             Some(
                 quote! {
-                    Test::Variant1("xx".to_string(), "yy".to_string())
+                    Test::Array("xx".to_string(), "yy".to_string())
                 }
                 .to_string()
             )
@@ -1175,7 +1175,7 @@ mod tests {
                 .map(|x| x.to_string()),
             Some(
                 quote! {
-                    Test::Variant2 {
+                    Test::Object {
                         cc: "xx".to_string(),
                         dd: "yy".to_string()
                     }