jsonforge 0.1.0

A Rust procedural macro for generating JSON schema validators from Rust types
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

use proc_macro2::TokenStream;
use quote::quote;
use syn::{Ident, Visibility};

use crate::schema::types::{SchemaType, StructSchema};

use super::util::make_ident;

/// Generate a struct definition token stream.
///
/// In embedded mode, string fields use `&'static str` and arrays use `&'static [T]`.
pub fn struct_def(
    vis: &Visibility,
    name: &Ident,
    schema: &StructSchema,
    embedded: bool,
) -> TokenStream {
    let fields = schema.fields.iter().map(|f| {
        let field_ident = make_ident(&f.rust_name);
        let ty = schema_type_tokens(&f.ty, embedded);
        quote! { pub #field_ident: #ty }
    });

    if embedded {
        quote! {
            #[derive(Debug, Clone, Copy)]
            #vis struct #name {
                #(#fields,)*
            }
        }
    } else {
        quote! {
            #[derive(Debug, Clone)]
            #vis struct #name {
                #(#fields,)*
            }
        }
    }
}

/// Convert a [`SchemaType`] to its Rust token representation.
pub fn schema_type_tokens(ty: &SchemaType, embedded: bool) -> TokenStream {
    match ty {
        SchemaType::Bool => quote! { bool },
        SchemaType::Integer => quote! { i64 },
        SchemaType::Float => quote! { f64 },
        SchemaType::Str => {
            if embedded {
                quote! { &'static str }
            } else {
                quote! { ::std::string::String }
            }
        },
        SchemaType::Optional(inner) => {
            let inner_ts = schema_type_tokens(inner, embedded);
            quote! { ::std::option::Option<#inner_ts> }
        },
        SchemaType::Array(inner) => {
            let inner_ts = schema_type_tokens(inner, embedded);
            if embedded {
                quote! { &'static [#inner_ts] }
            } else {
                quote! { ::std::vec::Vec<#inner_ts> }
            }
        },
        SchemaType::Struct(nested) => {
            // Nested structs are inlined as anonymous structs isn't valid Rust;
            // we generate a placeholder name. In practice, top-level JSON objects
            // contain flat structs, so deep nesting is rare.
            // The caller is responsible for emitting any nested struct definitions
            // before this one.
            let _ = nested;
            if embedded {
                quote! { &'static str }
            } else {
                quote! { ::std::string::String }
            }
        },
    }
}