VienDesu/schemars
3
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Set additionalProperties to false on enums where appropriate

Browse source
This commit is contained in:
Graham Esau 2021-03-20 18:45:29 +00:00
parent 3a7d7ad905
commit 6a3bba1e86
12 changed files with 727 additions and 31 deletions
Download patch file Download diff file Expand all files Collapse all files

70
schemars_derive/src/schema_exprs.rs
View file

@ -9,7 +9,11 @@ pub fn expr_for_container(cont: &Container) -> TokenStream {
Data::Struct(Style::Unit, _) => expr_for_unit_struct(),
Data::Struct(Style::Newtype, fields) => expr_for_newtype_struct(&fields[0]),
Data::Struct(Style::Tuple, fields) => expr_for_tuple_struct(fields),
Data::Struct(Style::Struct, fields) => expr_for_struct(fields, Some(&cont.serde_attrs)),
Data::Struct(Style::Struct, fields) => expr_for_struct(
fields,
cont.serde_attrs.default(),
cont.serde_attrs.deny_unknown_fields(),
),
Data::Enum(variants) => expr_for_enum(variants, &cont.serde_attrs),
};
@ -70,19 +74,26 @@ pub fn type_for_schema(field: &Field, local_id: usize) -> (syn::Type, Option<Tok
}
fn expr_for_enum(variants: &[Variant], cattrs: &serde_attr::Container) -> TokenStream {
let deny_unknown_fields = cattrs.deny_unknown_fields();
let variants = variants
.iter()
.filter(|v| !v.serde_attrs.skip_deserializing());
match cattrs.tag() {
TagType::External => expr_for_external_tagged_enum(variants),
TagType::None => expr_for_untagged_enum(variants),
TagType::Internal { tag } => expr_for_internal_tagged_enum(variants, tag),
TagType::Adjacent { tag, content } => expr_for_adjacent_tagged_enum(variants, tag, content),
TagType::External => expr_for_external_tagged_enum(variants, deny_unknown_fields),
TagType::None => expr_for_untagged_enum(variants, deny_unknown_fields),
TagType::Internal { tag } => {
expr_for_internal_tagged_enum(variants, tag, deny_unknown_fields)
}
TagType::Adjacent { tag, content } => {
expr_for_adjacent_tagged_enum(variants, tag, content, deny_unknown_fields)
}
}
}
fn expr_for_external_tagged_enum<'a>(
variants: impl Iterator<Item = &'a Variant<'a>>,
deny_unknown_fields: bool,
) -> TokenStream {
let (unit_variants, complex_variants): (Vec<_>, Vec<_>) =
variants.partition(|v| v.is_unit() && v.attrs.with.is_none());
@ -104,7 +115,8 @@ fn expr_for_external_tagged_enum<'a>(
schemas.extend(complex_variants.into_iter().map(|variant| {
let name = variant.name();
let sub_schema = expr_for_untagged_enum_variant(variant);
let sub_schema = expr_for_untagged_enum_variant(variant, deny_unknown_fields);
let schema_expr = schema_object(quote! {
instance_type: Some(schemars::schema::InstanceType::Object.into()),
object: Some(Box::new(schemars::schema::ObjectValidation {
@ -118,6 +130,7 @@ fn expr_for_external_tagged_enum<'a>(
required.insert(#name.to_owned());
required
},
additional_properties: Some(Box::new(false.into())),
..Default::default()
})),
});
@ -136,6 +149,7 @@ fn expr_for_external_tagged_enum<'a>(
fn expr_for_internal_tagged_enum<'a>(
variants: impl Iterator<Item = &'a Variant<'a>>,
tag_name: &str,
deny_unknown_fields: bool,
) -> TokenStream {
let variant_schemas = variants.map(|variant| {
let name = variant.name();
@ -163,7 +177,7 @@ fn expr_for_internal_tagged_enum<'a>(
let doc_metadata = SchemaMetadata::from_attrs(&variant.attrs);
let tag_schema = doc_metadata.apply_to_schema(tag_schema);
match expr_for_untagged_enum_variant_for_flatten(&variant) {
match expr_for_untagged_enum_variant_for_flatten(&variant, deny_unknown_fields) {
Some(variant_schema) => quote! {
#tag_schema.flatten(#variant_schema)
},
@ -179,9 +193,12 @@ fn expr_for_internal_tagged_enum<'a>(
})
}
fn expr_for_untagged_enum<'a>(variants: impl Iterator<Item = &'a Variant<'a>>) -> TokenStream {
fn expr_for_untagged_enum<'a>(
variants: impl Iterator<Item = &'a Variant<'a>>,
deny_unknown_fields: bool,
) -> TokenStream {
let schemas = variants.map(|variant| {
let schema_expr = expr_for_untagged_enum_variant(variant);
let schema_expr = expr_for_untagged_enum_variant(variant, deny_unknown_fields);
let doc_metadata = SchemaMetadata::from_attrs(&variant.attrs);
doc_metadata.apply_to_schema(schema_expr)
});
@ -198,12 +215,13 @@ fn expr_for_adjacent_tagged_enum<'a>(
variants: impl Iterator<Item = &'a Variant<'a>>,
tag_name: &str,
content_name: &str,
deny_unknown_fields: bool,
) -> TokenStream {
let schemas = variants.map(|variant| {
let content_schema = if variant.is_unit() && variant.attrs.with.is_none() {
None
} else {
Some(expr_for_untagged_enum_variant(variant))
Some(expr_for_untagged_enum_variant(variant, deny_unknown_fields))
};
let (add_content_to_props, add_content_to_required) = content_schema
@ -221,6 +239,14 @@ fn expr_for_adjacent_tagged_enum<'a>(
enum_values: Some(vec![#name.into()]),
});
let set_additional_properties = if deny_unknown_fields {
quote! {
additional_properties: Some(Box::new(false.into())),
}
} else {
TokenStream::new()
};
let outer_schema = schema_object(quote! {
instance_type: Some(schemars::schema::InstanceType::Object.into()),
object: Some(Box::new(schemars::schema::ObjectValidation {
@ -236,6 +262,7 @@ fn expr_for_adjacent_tagged_enum<'a>(
#add_content_to_required
required
},
#set_additional_properties
..Default::default()
})),
});
@ -252,7 +279,7 @@ fn expr_for_adjacent_tagged_enum<'a>(
})
}
fn expr_for_untagged_enum_variant(variant: &Variant) -> TokenStream {
fn expr_for_untagged_enum_variant(variant: &Variant, deny_unknown_fields: bool) -> TokenStream {
if let Some(WithAttr::Type(with)) = &variant.attrs.with {
return quote_spanned! {variant.original.span()=>
gen.subschema_for::<#with>()
@ -263,11 +290,14 @@ fn expr_for_untagged_enum_variant(variant: &Variant) -> TokenStream {
Style::Unit => expr_for_unit_struct(),
Style::Newtype => expr_for_field(&variant.fields[0], true),
Style::Tuple => expr_for_tuple_struct(&variant.fields),
Style::Struct => expr_for_struct(&variant.fields, None),
Style::Struct => expr_for_struct(&variant.fields, &SerdeDefault::None, deny_unknown_fields),
}
}
fn expr_for_untagged_enum_variant_for_flatten(variant: &Variant) -> Option<TokenStream> {
fn expr_for_untagged_enum_variant_for_flatten(
variant: &Variant,
deny_unknown_fields: bool,
) -> Option<TokenStream> {
if let Some(WithAttr::Type(with)) = &variant.attrs.with {
return Some(quote_spanned! {variant.original.span()=>
<#with>::json_schema(gen)
@ -278,7 +308,7 @@ fn expr_for_untagged_enum_variant_for_flatten(variant: &Variant) -> Option<Token
Style::Unit => return None,
Style::Newtype => expr_for_field(&variant.fields[0], false),
Style::Tuple => expr_for_tuple_struct(&variant.fields),
Style::Struct => expr_for_struct(&variant.fields, None),
Style::Struct => expr_for_struct(&variant.fields, &SerdeDefault::None, deny_unknown_fields),
})
}
@ -307,17 +337,21 @@ fn expr_for_tuple_struct(fields: &[Field]) -> TokenStream {
}
}
fn expr_for_struct(fields: &[Field], cattrs: Option<&serde_attr::Container>) -> TokenStream {
fn expr_for_struct(
fields: &[Field],
default: &SerdeDefault,
deny_unknown_fields: bool,
) -> TokenStream {
let (flattened_fields, property_fields): (Vec<_>, Vec<_>) = fields
.iter()
.filter(|f| !f.serde_attrs.skip_deserializing() || !f.serde_attrs.skip_serializing())
.partition(|f| f.serde_attrs.flatten());
let set_container_default = cattrs.and_then(|c| match c.default() {
let set_container_default = match default {
SerdeDefault::None => None,
SerdeDefault::Default => Some(quote!(let container_default = Self::default();)),
SerdeDefault::Path(path) => Some(quote!(let container_default = #path();)),
});
};
let mut type_defs = Vec::new();
@ -362,7 +396,6 @@ fn expr_for_struct(fields: &[Field], cattrs: Option<&serde_attr::Container>) ->
})
.collect();
let deny_unknown_fields = cattrs.map_or(false, |attrs| attrs.deny_unknown_fields());
let set_additional_properties = if deny_unknown_fields {
quote! {
schema_object.object().additional_properties = Some(Box::new(false.into()));
@ -370,7 +403,6 @@ fn expr_for_struct(fields: &[Field], cattrs: Option<&serde_attr::Container>) ->
} else {
TokenStream::new()
};
quote! {
{
#(#type_defs)*