autapi-macros 0.0.1

Macros for autapi
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
122
123
124
125
126
127
128
129
130
131
132
133

use darling::{FromDeriveInput, FromField, FromMeta, FromVariant, util::Flag};
use syn::{Generics, Ident, LitStr, Type};

use crate::{
    doc_attr::DocAttr,
    utils::{Case, ExprsMeta, PreserveStringExpr},
};

#[derive(Debug, Clone, FromDeriveInput)]
#[darling(attributes(schema), forward_attrs(doc))]
pub struct DeriveToSchemaAttrs<I> {
    pub ident: Ident,
    pub generics: Generics,
    pub bounds: Option<LitStr>,

    pub rename: Option<LitStr>,
    pub always_inlined: Flag,

    pub no_serialize: Flag,
    pub no_deserialize: Flag,

    pub serde: Flag,

    #[darling(with = DocAttr::try_from)]
    pub attrs: DocAttr,
    #[darling(flatten)]
    pub inner: I,
}

pub type NamedFieldsStructAttrs = DeriveToSchemaAttrs<NamedFieldsAttrs>;
pub type TupleStructAttrs = DeriveToSchemaAttrs<FieldAttrs>;
pub type UnitStructAttrs = DeriveToSchemaAttrs<SchemaMetaAttrs>;
pub type EnumAttrs = DeriveToSchemaAttrs<EnumAttrsInner>;

#[derive(Debug, Clone, FromMeta)]
pub struct EnumAttrsInner {
    pub tag: Option<LitStr>,
    pub untagged: Flag,
    pub rename_all: Option<Case>,
    pub rename_all_fields: Option<Case>,
    #[darling(flatten)]
    pub meta: SchemaMetaAttrs,
}

#[derive(Debug, Clone, FromVariant)]
#[darling(attributes(schema), forward_attrs(doc))]
pub struct EnumVariantAttrs<I> {
    pub ident: Ident,
    pub rename: Option<LitStr>,
    pub untagged: Flag,
    #[darling(with = DocAttr::try_from)]
    pub attrs: DocAttr,
    #[darling(flatten)]
    pub inner: I,
}

pub type NamedFieldsEnumVariantAttrs = EnumVariantAttrs<NamedFieldsAttrs>;
pub type TupleEnumVariantAttrs = EnumVariantAttrs<FieldAttrs>;
pub type UnitEnumVariantAttrs = EnumVariantAttrs<UnitEnumVariantAttrsInner>;

#[derive(Debug, Clone, FromMeta)]
pub struct UnitEnumVariantAttrsInner {
    pub null: Flag,
    #[darling(flatten)]
    pub meta: SchemaMetaAttrs,
}

#[derive(Debug, Clone, FromMeta)]
pub struct NamedFieldsAttrs {
    pub rename_all: Option<Case>,
    #[darling(flatten)]
    pub meta: SchemaMetaAttrs,
}

#[derive(Debug, Clone, FromField)]
#[darling(attributes(schema), forward_attrs(doc))]
pub struct NamedFieldAttrs {
    pub ty: Type,
    pub skip: Flag,
    pub rename: Option<LitStr>,
    #[darling(with = DocAttr::try_from)]
    pub attrs: DocAttr,
    #[darling(flatten)]
    pub inner: FieldAttrs,
}

#[derive(Debug, Clone, FromMeta)]
pub struct FieldAttrs {
    pub inline: Flag,
    pub using: Option<String>,
    pub optional: Flag,
    pub nullable: Flag,
    #[darling(flatten)]
    pub meta: SchemaMetaAttrs,
}

#[derive(Debug, Clone, FromMeta)]
pub struct SchemaMetaAttrs {
    pub description: Option<LitStr>,
    pub title: Option<LitStr>,
    pub deprecated: Flag,
    pub read_only: Flag,
    pub write_only: Flag,
    pub example: Option<PreserveStringExpr>,
    pub examples: Option<ExprsMeta>,
}

impl SchemaMetaAttrs {
    pub fn any_set(&self) -> bool {
        let Self {
            description,
            title,
            deprecated,
            read_only,
            write_only,
            example,
            examples,
        } = self;
        description.is_some()
            || title.is_some()
            || deprecated.is_present()
            || read_only.is_present()
            || write_only.is_present()
            || example.is_some()
            || examples.is_some()
    }
    pub fn or_with_doc_description(self, docs: &DocAttr) -> Self {
        Self {
            description: self.description.or_else(|| docs.to_lines()),
            ..self
        }
    }
}