oas3-gen 0.25.1

A rust type generator for OpenAPI v3.1.x specification.
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

use proc_macro2::TokenStream;
use quote::{ToTokens, quote};

use crate::generator::{
  ast::{FieldDef, MethodNode, TypeRef},
  codegen::Visibility,
};

pub(crate) trait HelperMethodParts {
  type Kind;
  fn method(&self) -> MethodNode<Self::Kind>;
  fn parameters(&self) -> impl ToTokens;
  fn implementation(&self) -> TokenStream;
}

#[derive(Clone, Debug)]
pub(crate) struct HelperMethodFragment<Parts>(Visibility, Parts)
where
  Parts: HelperMethodParts;

impl<Parts> HelperMethodFragment<Parts>
where
  Parts: HelperMethodParts,
{
  pub(crate) fn new(vis: Visibility, node: Parts) -> Self {
    Self(vis, node)
  }
}

impl<Parts> ToTokens for HelperMethodFragment<Parts>
where
  Parts: HelperMethodParts,
{
  fn to_tokens(&self, tokens: &mut TokenStream) {
    let method_name = self.1.method().name.clone();
    let docs = self.1.method().docs.clone();
    let parameter = self.1.parameters();
    let implementation = self.1.implementation();
    let vis = &self.0;

    let ts = quote! {
      #docs
      #vis fn #method_name(#parameter) -> Self {
        #implementation
      }
    };

    tokens.extend(ts);
  }
}

#[derive(Clone, Debug)]
pub(crate) struct FieldFunctionParameterFragment(FieldDef);

impl FieldFunctionParameterFragment {
  pub(crate) fn new(field: FieldDef) -> Self {
    Self(field)
  }
}

impl ToTokens for FieldFunctionParameterFragment {
  fn to_tokens(&self, tokens: &mut TokenStream) {
    let name = &self.0.name;
    let rust_type = &self.0.rust_type;

    let ts = quote! { #name: #rust_type };

    tokens.extend(ts);
  }
}

#[derive(Clone, Debug)]
pub(crate) struct StructConstructorFragment(TypeRef, Vec<FieldDef>);

impl StructConstructorFragment {
  pub(crate) fn new(type_token: TypeRef, fields: Vec<FieldDef>) -> Self {
    Self(type_token, fields)
  }
}

impl ToTokens for StructConstructorFragment {
  fn to_tokens(&self, tokens: &mut TokenStream) {
    let base_type = &self.0.base_type;
    let field_names = self.1.iter().map(|f| f.name.clone()).collect::<Vec<_>>();

    let parameters = quote! { #(#field_names),* };

    let constructor = quote! {
      #base_type {
        #parameters,
        ..Default::default()
      }
    };

    let ts = if self.0.boxed {
      quote! { Box::new(#constructor) }
    } else {
      constructor
    };

    tokens.extend(ts);
  }
}