89b83a8 | rust-embed

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

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

89b83a8 — pyros2097 2018-03-18T22:02:46+05:30

add dev version of custom derive macro

Generated files not shown: Cargo.lock

Files changed (8) hide show

.vscode/settings.json +82 -0
Cargo.toml +7 -2
examples/basic.rs +28 -0
examples/rocket.rs +14 -14
examples/rouille.rs +0 -1
readme.md +20 -22
src/lib.rs +134 -94
tests/lib.rs +47 -0

.vscode/settings.json ADDED Viewed

@@ -0,0 +1,82 @@
+{
+  "editor.tabSize": 2,
+  "editor.fontSize": 15,
+  "editor.wordWrapColumn": 160,
+  "editor.minimap.enabled": false,
+  "search.exclude": {
+    "**/node_modules": true,
+    "**/bower_components": true,
+    "**/.git": true,
+    "**/.DS_Store": true,
+    "**/__pycache__": true,
+    "**/target": true,
+    "**/dist": true,
+    "**/.expo": true,
+    "**/.cache": true,
+    "**/.cache-loader": true,
+  },
+  "files.exclude": {
+    "**/node_modules": true,
+    "**/.git": true,
+    "**/.DS_Store": true,
+    "**/__pycache__": true,
+    "**/target": true,
+    "**/dist": true,
+    "**/.expo": true,
+    "**/.cache": true,
+    "**/.cache-loader": true,
+  },
+  "files.watcherExclude": {
+    "**/node_modules": true,
+    "**/dist": true,
+    "**/.git/objects/**": true,
+    "**/node_modules/**": true,
+    "**/__pycache__": true,
+    "**/target": true,
+    "**/.expo": true,
+    "**/.cache": true,
+    "**/.cache-loader": true,
+  },
+  "workbench.editor.showTabs": false,
+  "explorer.openEditors.visible": 0,
+  "gitProjectManager.baseProjectsFolders": [
+    "~/Code",
+  ],
+  "gitProjectManager.openInNewWindow": true,
+  "window.zoomLevel": 0,
+  "window.menuBarVisibility": "toggle",
+  "workbench.iconTheme": "vscode-icons",
+  "git.confirmSync": false,
+  "git.enableSmartCommit": true,
+  "workbench.startupEditor": "newUntitledFile",
+  "gitlens.advanced.messages": {
+    "suppressCommitHasNoPreviousCommitWarning": false,
+    "suppressCommitNotFoundWarning": false,
+    "suppressFileNotUnderSourceControlWarning": false,
+    "suppressGitVersionWarning": false,
+    "suppressLineUncommittedWarning": false,
+    "suppressNoRepositoryWarning": false,
+    "suppressResultsExplorerNotice": true,
+    "suppressUpdateNotice": true,
+    "suppressWelcomeNotice": false
+  },
+  "workbench.colorTheme": "Dracula Soft",
+  "git.autofetch": true,
+  "gitlens.keymap": "alternate",
+  "sqltools.format": {
+    "indentSize": 2
+  },
+  "sqltools.connections": [
+    {
+      "name": "Postgres",
+      "server": "localhost",
+      "dialect": "PostgreSQL",
+      "port": 5432,
+      "database": "postgres",
+      "username": "postgres",
+      "askForPassword": false,
+      "password": "postgres",
+      "connectionTimeout": 300
+    }
+  ]
+}

Cargo.toml CHANGED Viewed

@@ -1,7 +1,7 @@
 [package]
 name = "rust-embed"
-version = "0.5.2"
+version = "1.0.0"
-description = "Rust Marco which loads files into the rust binary at compile time during release and loads the file from the fs during dev"
+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"
@@ -10,7 +10,12 @@ keywords = ["http", "rocket", "static", "web", "server"]
 categories = ["web-programming::http-server"]
 authors = ["pyros2097 <[email protected]>"]
+[lib]
+proc-macro = true
 [dependencies]
+syn = "0.11"
+quote = "0.3"
 log = "0.4"
 walkdir = "2.1.4"

examples/basic.rs ADDED Viewed

@@ -0,0 +1,28 @@
+#![feature(attr_literals)]
+#[macro_use]
+extern crate log;
+#[macro_use]
+extern crate rust_embed;
+extern crate fern;
+#[derive(RustEmbed)]
+#[folder("examples/public/")]
+struct Asset;
+fn main() {
+  fern::Dispatch::new()
+    .format(move |out, message, record| {
+      out.finish(format_args!(
+        "[{}][{}] {}",
+        record.target(),
+        record.level(),
+        message
+      ))
+    })
+    .level(log::LevelFilter::Info)
+    .chain(std::io::stdout())
+    .apply()
+    .expect("Could not initialize logger");
+  let index_html = Asset::get("index.html").unwrap();
+  println!("{:?}", std::str::from_utf8(&index_html));
+}

examples/rocket.rs CHANGED Viewed

@@ -1,22 +1,26 @@
-#![feature(test, plugin, decl_macro)]
+#![feature(test, plugin, decl_macro, attr_literals)]
 #![plugin(rocket_codegen)]
+extern crate fern;
+#[macro_use]
+extern crate log;
 extern crate rocket;
 extern crate rocket_contrib;
+#[macro_use]
 extern crate rust_embed;
-extern crate fern;
-extern crate log;
 use std::path::PathBuf;
 use std::ffi::OsStr;
 use std::io::Cursor;
 use rocket::response;
 use rocket::http::{ContentType, Status};
+#[derive(RustEmbed)]
+#[folder("examples/public/")]
-use rocket::State;
+struct Asset;
-use rust_embed::*;
 #[get("/")]
-fn index<'r>(asset: State<Asset>) -> response::Result<'r> {
+fn index<'r>() -> response::Result<'r> {
-  asset("index.html".to_owned()).map_or_else(
+  Asset::get("index.html").map_or_else(
     || Err(Status::NotFound),
     |d| {
       response::Response::build()
@@ -28,7 +32,7 @@ fn index<'r>(asset: State<Asset>) -> response::Result<'r> {
 }
 #[get("/dist/<file..>")]
-fn dist<'r>(asset: State<Asset>, file: PathBuf) -> response::Result<'r> {
+fn dist<'r>(file: PathBuf) -> response::Result<'r> {
   let filename = file.display().to_string();
   let ext = file
     .as_path()
@@ -36,7 +40,7 @@ fn dist<'r>(asset: State<Asset>, file: PathBuf) -> response::Result<'r> {
     .and_then(OsStr::to_str)
     .expect("Could not get file extension");
   let content_type = ContentType::from_extension(ext).expect("Could not get file content type");
-  asset(filename.clone()).map_or_else(
+  Asset::get(&filename.clone()).map_or_else(
     || Err(Status::NotFound),
     |d| {
       response::Response::build()
@@ -61,9 +65,5 @@ fn main() {
     .chain(std::io::stdout())
     .apply()
     .expect("Could not initialize logger");
-  let asset = embed!("examples/public/".to_owned());
-  rocket::ignite()
-    .manage(asset)
-    .mount("/", routes![index, dist])
+  rocket::ignite().mount("/", routes![index, dist]).launch();
-    .launch();
 }

examples/rouille.rs CHANGED Viewed

@@ -1,4 +1,3 @@
-#[macro_use]
 extern crate rouille;
 use rouille::Response;

readme.md CHANGED Viewed

@@ -1,5 +1,5 @@
 ## Rust Embed [![Build Status](https://travis-ci.org/pyros2097/rust-embed.svg?branch=master)](https://travis-ci.org/pyros2097/rust-embed) [![crates.io](http://meritbadge.herokuapp.com/rust-embed)](https://crates.io/crates/rust-embed)
-Rust Marco which loads files into the rust binary at compile time during release and loads the file from the fs during dev.
+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.
 You can use this to embed your css, js and images into a single executable.
@@ -7,55 +7,53 @@ This is similar to [go-embed](https://github.com/pyros2097/go-embed).
 This is similar to [pony-embed](https://github.com/pyros2097/pony-embed).
-Note:
-This is not the same as std macros,
-`include_bytes!`
-`include_str!`
-these are macros which generate code at compile time for only files.
-`embed!("examples/public/")` accepts folders and returns a function to get the contents using the file path
 ## Installation
 ```
 [dependencies]
-rust-embed="0.5.2"
+rust-embed="1.0.0"
 ```
 ## Documentation
-The `embed!` macro takes a folder path and returns a function which allows you to get the file by passing the file path within the folder. So now you can statically compile all your assets i.e. your /static/ or /public/ folders into the rust executable and serve them during release and in development it will load the file from the file
-system so that it doesn't take to much time to compile;]
+Declare a struct name it Asset or something and add an attribute `folder` to it which has the path to your static folder.
 ```rust
+#![feature(attr_literals)]
+#[derive(RustEmbed)]
-asset(path: String) -> Option<Vec<u8>>
+#[folder("examples/public/")]
+struct Asset;
 ```
 ## Usage
 ```rust
+#![feature(attr_literals)]
 #[macro_use]
 extern crate rust_embed;
+#[macro_use]
+extern crate log;
+#[derive(RustEmbed)]
+#[folder("examples/public/")]
-use rust_embed::*;
+struct Asset;
 fn main() {
-  let asset = embed!("examples/public/".to_owned());
-  let index_html = asset("index.html".to_owned()).unwrap();
+  let index_html = Asset::get("index.html").unwrap();
-  println!("{}", index_html);
+  println!("{:?}", std::str::from_utf8(&index_html));
 }
 ```
 ## Examples
 To run the example in dev mode where it reads from the fs,
-`cargo run --example rocket`
+`cargo run --example basic`
 To run the example in release mode where it reads from binary,
-`cargo run --release --example rocket`
+`cargo run --release --example basic`
 ## Testing
-debug: `cargo test --lib`
+debug: `cargo test --tests --lib`
-release: `cargo test --lib --release`
+release: `cargo test --tests --lib --release`
 Go Rusketeers!
 The power is yours!

src/lib.rs CHANGED Viewed

@@ -1,110 +1,150 @@
+#![recursion_limit = "1024"]
+extern crate proc_macro;
 #[macro_use]
+extern crate quote;
-extern crate log;
+extern crate syn;
 extern crate walkdir;
-pub type Asset = Box<Fn(String) -> Option<Vec<u8>> + std::marker::Sync + std::marker::Send>;
+use proc_macro::TokenStream;
+use syn::*;
+use quote::Tokens;
 #[cfg(debug_assertions)]
-pub fn generate_assets(parent_path: String) -> Asset {
+fn generate_assets(ident: &syn::Ident, folder_path: String) -> quote::Tokens {
+  quote!{
-    use std::fs::File;
+      use std::fs::File;
+      use std::io::Read;
-    use std::path::Path;
+      use std::path::Path;
-    use std::io::Read;
+      impl #ident {
-    info!("loading folder -> {}", parent_path);
+          pub fn get(file_path: &str) -> Option<Vec<u8>> {
-    Box::new(move |file_path| {
+              let folder_path = #folder_path;
-        let name = &format!("{}{}", parent_path, file_path);
+              let name = &format!("{}{}", folder_path, file_path);
-        let path = &Path::new(name);
+              let path = &Path::new(name);
-        let key = String::from(path.to_str().expect("Path does not have a string representation"));
+              let key = String::from(path.to_str().expect("Path does not have a string representation"));
-        info!("asset from file -> {}", key);
+              info!("file: {}", key);
-        let mut file = match File::open(path) {
+              let mut file = match File::open(path) {
-            Ok(mut file) => file,
+                  Ok(mut file) => file,
-            Err(e) => {
+                  Err(e) => {
-                error!("could not open file -> {} {}", key, e);
+                      error!("file: {} {}", key, e);
-                return None
+                      return None
-            }
+                  }
-        };
+              };
-        let mut data: Vec<u8> = Vec::new();
+              let mut data: Vec<u8> = Vec::new();
-        match file.read_to_end(&mut data) {
+              match file.read_to_end(&mut data) {
-            Ok(_) => Some(data),
+                  Ok(_) => Some(data),
-            Err(e) =>  {
+                  Err(e) =>  {
-                error!("could not open file -> {} {}", key, e);
+                      error!("file: {} {}", key, e);
-                return None
+                      return None
-            }
+                  }
-        }
+              }
-    })
+          }
+      }
+  }
 }
 #[cfg(not(debug_assertions))]
-pub fn generate_assets<'a>(parent_path: String) -> Asset {
+pub fn generate_assets(folder_path: String) -> Asset {
-    use std::fs::File;
+  use std::fs::File;
-    use std::io::Read;
+  use std::io::Read;
-    use std::path::Path;
+  use std::path::Path;
-    use walkdir::WalkDir;
+  use walkdir::WalkDir;
-    use std::collections::HashMap;
+  use std::collections::HashMap;
-    info!("loading folder -> {}", parent_path);
+  info!("loading folder -> {}", parent_path);
-    let mut map = HashMap::new();
+  let mut map = HashMap::new();
-    for entry in WalkDir::new(parent_path.clone()).into_iter().filter_map(|e| e.ok()).filter(|e| e.file_type().is_file()) {
+  for entry in WalkDir::new(parent_path.clone())
+    .into_iter()
+    .filter_map(|e| e.ok())
+    .filter(|e| e.file_type().is_file())
+  {
-        info!("asset from file -> {}", entry.path().display());
+    info!("asset from file -> {}", entry.path().display());
-        let base = &parent_path.clone();
+    let base = &parent_path.clone();
+    let key = String::from(
+      entry
+        .path()
+        .to_str()
-        let key = String::from(entry.path().to_str().expect("Path does not have a string representation")).replace(base, "");
+        .expect("Path does not have a string representation"),
+    ).replace(base, "");
-        let mut file = File::open(&Path::new(&entry.path())).unwrap_or_else(|e| {
+    let mut file = File::open(&Path::new(&entry.path())).unwrap_or_else(|e| {
-            panic!("could not open file -> {} {}", key, e);
+      panic!("could not open file -> {} {}", key, e);
-        });
+    });
-        let mut data: Vec<u8> = Vec::new();
+    let mut data: Vec<u8> = Vec::new();
-        file.read_to_end(&mut data).unwrap_or_else(|e| {
+    file.read_to_end(&mut data).unwrap_or_else(|e| {
-            panic!("could not read file -> {} {}", key, e);
+      panic!("could not read file -> {} {}", key, e);
-        });
+    });
-        map.insert(key, data);
+    map.insert(key, data);
+  }
+  Box::new(move |file_path| {
+    info!("asset from cache -> {}", file_path);
+    match map.get(&file_path) {
+      Some(s) => Some(s.to_vec()),
+      None => None,
     }
+  });
+  quote!{
-    Box::new(move |file_path| {
+      impl #ident {
-        info!("asset from cache -> {}", file_path);
+          pub fn get(file_path: &str) -> Option<Vec<u8>> {
-        match map.get(&file_path) {
+              match file_path {
-            Some(s) => Some(s.to_vec()),
+                  "index.html" => Some(vec![]),
-            None => None,
+                  _ => None,
-        }
+              }
-    })
+          }
+      }
+  }
 }
-#[macro_export]
+fn help() {
-macro_rules! embed {
+  panic!(
-    ($x:expr) => ( $crate::generate_assets($x) )
+    "#[derive(RustEmbed)] should contain one attribute like this #[golem(\"examples/public/\")]"
+  );
 }
+fn impl_rust_embed(ast: &syn::DeriveInput) -> Tokens {
-#[cfg(test)]
+  match ast.body {
+    Body::Enum(_) => help(),
+    Body::Struct(ref data) => match data {
+      &VariantData::Struct(_) => help(),
-mod tests {
+      _ => {}
-    #[test]
+    },
+  };
-    #[cfg(debug_assertions)]
+  let ident = &ast.ident;
-    fn dev() {
-        let asset = embed!("examples/public/".to_owned());
-        match asset("index.html".to_owned()) {
+  if ast.attrs.len() == 0 || ast.attrs.len() > 1 {
-            None => assert!(false, "index.html should exist"),
-            _ => assert!(true),
+    help();
-        }
+  }
+  let value = &ast.attrs[0].value;
+  let items = match value {
+    &MetaItem::List(ref attr_name, ref items) => {
-        match asset("gg.html".to_owned()) {
+      if attr_name == "folder" {
+        items
+      } else {
-            Some(_) => assert!(false, "gg.html should not exist"),
+        panic!("#[derive(RustEmbed)] attribute name must be folder");
-            _ => assert!(true),
-        }
+      }
-        match asset("images/llama.png".to_owned()) {
-            None => assert!(false, "llama.png should exist"),
-            _ => assert!(true),
-        }
     }
-    #[test]
-    #[cfg(not(debug_assertions))]
-    fn prod() {
+    _ => {
-        let asset = embed!("examples/public/".to_owned());
-        match asset("index.html".to_owned()) {
-            None => assert!(false, "index.html should exist"),
+      panic!("#[derive(RustEmbed)] attribute name must be folder");
-            _ => assert!(true),
-        }
-        match asset("gg.html".to_owned()) {
-            Some(_) => assert!(false, "gg.html should not exist"),
-            _ => assert!(true),
-        }
-        match asset("images/llama.png".to_owned()) {
-            None => assert!(false, "llama.png should exist"),
-            _ => assert!(true),
-        }
     }
+  };
+  let item = &items[0];
+  let lit = match item {
+    &NestedMetaItem::Literal(ref l) => l,
+    _ => {
+      panic!("Hello");
+    }
+  };
+  let folder_path = match lit {
+    &Lit::Str(ref val, _) => val.clone(),
+    _ => {
+      panic!("#[derive(RustEmbed)] attribute value must be a string literal");
+    }
+  };
+  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()
 }

tests/lib.rs ADDED Viewed

@@ -0,0 +1,47 @@
+#![feature(attr_literals)]
+#[macro_use]
+extern crate log;
+#[macro_use]
+extern crate rust_embed;
+#[test]
+#[cfg(debug_assertions)]
+fn dev() {
+  #[derive(RustEmbed)]
+  #[folder("examples/public/")]
+  struct Asset;
+  match Asset::get("index.html") {
+    None => assert!(false, "index.html should exist"),
+    _ => assert!(true),
+  }
+  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),
+  }
+}
+#[test]
+#[cfg(not(debug_assertions))]
+fn prod() {
+  #[derive(RustEmbed)]
+  #[folder("examples/public/")]
+  struct Asset;
+  match Asset::get("index.html") {
+    None => assert!(false, "index.html should exist"),
+    _ => assert!(true),
+  }
+  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),
+  }
+}

rust-embed v8.13.0

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

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