typify-impl 0.6.1

typify backend implementation
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

// Copyright 2024 Oxide Computer Company

use std::collections::BTreeMap;

use proc_macro2::TokenStream;
use quote::quote;

#[derive(Debug, Default)]
pub struct OutputSpace {
    items: BTreeMap<(OutputSpaceMod, String), TokenStream>,
}

#[derive(Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum OutputSpaceMod {
    Error,
    Crate,
    Builder,
    Defaults,
}

impl OutputSpace {
    pub fn add_item(
        &mut self,
        location: OutputSpaceMod,
        order_hint: impl ToString,
        stream: TokenStream,
    ) {
        self.items
            .entry((location, order_hint.to_string()))
            .or_default()
            .extend(stream);
    }

    pub fn into_stream(self) -> TokenStream {
        let mods = self
            .items
            .into_iter()
            .map(|((location, _), item)| (location, item))
            .fold(
                BTreeMap::<_, TokenStream>::new(),
                |mut map, (location, item)| {
                    map.entry(location).or_default().extend(item);
                    map
                },
            );

        let mod_streams = mods.into_iter().map(|(location, items)| match location {
            OutputSpaceMod::Crate => quote! {
                #items
            },
            OutputSpaceMod::Builder => quote! {
                /// Types for composing complex structures.
                pub mod builder {
                    #items
                }
            },
            OutputSpaceMod::Defaults => quote! {
                /// Generation of default values for serde.
                pub mod defaults {
                    #items
                }
            },
            OutputSpaceMod::Error => quote! {
                /// Error types.
                pub mod error {
                    #items
                }
            },
        });

        quote! {
            #(#mod_streams)*
        }
    }
}

#[cfg(test)]
mod tests {
    use super::{OutputSpace, OutputSpaceMod};

    use quote::quote;

    #[test]
    fn test_order() {
        let mut output = OutputSpace::default();
        output.add_item(
            OutputSpaceMod::Crate,
            "a",
            quote! {
                struct A;
            },
        );
        output.add_item(
            OutputSpaceMod::Crate,
            "b",
            quote! {
                struct B;
            },
        );
        output.add_item(
            OutputSpaceMod::Crate,
            "a",
            quote! {
                impl A {
                    fn new() -> Self { Self }
                }
            },
        );

        assert_eq!(
            output.into_stream().to_string(),
            quote! {
                struct A;
                impl A {
                    fn new() -> Self { Self }
                }
                struct B;
            }
            .to_string()
        );
    }
}