rust-embed-for-web-impl 11.4.1

The proc-macro implementation of rust-embed-for-web.
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
95
96
97
98
99
100
101
102

#[cfg(feature = "include-exclude")]
use globset::GlobMatcher;
use proc_macro2::TokenStream as TokenStream2;
use rust_embed_for_web_utils::Config;

use crate::embed::MakeEmbed;

impl MakeEmbed for Vec<String> {
    fn make_embed(&self) -> TokenStream2 {
        let v = self;
        quote! { &[#(#v),*] }
    }
}

#[cfg(feature = "include-exclude")]
impl MakeEmbed for Vec<GlobMatcher> {
    fn make_embed(&self) -> TokenStream2 {
        let patterns: Vec<String> = self.iter().map(|v| v.glob().to_string()).collect();
        patterns.make_embed()
    }
}

impl MakeEmbed for Config {
    fn make_embed(&self) -> TokenStream2 {
        let includes_embed = {
            #[cfg(feature = "include-exclude")]
            {
                let includes = self.get_includes();
                if includes.is_empty() {
                    quote! {}
                } else {
                    let includes = includes.make_embed();
                    quote! {
                        for ele in #includes {
                            config.add_include(ele.to_string());
                        }
                    }
                }
            }
            #[cfg(not(feature = "include-exclude"))]
            quote! {}
        };
        let excludes_embed = {
            #[cfg(feature = "include-exclude")]
            {
                let excludes = self.get_excludes();
                if excludes.is_empty() {
                    quote! {}
                } else {
                    let excludes = excludes.make_embed();
                    quote! {
                        for ele in #excludes {
                            config.add_exclude(ele.to_string());
                        }
                    }
                }
            }
            #[cfg(not(feature = "include-exclude"))]
            quote! {}
        };

        quote! {
            let mut config = rust_embed_for_web::utils::Config::new();
            #includes_embed
            #excludes_embed
            config
        }
    }
}

pub(crate) fn generate_dynamic_impl(
    ident: &syn::Ident,
    config: &Config,
    folder_path: &str,
    prefix: &str,
) -> TokenStream2 {
    let config = config.make_embed();

    quote! {
      impl #ident {
        fn get(path: &str) -> Option<rust_embed_for_web::DynamicFile> {
          let config = { #config };
          let path = path.strip_prefix(#prefix)?;
          if config.should_include(path) {
            let folder_path: std::path::PathBuf = std::convert::From::from(#folder_path);
            let combined_path = folder_path.join(path);
            rust_embed_for_web::DynamicFile::read_from_fs(combined_path).ok()
          } else {
            None
          }
        }
      }

      impl rust_embed_for_web::RustEmbed for #ident {
        type File = rust_embed_for_web::DynamicFile;

        fn get(file_path: &str) -> Option<Self::File> {
          #ident::get(file_path)
        }
      }
    }
}