file_enum_macro 0.1.2

Macros to generate an enum with a variant for each file in a project subdirectory. Extremely sloppy for now.
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

extern crate proc_macro;

use std::{collections::HashMap, path};

//use proc_macro::TokenStream;
use quote::quote;
use syn::parse::ParseStream;
use syn::punctuated::Punctuated;
use syn::token::Enum;
use syn::{parse_macro_input, DeriveInput, Expr, Ident, Item, ItemEnum, ItemFn, ItemStruct, LitStr, Token};
use enum_map::{EnumMap};
use std::fs;
use std::path::Path;

#[proc_macro_attribute]
pub fn generate_enum_and_map(attr: proc_macro::TokenStream, item: proc_macro::TokenStream) -> proc_macro::TokenStream
{
	let input = parse_macro_input!(item as ItemEnum);

	// Get the list of variants to add
	let subdir = attr.to_string().trim_matches('"').to_string();
	
	// Reading files in the subdirectory
	let paths = std::fs::read_dir(subdir.clone()).unwrap();
	
	let names_and_variants: Vec<(Ident, String)> = paths.into_iter()
	.filter_map(|dir| dir.ok())
	.map(|dir| dir.path())
	.filter(|path| path.is_file())
	.filter_map(|path|
		match
		(
			path.file_name().and_then(|x| x.to_str()),
			path.file_stem().and_then(|x| x.to_str()),
			path.extension().and_then(|x| x.to_str())
		)
		{
			(Some(name), Some(stem), Some(ext)) => Some((name.to_string(), stem.to_string(), ext.to_string())),
			_ => None,
		}
	)
	.map
	(
		|(name, stem, ext)| (format!("{}/{}", subdir.clone(), name), stem.chars().into_iter().filter(|x| x.is_ascii_alphanumeric()).collect::<String>(), ext)
	)
	.map
	(
		|(name, variant, ext)| (name, syn::Ident::new(&variant, proc_macro2::Span::call_site()), ext)
	)
	.map
	(
		|(name, variant, ext)| (variant, name)
	)
	.collect();

	let variants: Vec<Ident> = names_and_variants.iter().map(|x| x.0.clone()).collect();
	let names: Vec<String> = names_and_variants.iter().map(|x| x.1.clone()).collect();
	
	let attrs = &input.attrs;
	let vis = &input.vis;
	let enum_ident = &input.ident;
	let map_ident = syn::Ident::new(&format!("{}{}", &input.ident, "Map"), proc_macro2::Span::call_site());

	let expanded = quote! 
	{
		#(#attrs)*
		#vis enum #enum_ident 
		{
			#(#variants),*
		}
		struct #map_ident ( HashMap < #enum_ident, String >);
		impl #map_ident
		{
			fn new() -> Self
			{
				let mut map: Self = #map_ident(HashMap::new());
				let a: Vec<(#enum_ident, String)> = vec![#( (#enum_ident::#variants, #names.to_string()) ),*];
				a.iter().for_each
				(
					|(variant, name)| {map.0.insert(variant.clone(), name.clone());}
				);
				map
			}
		}
	};

	proc_macro::TokenStream::from(expanded)
}