smd_macro 0.0.7

A crate for the smd! macro
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

use super::{
  event_names::UI_EVENT_NAMES,
  util,
};
use crate::types::{
  AttributeOrEventHandler,
  TokenTreeSlice,
};

#[allow(unused_imports)]
use nom::{
  error_position,
  tuple_parser,
};

use nom::{
  alt,
  apply,
  call,
  map,
  named,
  tuple,
};
use proc_macro2::{
  Delimiter,
  TokenStream,
};

// N.B. there are three types of attributes values supported:
// groups, empty and literals. Obviously, only groups can hold event handlers
// (callbacks), so we either call assert_is_not_event_handler or we
// switch on whether it is an event handler.
//
// In the EventHandler case, the string *is changed to upper camel case*
// to match the Event type! Beware!
// (Should we use a newtype?)

fn assert_is_not_event_handler(string: &String) {
  assert!(
    !UI_EVENT_NAMES.contains_key(string),
    format!(
      "attribute {} is an event name, but was not followed by curly braces",
      string
    )
  );
}

impl AttributeOrEventHandler {
  fn create_from_string(string: String, t: TokenStream) -> AttributeOrEventHandler {
    match UI_EVENT_NAMES.get(&string) {
      Some((event_name, _should_include_rest_param)) => {
        AttributeOrEventHandler::EventHandler((event_name.to_string(), t))
      },
      None => {
        // TODO make this less awkward
        if string == "ref" {
          AttributeOrEventHandler::DomRef(t)
        } else {
          AttributeOrEventHandler::Attribute((string, t))
        }
      },
    }
  }
}

named!(
  pub match_attribute <TokenTreeSlice, AttributeOrEventHandler>,
  alt!(
    alt!(
      map!(
        tuple!(
          apply!(util::match_ident, None, false),
          apply!(util::match_punct, Some('='), None, vec![]),
          map!(apply!(util::match_group, Some(Delimiter::Brace)), super::util::enquote)
        ),
        |val| {
          AttributeOrEventHandler::create_from_string(val.0, val.2)
        }
      )
        | map!(
          tuple!(
            apply!(util::match_ident, None, false),
            apply!(util::match_punct, Some('='), None, vec![]),
            map!(call!(util::match_literal), super::util::enquote)
          ),
          |val| {
            assert_is_not_event_handler(&val.0);
            AttributeOrEventHandler::Attribute((val.0, val.2))
          }
        )
        | map!(
          apply!(util::match_ident, None, false),
          |attr_name| {
            assert_is_not_event_handler(&attr_name);
            AttributeOrEventHandler::Attribute((attr_name, quote::quote!("")))
          }
        )
    )
  )
);