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

use heck::ToUpperCamelCase;
use indexmap::IndexMap;
use proc_macro2::TokenStream;
use quote::{format_ident, quote};

use super::path::{Path, PathSegment};

pub struct Scope {
    pub name: String,
    pub mod_name: String,
    pub members: Vec<Path>,
}

impl Scope {
    pub fn from_paths(paths: Vec<Path>) -> Vec<Scope> {
        let mut map = IndexMap::new();

        for path in paths {
            let Some(PathSegment::Constant(first_seg)) = path.segments.first() else {
                continue;
            };

            map.entry(first_seg.to_owned())
                .or_insert_with(|| Scope {
                    name: format!("{}Scope", first_seg.to_upper_camel_case()),
                    mod_name: first_seg.clone(),
                    members: Vec::new(),
                })
                .members
                .push(path);
        }

        map.into_values().collect()
    }

    pub fn codegen(&self) -> Option<TokenStream> {
        let name = format_ident!("{}", self.name);
        let bulk_name = format_ident!("Bulk{}", self.name);

        let mut functions = Vec::with_capacity(self.members.len());
        let mut bulk_functions = Vec::with_capacity(self.members.len());

        for member in &self.members {
            if let Some(code) = member.codegen_scope_call() {
                functions.push(code);
            }
            if let Some(code) = member.codegen_bulk_scope_call() {
                bulk_functions.push(code);
            }
        }

        Some(quote! {
            #[allow(dead_code)]
            pub struct #name<E>(E)
            where
                E: crate::executor::Executor;

            impl<E> #name<E>
            where
                E: crate::executor::Executor
            {
                pub fn new(executor: E) -> Self {
                    Self(executor)
                }

                #(#functions)*
            }

            #[allow(dead_code)]
            pub struct #bulk_name<E> where
                E: crate::executor::BulkExecutor,
            {
                executor: E,
            }

            impl<E> #bulk_name<E>
            where
                E: crate::executor::BulkExecutor
            {
                pub fn new(executor: E) -> Self {
                    Self {
                        executor,
                    }
                }

                #(#bulk_functions)*
            }
        })
    }
}