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

Internally tagged enums

Browse source
This commit is contained in:
Graham Esau 2019-08-10 00:41:04 +01:00
parent b0ae29094e
commit a3076dde63
5 changed files with 110 additions and 213 deletions
Download patch file Download diff file Expand all files Collapse all files

12
schemars/tests/enum.rs
View file

@ -1,12 +1,12 @@
mod util;
use schemars::MakeSchema;
use schemars::{MakeSchema, Map};
use util::*;
#[derive(Debug, MakeSchema)]
#[schemars(rename_all = "camelCase")]
pub enum External {
UnitOne,
String(String),
StringMap(Map<String, String>),
Struct{ foo: i32, bar: bool },
UnitTwo,
}
@ -15,12 +15,12 @@ pub enum External {
fn enum_external_tag() -> TestResult {
test_default_generated_schema::<External>("enum-external")
}
/*
#[derive(Debug, MakeSchema)]
#[schemars(tag = "typeProperty")]
pub enum Internal {
UnitOne,
String(String),
StringMap(Map<String, String>),
Struct{ foo: i32, bar: bool },
UnitTwo,
}
@ -29,12 +29,12 @@ pub enum Internal {
fn enum_internal_tag() -> TestResult {
test_default_generated_schema::<Internal>("enum-internal")
}
*/
#[derive(Debug, MakeSchema)]
#[schemars(untagged)]
pub enum Untagged {
UnitOne,
String(String),
StringMap(Map<String, String>),
Struct{ foo: i32, bar: bool }
}

9
schemars/tests/expected/enum-external.json
View file

@ -11,12 +11,15 @@
{
"type": "object",
"properties": {
"string": {
"type": "string"
"stringMap": {
"type": "object",
"additionalProperties": {
"type": "string"
}
}
},
"required": [
"string"
"stringMap"
]
},
{

257
schemars/tests/expected/enum-internal.json
View file

@ -1,222 +1,73 @@
{
"$schema": "http://json-schema.org/draft-07/schema#",
"title": "Schema",
"title": "Internal",
"anyOf": [
{
"type": "boolean"
},
{
"$ref": "#/definitions/Ref"
},
{
"$ref": "#/definitions/SchemaObject"
}
],
"definitions": {
"InstanceType": {
"enum": [
"null",
"boolean",
"object",
"array",
"number",
"string",
"integer"
]
},
"Schema": {
"anyOf": [
{
"type": "boolean"
},
{
"$ref": "#/definitions/Ref"
},
{
"$ref": "#/definitions/SchemaObject"
}
]
},
"SchemaObject": {
"type": "object",
"properties": {
"$id": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
"typeProperty": {
"type": "string",
"enum": [
"UnitOne"
]
},
"$schema": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
]
},
"allOf": {
"anyOf": [
{
"type": "array",
"items": {
"$ref": "#/definitions/Schema"
}
},
{
"type": "null"
}
]
},
"anyOf": {
"anyOf": [
{
"type": "array",
"items": {
"$ref": "#/definitions/Schema"
}
},
{
"type": "null"
}
]
},
"definitions": {
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/Schema"
}
},
"description": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
]
},
"enum": {
"anyOf": [
{
"type": "array",
"items": true
},
{
"type": "null"
}
]
},
"items": {
"anyOf": [
{
"$ref": "#/definitions/SingleOrVec_For_Schema"
},
{
"type": "null"
}
]
},
"not": {
"anyOf": [
{
"$ref": "#/definitions/Schema"
},
{
"type": "null"
}
]
},
"oneOf": {
"anyOf": [
{
"type": "array",
"items": {
"$ref": "#/definitions/Schema"
}
},
{
"type": "null"
}
]
},
"properties": {
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/Schema"
}
},
"required": {
"type": "array",
"items": {
"type": "string"
}
},
"title": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
]
},
"type": {
"anyOf": [
{
"$ref": "#/definitions/SingleOrVec_For_InstanceType"
},
{
"type": "null"
}
]
}
},
"additionalProperties": true
},
"Ref": {
"type": "object",
"properties": {
"$ref": {
"type": "string"
}
},
"required": [
"$ref"
"typeProperty"
]
},
"SingleOrVec_For_InstanceType": {
"anyOf": [
{
"$ref": "#/definitions/InstanceType"
},
{
"type": "array",
"items": {
"$ref": "#/definitions/InstanceType"
}
{
"type": "object",
"properties": {
"typeProperty": {
"type": "string",
"enum": [
"StringMap"
]
}
},
"required": [
"typeProperty"
],
"additionalProperties": {
"type": "string"
}
},
{
"type": "object",
"properties": {
"typeProperty": {
"type": "string",
"enum": [
"Struct"
]
},
"bar": {
"type": "boolean"
},
"foo": {
"type": "integer"
}
},
"required": [
"bar",
"foo",
"typeProperty"
]
},
"SingleOrVec_For_Schema": {
"anyOf": [
{
"$ref": "#/definitions/Schema"
},
{
"type": "array",
"items": {
"$ref": "#/definitions/Schema"
}
{
"type": "object",
"properties": {
"typeProperty": {
"type": "string",
"enum": [
"UnitTwo"
]
}
},
"required": [
"typeProperty"
]
}
}
]
}

5
schemars/tests/expected/enum-untagged.json
View file

@ -6,7 +6,10 @@
"type": "null"
},
{
"type": "string"
"type": "object",
"additionalProperties": {
"type": "string"
}
},
{
"type": "object",

40
schemars_derive/src/lib.rs
View file

@ -104,6 +104,7 @@ fn schema_for_enum(variants: &[Variant], cattrs: &attr::Container) -> TokenStrea
match cattrs.tag() {
EnumTag::External => schema_for_external_tagged_enum(variants, cattrs),
EnumTag::None => schema_for_untagged_enum(variants, cattrs),
EnumTag::Internal { tag } => schema_for_internal_tagged_enum(variants, cattrs, tag),
_ => unimplemented!("Adjacent/internal tagged enums not yet supported."),
}
}
@ -152,6 +153,45 @@ fn schema_for_external_tagged_enum(variants: &[Variant], cattrs: &attr::Containe
})
}
fn schema_for_internal_tagged_enum(
variants: &[Variant],
cattrs: &attr::Container,
tag_name: &str,
) -> TokenStream {
let schemas = variants.into_iter().map(|variant| {
let name = variant.attrs.name().deserialize_name();
let type_schema = wrap_schema_fields(quote! {
instance_type: Some(schemars::schema::InstanceType::String.into()),
enum_values: Some(vec![#name.into()]),
});
let schema = wrap_schema_fields(quote! {
instance_type: Some(schemars::schema::InstanceType::Object.into()),
properties: {
let mut props = schemars::Map::new();
props.insert(#tag_name.to_owned(), #type_schema);
props
},
required: {
let mut required = schemars::Set::new();
required.insert(#tag_name.to_owned());
required
},
});
if is_unit_variant(&variant) {
schema
} else {
let sub_schema = schema_for_untagged_enum_variant(variant, cattrs);
quote! {
#schema.flatten(#sub_schema)?
}
}
});
wrap_schema_fields(quote! {
any_of: Some(vec![#(#schemas),*]),
})
}
fn schema_for_untagged_enum(variants: &[Variant], cattrs: &attr::Container) -> TokenStream {
let schemas = variants
.into_iter()