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

//! Implementation crate for the [include_dir!()] macro.
//!
//! [include_dir!()]: https://github.com/Michael-F-Bryan/include_dir

extern crate proc_macro;

use proc_macro::TokenStream;
use proc_macro_hack::proc_macro_hack;
use quote::{quote, ToTokens};
use syn::{parse_macro_input, LitStr};

use crate::dir::Dir;
use std::env;
use std::path::{Path, PathBuf};
use std::time::{SystemTime, UNIX_EPOCH};

mod dir;
mod file;

#[proc_macro_hack]
pub fn include_dir(input: TokenStream) -> TokenStream {
    let input: LitStr = parse_macro_input!(input as LitStr);
    let crate_root = env::var("CARGO_MANIFEST_DIR").unwrap();

    let path = PathBuf::from(crate_root).join(input.value());

    if !path.exists() {
        panic!("\"{}\" doesn't exist", path.display());
    }

    let path = path.canonicalize().expect("Can't normalize the path");

    Dir::from_disk(&path, &path)
        .expect("Couldn't load the directory")
        .to_token_stream()
        .into()
}

#[proc_macro_hack]
pub fn try_include_dir(input: TokenStream) -> TokenStream {
    let input: LitStr = parse_macro_input!(input as LitStr);
    let crate_root = env::var("CARGO_MANIFEST_DIR").unwrap();

    let path = PathBuf::from(crate_root).join(input.value());
    match load_dir(path) {
        Ok(dir) => quote! { Result::<$crate::Dir, &'static str>::Ok(#dir) },
        Err(err) => quote! { Result::<$crate::Dir, &'static str>::Err(#err) },
    }
    .into()
}

fn load_dir(path: impl AsRef<Path>) -> Result<Dir, String> {
    let path = path.as_ref();

    if !path.exists() {
        return Err(format!("\"{}\" doesn't exist", path.display()));
    }

    let path = path
        .canonicalize()
        .map_err(|_| String::from("Can't normalize the path"))?;

    Dir::from_disk(&path, &path)
        .map_err(|e| format!("Couldn't load the directory: {}", e.to_string()))
}

pub(crate) fn timestamp_to_tokenstream(
    time: std::io::Result<SystemTime>,
) -> proc_macro2::TokenStream {
    time.ok()
        .and_then(|m| m.duration_since(UNIX_EPOCH).ok())
        .map(|dur| dur.as_secs_f64())
        .map(|secs| quote! { Some(#secs) }.to_token_stream())
        .unwrap_or_else(|| quote! { None }.to_token_stream())
}