hypermod 0.2.0

Automatically build the module tree from the src/ dir.
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

use proc_macro::TokenStream;
use proc_macro2::{Ident, Span, TokenStream as TokenStream2};
use quote::quote;

use std::collections::HashMap;
use std::env;
use std::ffi::OsStr;
use std::io::{Error, ErrorKind};
use std::path::{Path, PathBuf};
use std::result::Result;

#[proc_macro]
pub fn hypermod(_args: TokenStream) -> TokenStream {
    let src_dir = match env::var_os("CARGO_MANIFEST_DIR") {
        Some(manifest_dir) => PathBuf::from(manifest_dir).join("src"),
        None => PathBuf::from("src"),
    };
    let quote = match build_directory_mods_recursive(src_dir.as_path()) {
        Ok(expanded) => expanded,
        Err(err) => syn::Error::new(Span::call_site(), err).to_compile_error(),
    };
    quote.into()
}

fn build_directory_mods_recursive(directory: &Path) -> Result<TokenStream2, Error> {
    if !directory.is_dir() {
        return Err(Error::from(ErrorKind::InvalidInput));
    }

    let mut files = Vec::new();
    let mut submodules = HashMap::new();

    for entry in directory.read_dir()? {
        let entry = entry?;
        let file_type = entry.file_type()?;
        if file_type.is_dir() {
            let directory = entry.path();
            let dirname = directory
                .clone()
                .file_name()
                .unwrap()
                .to_os_string()
                .into_string()
                .unwrap();
            let submodule = build_directory_mods_recursive(directory.as_path())?;
            if !submodule.is_empty() {
                submodules.insert(Ident::new(dirname.as_str(), Span::call_site()), submodule);
            }
        } else if file_type.is_file() {
            let file_name = entry.file_name();
            let file_path = entry.path();
            if file_name == "mod.rs" || file_name == "lib.rs" || file_name == "main.rs" {
                continue;
            } else if file_path.extension() != Some(OsStr::new("rs")) {
                continue;
            }
            let file_ident = Ident::new(
                file_path
                    .file_stem()
                    .unwrap()
                    .to_os_string()
                    .into_string()
                    .unwrap()
                    .as_str(),
                Span::call_site(),
            );
            files.push(file_ident);
        }
    }

    let dirnames = submodules.keys();
    let modstreams = submodules.values();
    if submodules.is_empty() && files.is_empty() {
        return Ok(TokenStream2::new());
    }
    Ok(quote! {
        #(
            pub mod #dirnames {
                #modstreams
            }
        )*
        #(
            pub mod #files;
            pub use self::#files::*;
        )*
    })
}