qsk-macros 0.1.0

Remapping DSL macro to make qsk remapping more concise.
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

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

use crate::lower;

impl From<&lower::ControlCode> for TokenStream {
    fn from(cc: &lower::ControlCode) -> TokenStream {
        match cc {
            lower::ControlCode::Key(control_code_path) => {
                quote!(
                    vec![qsk_types::ControlCode::KeyMap(#control_code_path)]
                )
            },
            lower::ControlCode::TapToggle(tt) => {
                let tt_name = &tt.name;
                let layer_ref_path = &tt.layer_ref.path;
                let layer_ref_name = &tt.layer_ref.name;
                let tap_key = &tt.tap_key;
                quote!(
                    vec![#tt_name(#layer_ref_path(#layer_ref_name.to_string()), #tap_key)]
                )
            },
            lower::ControlCode::Exit(path) => {
                quote!(
                    vec![#path]
                )
            },
        }
    }
}

impl From<&lower::KeyMap> for TokenStream {
    fn from(km: &lower::KeyMap) -> Self {
        let key_path = &km.key;
        km.control_code
            .iter()
            .map(|cc| cc.into())
            .map(|cc_ts: TokenStream| {
                quote!(
                    (#key_path, #cc_ts)
                )
            })
            .collect()
    }
}

impl From<&lower::Layer> for TokenStream {
    fn from(layer: &lower::Layer) -> Self {
        let name = &layer.name;
        let active = &layer.active;
        let maps: Vec<TokenStream> = layer.maps
            .iter()
            .map(TokenStream::from)
            .collect();

        quote!(
            qsk_types::Layer::from_hashmap(
                String::from(#name),
                std::collections::HashMap::from([
                    #(#maps),*
                ]),
                #active,
            )
        )
    }
}

pub fn codegen(ir: lower::Ir) -> TokenStream {
    let layers_quoted: Vec<TokenStream> = ir.layers
        .iter()
        .map(TokenStream::from)
        .collect();

    quote!(
        qsk_types::LayerComposer::from_layers(
            vec![#(#layers_quoted),*]
        )
    )
}