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.

72ec32c6 — Peter

Merge pull request #45 from vemoo/list-files

Files changed (9) hide show

Cargo.toml +2 -6
appveyor.yml +6 -0
impl/Cargo.toml +19 -0
impl/src/lib.rs +137 -0
impl/src/utils.rs +1 -0
readme.md +49 -3
src/lib.rs +7 -129
src/utils.rs +33 -0
tests/lib.rs +11 -23

Cargo.toml CHANGED Viewed

@@ -1,6 +1,6 @@
 [package]
 name = "rust-embed"
-version = "4.0.0"
+version = "4.1.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"
@@ -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.1.0", path = "impl"}
 actix-web = { version = "0.7", optional = true }
 mime_guess = { version = "2.0.0-alpha.6", optional = true }

appveyor.yml CHANGED Viewed

@@ -6,6 +6,12 @@
 # Rust needs at least Visual Studio 2013 Appveyor OS for MSVC targets.
 os: Visual Studio 2015
+# before repo cloning
+init:
+  - git config --global core.symlinks true
 ## Build Matrix ##
 # This configuration will setup a build for each channel & target combination (12 windows

impl/Cargo.toml ADDED Viewed

@@ -0,0 +1,19 @@
+[package]
+name = "rust-embed-impl"
+version = "4.1.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,137 @@
+#![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 {
+  use std::env::current_dir;
+  // resolve relative to current path
+  let folder_path = utils::path_to_str(current_dir().unwrap().join(folder_path));
+  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 file_path = Path::new(#folder_path).join(file_path);
+              let mut file = match File::open(file_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 std::path::Path;
+              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

readme.md CHANGED Viewed

@@ -13,21 +13,63 @@ You can use this to embed your css, js and images into a single executable which
 ```
 [dependencies]
-rust-embed="4.0.0"
+rust-embed="4.1.0"
 ```
 ## Documentation
 You need to add the custom derive macro RustEmbed to your struct with an attribute `folder` which is the path to your static folder.
+The path resolution works as follows:
+- In `debug` and when `debug-embed` feature is not enabled, the folder path is resolved relative to where the binary is run from.
+- In `release` or when `debug-embed` feature is enabled, the folder path is resolved relative to where `Cargo.toml` is.
 ```rust
 #[derive(RustEmbed)]
 #[folder = "examples/public/"]
 struct Asset;
 ```
-This macro adds a single static method `get` to your type. This method allows you to get your assets from the fs during dev and from the binary during release. It takes the file path as string and returns an `Option` with the bytes.
+The macro will generate the following code:
 ```rust
+impl Asset {
-pub fn get(file_path: &str) -> Option<impl AsRef<[u8]>>
+  pub fn get(file_path: &str) -> Option<impl AsRef<[u8]>> {
+    ...
+  }
+  pub fn iter() -> impl Iterator<Item = impl AsRef<str>> {
+    ...
+  }
+}
 ```
+### `get(file_path: &str)`
+Given a relative path from the assets folder returns the bytes if found.
+If the feature `debug-embed` is enabled or the binary  compiled in release mode the bytes have been embeded in the binary and a `&'static [u8]` is returned.
+Otherwise the bytes are read from the file system on each call and a `Vec<u8>` is returned.
+### `iter()`
+Iterates the files in this assets folder.
+If the feature `debug-embed` is enabled or the binary compiled in release mode a static array to the list of relative paths to the files is returned.
+Otherwise the files are listed from the file system on each call.
+## Features
+### `debug-embed`
+Always embed the files in the binary, even in debug mode.
 ## Usage
 ```rust
 #[macro_use]
@@ -40,6 +82,10 @@ struct Asset;
 fn main() {
   let index_html = Asset::get("index.html").unwrap();
   println!("{:?}", std::str::from_utf8(index_html.as_ref()));
+  for file in Asset::iter() {
+      println!("{}", file.as_ref());
+  }
 }
 ```

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,33 @@
+use std;
+#[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 = path_to_str(e.path().strip_prefix(&folder_path).unwrap());
+      let full_canonical_path = path_to_str(std::fs::canonicalize(e.path()).expect("Could not get canonical path"));
+      let rel_path = if std::path::MAIN_SEPARATOR == '\\' {
+        rel_path.replace('\\', "/")
+      } else {
+        rel_path
+      };
+      FileEntry { rel_path, full_canonical_path }
+    })
+}
+pub fn path_to_str<P: AsRef<std::path::Path>>(p: P) -> String {
+  p.as_ref().to_str().expect("Path does not have a string representation").to_owned()
+}

tests/lib.rs CHANGED Viewed

@@ -1,13 +1,12 @@
 #[macro_use]
 extern crate rust_embed;
-#[test]
-#[cfg(debug_assertions)]
-fn dev() {
-  #[derive(RustEmbed)]
+#[derive(RustEmbed)]
-  #[folder = "examples/public/"]
+#[folder = "examples/public/"]
-  struct Asset;
+struct Asset;
+#[test]
+fn get_works() {
   match Asset::get("index.html") {
     None => assert!(false, "index.html should exist"),
     _ => assert!(true),
@@ -23,22 +22,11 @@ fn dev() {
 }
 #[test]
-#[cfg(not(debug_assertions))]
-fn prod() {
+fn iter_works() {
+  let mut num_files = 0;
-  #[derive(RustEmbed)]
+  for file in Asset::iter() {
-  #[folder = "examples/public/"]
-  struct Asset;
-  match Asset::get("index.html") {
+    assert!(Asset::get(file.as_ref()).is_some());
-    None => assert!(false, "index.html should exist"),
-    _ => assert!(true),
+    num_files += 1;
-  }
-  match Asset::get("gg.html") {
-    Some(_) => assert!(false, "gg.html should not exist"),
-    _ => assert!(true),
-  }
-  match Asset::get("images/llama.png") {
-    None => assert!(false, "llama.png should exist"),
-    _ => assert!(true),
   }
+  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.