deno_bindgen_macro 0.3.2

This tool aims to simplify glue code generation for Deno FFI libraries written in Rust.
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 syn::Attribute;
use syn::Lit;
use syn::Meta;
use syn::NestedMeta;

use inflector::Inflector;

#[derive(Debug)]
pub enum SerdeAttr {
  RenameAll(String),
  TagAndContent(String, String),
}

impl SerdeAttr {
  pub fn transform(&self, s: &str) -> Option<String> {
    match self {
      SerdeAttr::RenameAll(t) => match t.as_ref() {
        "lowercase" => Some(s.to_lowercase()),
        "UPPERCASE" => Some(s.to_uppercase()),
        "camelCase" => Some(s.to_camel_case()),
        "snake_case" => Some(s.to_snake_case()),
        "PascalCase" => Some(s.to_pascal_case()),
        "SCREAMING_SNAKE_CASE" => Some(s.to_screaming_snake_case()),
        _ => panic!("Invalid attribute value: {}", s),
      },
      _ => None,
    }
  }
}

pub fn get_serde_attrs(attrs: &Vec<Attribute>) -> Vec<SerdeAttr> {
  attrs
    .iter()
    .filter(|i| i.path.is_ident("serde"))
    .flat_map(|attr| match attr.parse_meta() {
      Ok(Meta::List(l)) => l.nested.iter().find_map(|meta| match meta {
        NestedMeta::Meta(Meta::NameValue(v)) => match v.path.get_ident() {
          Some(id) => match id.to_string().as_ref() {
            // #[serde(rename_all = "UPPERCASE")]
            "rename_all" => match &v.lit {
              Lit::Str(s) => Some(SerdeAttr::RenameAll(s.value())),
              _ => None,
            },
            // #[serde(tag = "key", content = "value")]
            "tag" => match &v.lit {
              Lit::Str(s) => {
                let tag = s.value();

                let lit = l.nested.iter().find_map(|meta| match meta {
                  NestedMeta::Meta(Meta::NameValue(v)) => {
                    match v.path.is_ident("content") {
                      true => Some(&v.lit),
                      false => None,
                    }
                  }
                  _ => None,
                });

                match lit {
                  Some(Lit::Str(s)) => {
                    let content = s.value();
                    Some(SerdeAttr::TagAndContent(tag, content))
                  }
                  _ => panic!("Missing `content` attribute with `tag`."),
                }
              }
              _ => None,
            },
            // #[serde(content = "value", tag = "key")]
            "content" => match &v.lit {
              Lit::Str(s) => {
                let content = s.value();

                let lit = l.nested.iter().find_map(|meta| match meta {
                  NestedMeta::Meta(Meta::NameValue(v)) => {
                    match v.path.is_ident("tag") {
                      true => Some(&v.lit),
                      false => None,
                    }
                  }
                  _ => None,
                });

                match lit {
                  Some(Lit::Str(s)) => {
                    let tag = s.value();
                    Some(SerdeAttr::TagAndContent(tag, content))
                  }
                  _ => panic!("Missing `tag` attribute with `content`."),
                }
              }
              _ => None,
            },
            _ => None,
          },
          _ => None,
        },
        _ => None,
      }),
      _ => None,
    })
    .collect::<Vec<_>>()
}