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

use proc_macro::{self, TokenStream};
use syn::{parse_macro_input, DeriveInput};

#[proc_macro_derive(ConfigrNoDefaultDerive)]
pub fn configr_no_default(input: TokenStream) -> TokenStream {
	let DeriveInput { ident, data, .. } = parse_macro_input!(input);
	if let syn::Data::Struct(s) = data {
		if let syn::Fields::Named(f) = s.fields {
			let fields: Vec<String> = f
				.named
				.into_iter()
				.map(|f| f.ident.map(|i| i.to_string()).unwrap_or("".to_string()))
				.collect();
			return format!(
				r#"impl Config<Self> for {} {{
                fn populate_template(fd: std::fs::File) -> std::io::Result<()> {{
                    use std::io::Write;
                    let mut writer = std::io::BufWriter::new(fd);
                    for f in &{:?} {{
                        writer.write_fmt(format_args!("{{}}=\n", f))?;
                    }}
                    writer.flush()?;
                    Ok(())
                }}
            }}"#,
				ident, fields
			)
			.parse()
			.unwrap();
		}
	}
	return "".parse().unwrap();
}

#[proc_macro_derive(ConfigrDefaultDerive)]
pub fn configr(input: TokenStream) -> TokenStream {
	let DeriveInput { ident, .. } = parse_macro_input!(input);
	format!(
		r#"impl Config<Self> for {} {{
		fn populate_template(fd: std::fs::File) -> std::io::Result<()> {{
			use std::io::Write;
			let mut writer = std::io::BufWriter::new(fd);
			writer.write(toml::to_string::<Self>(&Default::default()).unwrap().as_bytes())?;
			writer.flush()?;
			Ok(())
		}}
	}}"#,
		ident
	)
	.parse()
	.unwrap()
}

#[proc_macro_attribute]
#[allow(non_snake_case)]
pub fn ConfigrDefault(
	_: TokenStream,
	item: TokenStream,
) -> TokenStream {
	format!(
		"#[derive(configr::derive::ConfigrDefault, serde::Deserialize, serde::Serialize, std::default::Default)]\n{}",
		item
	)
	.parse()
	.unwrap()
}

#[proc_macro_attribute]
#[allow(non_snake_case)]
pub fn Configr(
	_: TokenStream,
	item: TokenStream,
) -> TokenStream {
	format!(
		"#[derive(configr::derive::Configr, serde::Deserialize)]\n{}",
		item
	)
	.parse()
	.unwrap()
}