postcard-bindgen-core 0.5.0

A crate to generate bindings for the postcard binary format for other languages than Rust - Core Crate
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
134
135
136
137

use std::{
    borrow::Cow,
    path::{Path, PathBuf},
};

use container::BindingTypeGenerateable;
use convert_case::{Case, Casing};
use genco::{quote, quote_in, tokens::quoted};

use crate::{
    code_gen::{python::ImportRegistry, utils::TokensIterExt},
    registry::{BindingType, Container, ContainerCollection, Module},
};

use super::{ExportFile, Tokens};

pub mod container;
pub mod types;

pub fn gen_typings(
    containers: &ContainerCollection,
    generate_package_name: String,
) -> Vec<ExportFile> {
    let mut files = Vec::new();

    let (containers, mods) = containers.containers_per_module();

    generate_typings_for_mod(
        "",
        containers.into_iter(),
        mods.into_iter(),
        &mut files,
        generate_package_name,
    );

    files
}

fn generate_typings_for_mod<'a>(
    package_path: impl AsRef<Path>,
    containers: impl Iterator<Item = Container> + Clone,
    mods: impl Iterator<Item = Module<'a>> + Clone,
    files: &mut Vec<ExportFile>,
    generate_package_name: String,
) {
    let container_exports = containers.clone().map(|f| {
        let mut l = vec![Cow::from(f.name)];
        if let BindingType::Enum(e) = f.r#type {
            l.extend(
                e.variants
                    .iter()
                    .map(|v| format!("{}_{}", f.name, v.name).into()),
            );
        }
        l
    });
    let mod_exports = mods.clone().map(|f| f.name().to_owned());

    let all_exports = container_exports
        .clone()
        .flatten()
        .chain(mod_exports.clone().map(|m| m.into()));

    let mut tokens = Tokens::new();

    let all_exports_tokens: Tokens = all_exports.map(|e| quote!($(quoted(e)))).join_with_comma();

    quote_in!(tokens=> __all__ = [
        $all_exports_tokens
    ]);

    tokens.line();

    for container_export in container_exports {
        let export_items = container_export.join(", ");
        quote_in!(tokens=> from ._$(container_export.first().unwrap().to_case(convert_case::Case::Snake)) import $export_items);
        tokens.push();
    }

    tokens.line();

    for mod_export in mod_exports {
        quote_in!(tokens=> from . import $mod_export);
        tokens.push();
    }

    let path = PathBuf::new().join("types").join(package_path);

    files.push(ExportFile {
        content_type: path.join("__init__").to_string_lossy().into_owned(),
        content: tokens,
    });

    for container in containers {
        let mut import_registry = ImportRegistry::new(generate_package_name.clone());
        let types = container
            .r#type
            .gen_typings_body((&container).into(), &mut import_registry);

        files.push(ExportFile {
            content_type: path
                .join(format!("_{}", container.name.to_case(Case::Snake)))
                .to_string_lossy()
                .into_owned(),
            content: quote! {
                $import_registry

                $types
            },
        });
    }

    for r#mod in mods {
        let (containers, mods) = r#mod.entries();

        generate_typings_for_mod(
            PathBuf::new().join(r#mod.path()).join(r#mod.name()),
            containers.into_iter(),
            mods.into_iter(),
            files,
            generate_package_name.clone(),
        );
    }
}

pub fn gen_basic_typings() -> Tokens {
    quote! {
        u8 = int
        i8 = int
        u16 = int
        i16 = int
        u32 = int
        i32 = int
        u64 = int
        i64 = int
    }
}