template-quote 0.4.4

A new-fasioned quote! macro implementation with pretty template-engine like syntax
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

use proc_macro2::{Ident, Span, TokenStream, TokenTree};
use template_quote::quote;

struct X;

impl template_quote::ToTokens for X {
	fn to_tokens(&self, tokens: &mut TokenStream) {
		tokens.extend(Some(TokenTree::Ident(Ident::new("X", Span::call_site()))));
	}
}

#[test]
fn test_ident() {
	let foo = Ident::new("Foo", Span::call_site());
	let bar = Ident::new(&format!("Bar{}", 7), Span::call_site());
	let tokens = quote!(struct #foo; enum #bar {});
	let expected = "struct Foo ; enum Bar7 { }";
	assert_eq!(expected, tokens.to_string());
}

#[test]
fn test_duplicate() {
	let ch = 'x';

	let tokens = quote!(#ch #ch);

	let expected = "'x' 'x'";
	assert_eq!(expected, tokens.to_string());
}

#[test]
fn test_substitution() {
	let x = X;
	let tokens = quote!(#x < #x > (#x) [#x] {#x});

	let expected = "X < X > (X) [X] { X }";

	assert_eq!(expected, tokens.to_string());
}

#[test]
fn test_advanced() {
	let generics = quote!( <'a, T> );

	let where_clause = quote!( where T: Serialize );

	let field_ty = quote!(String);

	let item_ty = quote!(Cow<'a, str>);

	let path = quote!(SomeTrait::serialize_with);

	let value = quote!(self.x);

	let tokens = quote! {
		struct SerializeWith #generics #where_clause {
			value: &'a #field_ty,
			phantom: ::std::marker::PhantomData<#item_ty>,
		}

		impl #generics ::serde::Serialize for SerializeWith #generics #where_clause {
			fn serialize<S>(&self, s: &mut S) -> Result<(), S::Error>
				where S: ::serde::Serializer
			{
				#path(self.value, s)
			}
		}

		SerializeWith {
			value: #value,
			phantom: ::std::marker::PhantomData::<#item_ty>,
		}
	};

	let expected = concat!(
		"struct SerializeWith < 'a , T > where T : Serialize { ",
		"value : & 'a String , ",
		"phantom : :: std :: marker :: PhantomData <Cow < 'a , str > >, ",
		"} ",
		"impl < 'a , T > :: serde :: Serialize for SerializeWith < 'a , T > where T : Serialize { ",
		"fn serialize < S > (& self , s : & mut S) -> Result < () , S :: Error > ",
		"where S : :: serde :: Serializer ",
		"{ ",
		"SomeTrait :: serialize_with (self . value , s) ",
		"} ",
		"} ",
		"SerializeWith { ",
		"value : self . x , ",
		"phantom : :: std :: marker :: PhantomData ::<Cow < 'a , str > >, ",
		"}"
	);

	assert_eq!(expected, tokens.to_string());
}