humphrey_json_derive 0.1.0

Derive macros for the Humphrey JSON crate.
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Provides the derive macros for Humphrey JSON.
//!
//! These macros should only be used from the Humphrey JSON crate itself, never directly from this crate. You can read about their uses in the [Humphrey JSON documentation](https://humphrey.whenderson.dev/json/data-structures.html).

#![warn(missing_docs)]
#![warn(clippy::missing_docs_in_private_items)]

extern crate proc_macro;

mod enum_type;
mod named_struct;
mod tuple_struct;

use proc_macro::TokenStream;

use syn::spanned::Spanned;
use syn::{parse_macro_input, Data, DeriveInput, Error};

/// Derives the `FromJson` trait for a type.
///
/// This macro can be used on named structs, tuple structs, and enums. It is not currently supported for enums with data variants.
#[proc_macro_derive(FromJson)]
pub fn derive_from_json(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);

    match &ast.data.clone() {
        Data::Struct(r#struct) => {
            if r#struct
                .fields
                .iter()
                .map(|field| field.ident.clone())
                .all(|ident| ident.is_some())
                && !r#struct.fields.is_empty()
            {
                named_struct::from_json_named_struct(ast, r#struct)
            } else if !r#struct.fields.is_empty() {
                tuple_struct::from_json_tuple_struct(ast, r#struct)
            } else {
                Error::new(ast.span(), "`FromJson` cannot be derived for empty structs")
                    .to_compile_error()
                    .into()
            }
        }

        Data::Enum(r#enum) => {
            if !r#enum
                .variants
                .iter()
                .any(|variant| !variant.fields.is_empty())
            {
                enum_type::from_json_enum(ast, r#enum)
            } else {
                Error::new(
                    ast.span(),
                    "`FromJson` cannot be derived for enums with data variants",
                )
                .to_compile_error()
                .into()
            }
        }

        _ => Error::new(
            ast.span(),
            "`FromJson` can only be derived for non-empty structs and enums",
        )
        .to_compile_error()
        .into(),
    }
}

/// Derives the `IntoJson` trait for a type.
///
/// This macro can be used on named structs, tuple structs, and enums. It is not currently supported for enums with data variants.
#[proc_macro_derive(IntoJson)]
pub fn derive_into_json(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);

    match &ast.data.clone() {
        Data::Struct(r#struct) => {
            if r#struct
                .fields
                .iter()
                .map(|field| field.ident.clone())
                .all(|ident| ident.is_some())
                && !r#struct.fields.is_empty()
            {
                named_struct::into_json_named_struct(ast, r#struct)
            } else if !r#struct.fields.is_empty() {
                tuple_struct::into_json_tuple_struct(ast, r#struct)
            } else {
                Error::new(ast.span(), "`IntoJson` cannot be derived for empty structs")
                    .to_compile_error()
                    .into()
            }
        }

        Data::Enum(r#enum) => {
            if !r#enum
                .variants
                .iter()
                .any(|variant| !variant.fields.is_empty())
            {
                enum_type::into_json_enum(ast, r#enum)
            } else {
                Error::new(
                    ast.span(),
                    "`IntoJson` cannot be derived for enums with data variants",
                )
                .to_compile_error()
                .into()
            }
        }

        _ => Error::new(
            ast.span(),
            "`IntoJson` can only be derived for non-empty structs and enums",
        )
        .to_compile_error()
        .into(),
    }
}