macro_tools 0.84.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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use super :: *;
use the_module :: { attr, qt, Result };

#[ test ]
fn is_standard_standard() 
{
  // Test a selection of attributes known to be standard
  assert!(attr ::is_standard("cfg"), "Expected 'cfg' to be a standard attribute.");
  assert!(attr ::is_standard("derive"), "Expected 'derive' to be a standard attribute.");
  assert!(attr ::is_standard("inline"), "Expected 'inline' to be a standard attribute.");
  assert!(attr ::is_standard("test"), "Expected 'test' to be a standard attribute.");
  assert!(attr ::is_standard("doc"), "Expected 'doc' to be a standard attribute.");
}

#[ test ]
fn is_standard_non_standard() 
{
  // Test some made-up attributes that should not be standard
  assert!(
  !attr ::is_standard("custom_attr"),
  "Expected 'custom_attr' to not be a standard attribute."
 );
  assert!(
  !attr ::is_standard("my_attribute"),
  "Expected 'my_attribute' to not be a standard attribute."
 );
  assert!(
  !attr ::is_standard("special_feature"),
  "Expected 'special_feature' to not be a standard attribute."
 );
}

#[ test ]
fn is_standard_edge_cases() 
{
  // Test edge cases like empty strings or unusual input
  assert!(
  !attr ::is_standard(""),
  "Expected empty string to not be a standard attribute."
 );
  assert!(
  !attr ::is_standard(" "),
  "Expected a single space to not be a standard attribute."
 );
  assert!(
  !attr ::is_standard("cfg_attr_extra"),
  "Expected 'cfg_attr_extra' to not be a standard attribute."
 );
}

#[ test ]
fn attribute_component_from_meta() 
{
  use the_module ::AttributeComponent;
  struct MyComponent;

  impl AttributeComponent for MyComponent 
  {
  const KEYWORD: &'static str = "my_component";

  fn from_meta(attr: &syn ::Attribute) -> Result< Self > 
  {
   match &attr.meta 
   {
  syn ::Meta ::NameValue(meta_name_value) if meta_name_value.path.is_ident(Self ::KEYWORD) => Ok(MyComponent),
  _ => Err(syn ::Error ::new_spanned(attr, "Failed to parse attribute as MyComponent")),
 }
 }
 }

  // Define a sample attribute
  let attr: syn ::Attribute = syn ::parse_quote!( #[ my_component = "value" ] );

  // Attempt to construct MyComponent from the attribute
  let result = MyComponent ::from_meta(&attr);

  // Assert that the construction was successful
  assert!(result.is_ok());

  // Negative testing

  // Define a sample invalid attribute
  let attr: syn ::Attribute = syn ::parse_quote!( #[ other_component = "value" ] );

  // Attempt to construct MyComponent from the invalid attribute
  let result = MyComponent ::from_meta(&attr);

  // Assert that the construction failed
  assert!(result.is_err());
}

#[ test ]
fn attribute_basic() -> Result< () > 
{
  use macro_tools ::syn ::parse ::Parser;

  // test.case( "AttributesOuter" );
  let code = qt! {
  #[ derive( Copy ) ]
  #[ derive( Clone ) ]
  #[ derive( Debug ) ]
 };
  let got = syn ::parse2 :: < the_module ::AttributesOuter >(code).unwrap();
  let exp = the_module ::AttributesOuter ::from(syn ::Attribute ::parse_outer.parse2(qt! {
  #[ derive( Copy ) ]
  #[ derive( Clone ) ]
  #[ derive( Debug ) ]
 })?);
  assert_eq!(got, exp);

  // test.case( "AttributesInner" );
  let code = qt! {
  // #![ deny( missing_docs ) ]
  #![ warn( something ) ]
 };
  let got = syn ::parse2 :: < the_module ::AttributesInner >(code).unwrap();
  let exp = the_module ::AttributesInner ::from(syn ::Attribute ::parse_inner.parse2(qt! {
  // #![ deny( missing_docs ) ]
  #![ warn( something ) ]
 })?);
  assert_eq!(got, exp);

  // test.case( "AttributesInner" );
  let code = qt! {
  #![ warn( missing_docs1 ) ]
  #![ warn( missing_docs2 ) ]
  #[ warn( something1 ) ]
  #[ warn( something2 ) ]
 };
  let got = syn ::parse2 :: < the_module ::Pair<the_module ::AttributesInner, the_module ::AttributesOuter >>(code).unwrap();
  let exp = the_module ::Pair ::from((
  the_module ::AttributesInner ::from(syn ::Attribute ::parse_inner.parse2(qt! {
   #![ warn( missing_docs1 ) ]
   #![ warn( missing_docs2 ) ]
 })?),
  the_module ::AttributesOuter ::from(syn ::Attribute ::parse_outer.parse2(qt! {
   #[ warn( something1 ) ]
   #[ warn( something2 ) ]
 })?),
 ));
  assert_eq!(got, exp);

  //

  Ok(())
}