wick-component-codegen 0.6.0

Code generator for wick components
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

use proc_macro2::TokenStream;
use quote::quote;
use serde_json::Value;
use wick_interface_types::{Field, Type};

use super::config;
use crate::generate::ids::{id, snake};
use crate::generate::{expand_type, Direction};

const fn is_defaultable(ty: &Type) -> bool {
  matches!(
    ty,
    Type::List { .. } | Type::Optional { .. } | Type::Map { .. } | Type::Object
  )
}

pub(crate) fn field_pair(
  config: &mut config::Config,
  imported: bool,
  serde: bool,
  dir: Direction,
) -> impl FnMut(&Field) -> TokenStream + '_ {
  move |field: &Field| {
    let name = &field.name;
    let id = id(&snake(name));

    let ty = expand_type(config, dir, imported, config.raw, &field.ty);
    let desc = field
      .description
      .as_ref()
      .map_or_else(|| quote! {}, |desc| quote! {#[doc = #desc]});

    let serde = if serde {
      let default = (!field.required || is_defaultable(field.ty())).then(|| quote! {#[serde(default)]});
      let skip_if = match field.ty() {
        wick_interface_types::Type::List { .. } => quote! { #[serde(skip_serializing_if = "Vec::is_empty")] },
        wick_interface_types::Type::Optional { .. } => quote! { #[serde(skip_serializing_if = "Option::is_none")] },
        wick_interface_types::Type::Map { .. } => {
          quote! { #[serde(skip_serializing_if = "std::collections::HashMap::is_empty")] }
        }
        _ => quote! {},
      };

      #[allow(clippy::match_single_binding)]
      let deserialize_with = match field.ty() {
        wick_interface_types::Type::Datetime => quote! {
          #[serde(deserialize_with = "wick_component::datetime::serde::from_str_or_integer")]
        },
        _ => quote! {},
      };

      quote! {
        #[serde(rename = #name)]
        #default
        #deserialize_with
        #skip_if
      }
    } else {
      quote! {}
    };
    quote! {
      #desc
      #serde
      pub #id: #ty
    }
  }
}

pub(crate) fn field_default(_config: &mut config::Config, _imported: bool) -> impl FnMut(&Field) -> TokenStream + '_ {
  move |f| {
    let name = id(&snake(&f.name));
    let default = default_val()(f.default());
    quote! {#name: #default}
  }
}

pub(crate) fn default_val() -> impl FnMut(Option<&Value>) -> TokenStream {
  move |f| f.map_or_else(|| quote! {Default::default()}, default_from_val)
}

fn from_json(value: &Value) -> TokenStream {
  let json_str = serde_json::to_string(&value).unwrap();
  quote! {wick_component::from_str(#json_str).unwrap()}
}

fn default_from_val(value: &Value) -> TokenStream {
  match value {
    Value::Bool(b) => quote! {#b},
    Value::Number(n) => {
      if n.is_f64() {
        let n = n.as_f64().unwrap();
        quote! {#n}
      } else {
        let n = n.as_i64().unwrap();
        quote! {#n}
      }
    }
    Value::String(s) => quote! {#s},
    Value::Array(_) => from_json(value),
    Value::Object(_) => from_json(value),
    Value::Null => quote! {None},
  }
}