torn-api-codegen 0.8.1

Contains the v2 torn API model descriptions and codegen for the bindings
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

use quote::{format_ident, quote};

use crate::openapi::r#type::OpenApiType;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum NewtypeInner {
    Str,
    I32,
    I64,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Newtype {
    pub name: String,
    pub description: Option<String>,
    pub inner: NewtypeInner,
    pub copy: bool,
    pub ord: bool,
}

impl Newtype {
    pub fn from_schema(name: &str, schema: &OpenApiType) -> Option<Self> {
        let name = name.to_owned();
        let description = schema.description.as_deref().map(ToOwned::to_owned);

        match schema {
            OpenApiType {
                r#type: Some("string"),
                ..
            } => Some(Self {
                name,
                description,
                inner: NewtypeInner::Str,
                copy: false,
                ord: false,
            }),
            OpenApiType {
                r#type: Some("integer"),
                format: Some("int32"),
                ..
            } => Some(Self {
                name,
                description,
                inner: NewtypeInner::I32,
                copy: true,
                ord: true,
            }),
            OpenApiType {
                r#type: Some("integer"),
                format: Some("int64"),
                ..
            } => Some(Self {
                name,
                description,
                inner: NewtypeInner::I64,
                copy: true,
                ord: true,
            }),
            _ => None,
        }
    }

    pub fn codegen(&self) -> Option<proc_macro2::TokenStream> {
        let mut derives = vec![quote! { Debug, Clone, PartialEq, Eq, Hash, serde::Deserialize }];

        if self.copy {
            derives.push(quote! { Copy });
        }

        if self.ord {
            derives.push(quote! { PartialOrd, Ord });
        }

        let name = format_ident!("{}", self.name);
        let inner = match self.inner {
            NewtypeInner::Str => format_ident!("String"),
            NewtypeInner::I32 => format_ident!("i32"),
            NewtypeInner::I64 => format_ident!("i64"),
        };

        let doc = self.description.as_ref().map(|d| {
            quote! {
                #[doc = #d]
            }
        });

        let body = quote! {
            #doc
            #[derive(#(#derives),*)]
            pub struct #name(pub #inner);

            impl #name {
                pub fn new(inner: #inner) -> Self {
                    Self(inner)
                }

                pub fn into_inner(self) -> #inner {
                    self.0
                }
            }

            impl From<#inner> for #name {
                fn from(inner: #inner) -> Self {
                    Self(inner)
                }
            }

            impl From<#name> for #inner {
                fn from(outer: #name) -> Self {
                    outer.0
                }
            }

            impl std::fmt::Display for #name {
                fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                    write!(f, "{}", self.0)
                }
            }
        };

        Some(body)
    }
}