rust-embed

git clone https://pyrossh.dev/repos/rust-embed.git

rust macro which loads files into the rust binary at compile time during release and loads the file from the fs during dev.

32a496df — Bernardo

list files implementation create impl crate for proc_macro main crate reexports macro add utils.rs symlinked in both crates for code reuse export get_files method in main crate for use when in debug

Files changed (7) hide show

Cargo.toml +1 -5
impl/Cargo.toml +19 -0
impl/src/lib.rs +135 -0
impl/src/utils.rs +1 -0
src/lib.rs +7 -129
src/utils.rs +38 -0
tests/lib.rs +14 -0

Cargo.toml CHANGED Viewed

@@ -10,13 +10,9 @@ keywords = ["http", "rocket", "static", "web", "server"]
 categories = ["web-programming::http-server"]
 authors = ["pyros2097 <pyros2097@gmail.com>"]
-[lib]
-proc-macro = true
 [dependencies]
-syn = "0.11"
-quote = "0.3"
 walkdir = "2.1.4"
+rust-embed-impl = { version = "4.0.0", path = "impl"}
 actix-web = { version = "0.7", optional = true }
 mime_guess = { version = "2.0.0-alpha.6", optional = true }

impl/Cargo.toml ADDED Viewed

@@ -0,0 +1,19 @@
+[package]
+name = "rust-embed-impl"
+version = "4.0.0"
+description = "Rust Custom Derive Macro which loads files into the rust binary at compile time during release and loads the file from the fs during dev"
+readme = "readme.md"
+documentation = "https://docs.rs/rust-embed"
+repository = "https://github.com/pyros2097/rust-embed"
+license = "MIT"
+keywords = ["http", "rocket", "static", "web", "server"]
+categories = ["web-programming::http-server"]
+authors = ["pyros2097 <pyros2097@gmail.com>"]
+[lib]
+proc-macro = true
+[dependencies]
+syn = "0.11"
+quote = "0.3"
+walkdir = "2.1.4"

impl/src/lib.rs ADDED Viewed

@@ -0,0 +1,135 @@
+#![recursion_limit = "1024"]
+extern crate proc_macro;
+#[macro_use]
+extern crate quote;
+extern crate syn;
+extern crate walkdir;
+use proc_macro::TokenStream;
+use quote::Tokens;
+use std::path::Path;
+use syn::*;
+mod utils;
+#[cfg(all(debug_assertions, not(feature = "debug-embed")))]
+fn generate_assets(ident: &syn::Ident, folder_path: String) -> quote::Tokens {
+  quote!{
+      impl #ident {
+          pub fn get(file_path: &str) -> Option<impl AsRef<[u8]>> {
+              use std::fs::File;
+              use std::io::Read;
+              use std::path::Path;
+              let folder_path = #folder_path;
+              let name = &format!("{}{}", folder_path, file_path);
+              let path = &Path::new(name);
+              let mut file = match File::open(path) {
+                  Ok(mut file) => file,
+                  Err(_e) => {
+                      return None
+                  }
+              };
+              let mut data: Vec<u8> = Vec::new();
+              match file.read_to_end(&mut data) {
+                  Ok(_) => Some(data),
+                  Err(_e) =>  {
+                      return None
+                  }
+              }
+          }
+          pub fn iter() -> impl Iterator<Item = impl AsRef<str>> {
+              use rust_embed::utils::get_files;
+              get_files(String::from(#folder_path)).map(|e| e.rel_path)
+          }
+      }
+  }
+}
+#[cfg(any(not(debug_assertions), feature = "debug-embed"))]
+fn generate_assets(ident: &syn::Ident, folder_path: String) -> quote::Tokens {
+  use utils::{get_files, FileEntry};
+  let mut match_values = Vec::<Tokens>::new();
+  let mut list_values = Vec::<String>::new();
+  for FileEntry { rel_path, full_canonical_path } in get_files(folder_path) {
+    match_values.push(quote!{
+      #rel_path => Some(&include_bytes!(#full_canonical_path)[..]),
+    });
+    list_values.push(rel_path);
+  }
+  let array_len = list_values.len();
+  quote!{
+      impl #ident {
+          pub fn get(file_path: &str) -> Option<impl AsRef<[u8]>> {
+              match file_path {
+                  #(#match_values)*
+                  _ => None,
+              }
+          }
+          pub fn iter() -> impl Iterator<Item = impl AsRef<str>> {
+              static items: [&str; #array_len] = [#(#list_values),*];
+              items.iter()
+          }
+      }
+  }
+}
+fn help() {
+  panic!("#[derive(RustEmbed)] should contain one attribute like this #[folder = \"examples/public/\"]");
+}
+fn impl_rust_embed(ast: &syn::DeriveInput) -> Tokens {
+  match ast.body {
+    Body::Enum(_) => help(),
+    Body::Struct(ref data) => match data {
+      &VariantData::Struct(_) => help(),
+      _ => {}
+    },
+  };
+  let ident = &ast.ident;
+  if ast.attrs.len() == 0 || ast.attrs.len() > 1 {
+    help();
+  }
+  let value = &ast.attrs[0].value;
+  let literal_value = match value {
+    &MetaItem::NameValue(ref attr_name, ref value) => {
+      if attr_name == "folder" {
+        value
+      } else {
+        panic!("#[derive(RustEmbed)] attribute name must be folder");
+      }
+    }
+    _ => {
+      panic!("#[derive(RustEmbed)] attribute name must be folder");
+    }
+  };
+  let folder_path = match literal_value {
+    &Lit::Str(ref val, _) => val.clone(),
+    _ => {
+      panic!("#[derive(RustEmbed)] attribute value must be a string literal");
+    }
+  };
+  if !Path::new(&folder_path).exists() {
+    panic!(
+      "#[derive(RustEmbed)] folder '{}' does not exist. cwd: '{}'",
+      folder_path,
+      std::env::current_dir().unwrap().to_str().unwrap()
+    );
+  };
+  generate_assets(ident, folder_path)
+}
+#[proc_macro_derive(RustEmbed, attributes(folder))]
+pub fn derive_input_object(input: TokenStream) -> TokenStream {
+  let s = input.to_string();
+  let ast = syn::parse_derive_input(&s).unwrap();
+  let gen = impl_rust_embed(&ast);
+  gen.parse().unwrap()
+}

impl/src/utils.rs ADDED Viewed

	@@ -0,0 +1 @@
1	+ ../../src/utils.rs

src/lib.rs CHANGED Viewed

@@ -1,133 +1,11 @@
-#![recursion_limit = "1024"]
+#[cfg(all(debug_assertions, not(feature = "debug-embed")))]
-extern crate proc_macro;
-#[macro_use]
-extern crate quote;
-extern crate syn;
 extern crate walkdir;
+#[allow(unused_imports)]
+#[macro_use]
-use proc_macro::TokenStream;
+extern crate rust_embed_impl;
-use quote::Tokens;
+pub use rust_embed_impl::*;
-use std::path::Path;
-use syn::*;
+#[doc(hidden)]
 #[cfg(all(debug_assertions, not(feature = "debug-embed")))]
-fn generate_assets(ident: &syn::Ident, folder_path: String) -> quote::Tokens {
-  quote!{
-      impl #ident {
-          pub fn get(file_path: &str) -> Option<impl AsRef<[u8]>> {
-              use std::fs::File;
+pub mod utils;
-              use std::io::Read;
-              use std::path::Path;
-              let folder_path = #folder_path;
-              let name = &format!("{}{}", folder_path, file_path);
-              let path = &Path::new(name);
-              let mut file = match File::open(path) {
-                  Ok(mut file) => file,
-                  Err(_e) => {
-                      return None
-                  }
-              };
-              let mut data: Vec<u8> = Vec::new();
-              match file.read_to_end(&mut data) {
-                  Ok(_) => Some(data),
-                  Err(_e) =>  {
-                      return None
-                  }
-              }
-          }
-      }
-  }
-}
-#[cfg(any(not(debug_assertions), feature = "debug-embed"))]
-fn generate_assets(ident: &syn::Ident, folder_path: String) -> quote::Tokens {
-  use walkdir::WalkDir;
-  let mut values = Vec::<Tokens>::new();
-  for entry in WalkDir::new(folder_path.clone())
-    .into_iter()
-    .filter_map(|e| e.ok())
-    .filter(|e| e.file_type().is_file())
-  {
-    let base = &folder_path.clone();
-    let key = String::from(
-      entry
-        .path()
-        .strip_prefix(base)
-        .unwrap()
-        .to_str()
-        .expect("Path does not have a string representation"),
-    );
-    let canonical_path = std::fs::canonicalize(entry.path()).expect("Could not get canonical path");
-    let key = if std::path::MAIN_SEPARATOR == '\\' { key.replace('\\', "/") } else { key };
-    let canonical_path_str = canonical_path.to_str();
-    let value = quote!{
-      #key => Some(&include_bytes!(#canonical_path_str)[..]),
-    };
-    values.push(value);
-  }
-  quote!{
-      impl #ident {
-          pub fn get(file_path: &str) -> Option<impl AsRef<[u8]>> {
-              match file_path {
-                  #(#values)*
-                  _ => None,
-              }
-          }
-      }
-  }
-}
-fn help() {
-  panic!("#[derive(RustEmbed)] should contain one attribute like this #[folder = \"examples/public/\"]");
-}
-fn impl_rust_embed(ast: &syn::DeriveInput) -> Tokens {
-  match ast.body {
-    Body::Enum(_) => help(),
-    Body::Struct(ref data) => match data {
-      &VariantData::Struct(_) => help(),
-      _ => {}
-    },
-  };
-  let ident = &ast.ident;
-  if ast.attrs.len() == 0 || ast.attrs.len() > 1 {
-    help();
-  }
-  let value = &ast.attrs[0].value;
-  let literal_value = match value {
-    &MetaItem::NameValue(ref attr_name, ref value) => {
-      if attr_name == "folder" {
-        value
-      } else {
-        panic!("#[derive(RustEmbed)] attribute name must be folder");
-      }
-    }
-    _ => {
-      panic!("#[derive(RustEmbed)] attribute name must be folder");
-    }
-  };
-  let folder_path = match literal_value {
-    &Lit::Str(ref val, _) => val.clone(),
-    _ => {
-      panic!("#[derive(RustEmbed)] attribute value must be a string literal");
-    }
-  };
-  if !Path::new(&folder_path).exists() {
-    panic!(
-      "#[derive(RustEmbed)] folder '{}' does not exist. cwd: '{}'",
-      folder_path,
-      std::env::current_dir().unwrap().to_str().unwrap()
-    );
-  };
-  generate_assets(ident, folder_path)
-}
-#[proc_macro_derive(RustEmbed, attributes(folder))]
-pub fn derive_input_object(input: TokenStream) -> TokenStream {
-  let s = input.to_string();
-  let ast = syn::parse_derive_input(&s).unwrap();
-  let gen = impl_rust_embed(&ast);
-  gen.parse().unwrap()
-}

src/utils.rs ADDED Viewed

@@ -0,0 +1,38 @@
+#[cfg_attr(all(debug_assertions, not(feature = "debug-embed")), allow(unused))]
+pub struct FileEntry {
+  pub rel_path: String,
+  pub full_canonical_path: String,
+}
+#[cfg_attr(all(debug_assertions, not(feature = "debug-embed")), allow(unused))]
+pub fn get_files(folder_path: String) -> impl Iterator<Item = FileEntry> {
+  use std;
+  use walkdir;
+  walkdir::WalkDir::new(&folder_path)
+    .into_iter()
+    .filter_map(|e| e.ok())
+    .filter(|e| e.file_type().is_file())
+    .map(move |e| {
+      let rel_path = e
+        .path()
+        .strip_prefix(&folder_path)
+        .unwrap()
+        .to_str()
+        .expect("Path does not have a string representation")
+        .to_owned();
+      let full_canonical_path = std::fs::canonicalize(e.path())
+        .expect("Could not get canonical path")
+        .to_str()
+        .expect("Path does not have a string representation")
+        .to_owned();
+      let rel_path = if std::path::MAIN_SEPARATOR == '\\' {
+        rel_path.replace('\\', "/")
+      } else {
+        rel_path
+      };
+      FileEntry { rel_path, full_canonical_path }
+    })
+}

tests/lib.rs CHANGED Viewed

@@ -20,6 +20,13 @@ fn dev() {
     None => assert!(false, "llama.png should exist"),
     _ => assert!(true),
   }
+  let mut num_files = 0;
+  for file in Asset::iter() {
+    assert!(Asset::get(file.as_ref()).is_some());
+    num_files += 1;
+  }
+  assert_eq!(num_files, 6);
 }
 #[test]
@@ -41,4 +48,11 @@ fn prod() {
     None => assert!(false, "llama.png should exist"),
     _ => assert!(true),
   }
+  let mut num_files = 0;
+  for file in Asset::iter() {
+    assert!(Asset::get(file.as_ref()).is_some());
+    num_files += 1;
+  }
+  assert_eq!(num_files, 6);
 }

~repos /rust-embed

git clone https://pyrossh.dev/repos/rust-embed.git

rust macro which loads files into the rust binary at compile time during release and loads the file from the fs during dev.