macro_tools 0.85.0

Tools for writing procedural macroses.
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

use super :: *;
use quote ::ToTokens;

#[ test ]
fn attr_prop_test() 
{
  use the_module :: { AttributePropertyComponent, AttributePropertyBoolean, AttributePropertyOptionalSingletone };

  #[ derive( Debug, Default, Clone, Copy ) ]
  pub struct DebugMarker;

  #[ derive( Debug, Default, Clone, Copy ) ]
  pub struct EnabledMarker;

  // pub trait AttributePropertyComponent
  // {
  //   const KEYWORD: &'static str;
  // }

  impl AttributePropertyComponent for DebugMarker 
  {
  const KEYWORD: &'static str = "debug";
 }

  impl AttributePropertyComponent for EnabledMarker 
  {
  const KEYWORD: &'static str = "enabled";
 }

  #[ derive( Debug, Default ) ]
  struct MyAttributes 
  {
  pub debug: AttributePropertyBoolean< DebugMarker >,
  pub enabled: AttributePropertyBoolean< EnabledMarker >,
 }

  impl syn ::parse ::Parse for MyAttributes
  {
    fn parse( input : syn ::parse ::ParseStream< '_ > ) -> syn ::Result< Self >
    {
      let mut debug = AttributePropertyBoolean ::< DebugMarker >::default();
      let mut enabled = AttributePropertyBoolean ::< EnabledMarker >::default();

      while !input.is_empty()
      {
        let lookahead = input.lookahead1();
        if lookahead.peek( syn ::Ident )
        {
          let ident : syn ::Ident = input.parse()?;
          match ident.to_string().as_str()
          {
            DebugMarker ::KEYWORD => debug = input.parse()?,
            EnabledMarker ::KEYWORD => enabled = input.parse()?,
            _ => return Err( lookahead.error() ),
          }
        }
        else
        {
          return Err( lookahead.error() );
        }

        // Optional comma handling
        if input.peek( syn ::Token![ , ] )
        {
          input.parse ::< syn ::Token![ , ] >()?;
        }
      }

      Ok( MyAttributes { debug, enabled } )
    }
  }

  let input: syn ::Attribute = syn ::parse_quote!( #[ attribute( enabled = true ) ] );
  let syn ::Meta ::List(meta) = input.meta  else
  {
  panic!("Expected a Meta ::List")
 };

  let nested_meta_stream: proc_macro2 ::TokenStream = meta.tokens;
  let attrs: MyAttributes = syn ::parse2(nested_meta_stream).unwrap();
  println!("{attrs:?}");

  let attr: AttributePropertyBoolean< DebugMarker > = AttributePropertyBoolean ::default();
  assert!(!attr.internal());
  let attr: AttributePropertyBoolean< DebugMarker > = true.into();
  assert!(attr.internal());
  let attr: AttributePropertyBoolean< DebugMarker > = false.into();
  assert!(!attr.internal());

  let input: syn ::Attribute = syn ::parse_quote!( #[ attribute( enabled = true ) ] );
  let syn ::Meta ::List(meta) = input.meta  else
  {
  panic!("Expected a Meta ::List")
 };

  let nested_meta_stream: proc_macro2 ::TokenStream = meta.tokens;
  let parsed: MyAttributes = syn ::parse2(nested_meta_stream).unwrap();
  assert!(parsed.enabled.internal());
  assert!(!parsed.debug.internal());
}

#[ test ]
fn attribute_property_enabled() 
{
  use the_module ::AttributePropertyOptionalSingletone;

  // Test default value
  let attr: AttributePropertyOptionalSingletone = AttributePropertyOptionalSingletone ::default();
  assert_eq!(attr.internal(), None);
  assert!(attr.value(true));
  assert!(!attr.value(false));
}