fn generate_value_for_schema()

in compiler-rs/openapi_to_clients_schema/src/types.rs [463:524]

• 57 lines of code
• 3 McCabe index (conditional complexity)

fn generate_value_for_schema(
    open_api: &OpenAPI,
    schema: &Schema,
    id_gen: impl Fn() -> String,
    types: &mut Types,
) -> anyhow::Result<ValueOf> {
    use openapiv3::SchemaKind::*;
    match &schema.schema_kind {
        Type(typ) => {
            use openapiv3::Type::*;
            match typ {
                String(string) if string.enumeration.is_empty() => Ok((&builtins::STRING).into()),
                String(_) => {
                    let type_name = generate_type_for_schema(open_api, &id_gen(), schema, types)?;
                    Ok(type_name.into())
                }
                Number(_) => {
                    // TODO: choose float/double depending on min/max values
                    // (see also generate_schema_kind_type)
                    Ok((&builtins::DOUBLE).into())
                }
                Integer(_) => {
                    // TODO: choose int/long depending on min/max values
                    // (see also generate_schema_kind_type)
                    Ok((&builtins::LONG).into())
                }
                Object(_) => {
                    let type_name = generate_type_for_schema(open_api, &id_gen(), schema, types)?;
                    Ok(type_name.into())
                }
                Array(array) => {
                    let item = array
                        .items
                        .as_ref()
                        .ok_or(anyhow!("Array type in '{}' has no items", id_gen()))?;
                    let item = generate_value_of(open_api, item.into(), id_gen, types)?;
                    Ok(ValueOf::ArrayOf(ArrayOf { value: Box::new(item) }))
                }
                Boolean { .. } => Ok((&builtins::BOOLEAN).into()),
            }
        }
        // Do not factorize below to keep exhaustiveness, if some specific handling is needed/possible
        OneOf { .. } => {
            let type_name = generate_type_for_schema(open_api, &id_gen(), schema, types)?;
            Ok(type_name.into())
        }
        AllOf { .. } => {
            let type_name = generate_type_for_schema(open_api, &id_gen(), schema, types)?;
            Ok(type_name.into())
        }
        AnyOf { .. } => {
            let type_name = generate_type_for_schema(open_api, &id_gen(), schema, types)?;
            Ok(type_name.into())
        }
        Not { .. } => Ok((&builtins::VOID).into()),
        Any(AnySchema { typ: Some(typ), .. }) if typ == "null" => Ok((&builtins::NULL).into()),
        Any(_) => {
            let type_name = generate_type_for_schema(open_api, &id_gen(), schema, types)?;
            Ok(type_name.into())
        }
    }
}