c3aed87 | 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.

c3aed87 — Hugues Morisset 2026-07-04T12:33:42+05:30

Add support to get files dat compressed

Files changed (9) hide show

Cargo.toml +8 -3
examples/axum.rs +36 -32
impl/src/lib.rs +113 -34
src/lib.rs +9 -0
tests/compression.rs +92 -0
tests/custom_crate_path.rs +3 -2
tests/path_traversal_attack.rs +1 -0
utils/Cargo.toml +3 -1
utils/src/lib.rs +18 -0

Cargo.toml CHANGED Viewed

@@ -10,7 +10,7 @@ keywords = ["http", "rocket", "static", "web", "server"]
 categories = ["web-programming", "filesystem"]
 authors = ["pyrossh"]
 edition = "2018"
-rust-version = "1.70.0"
+rust-version = "1.80.0"
 [[example]]
 name = "warp"
@@ -47,6 +47,11 @@ name = "salvo"
 path = "examples/salvo.rs"
 required-features = ["salvo-ex"]
+[[test]]
+name = "compression"
+path = "tests/compression.rs"
+required-features = ["compression"]
 [[test]]
 name = "interpolated_path"
 path = "tests/interpolated_path.rs"
@@ -87,12 +92,12 @@ poem = { version = "1.3.30", default-features = false, features = [
 salvo = { version = "0.16", default-features = false, optional = true }
 [dev-dependencies]
-sha2 = "0.10"
+sha2 = "0.11"
 [features]
 debug-embed = ["rust-embed-impl/debug-embed", "rust-embed-utils/debug-embed"]
 interpolate-folder-path = ["rust-embed-impl/interpolate-folder-path"]
-compression = ["rust-embed-impl/compression", "include-flate"]
+compression = ["rust-embed-impl/compression", "rust-embed-utils/compression", "include-flate"]
 mime-guess = ["rust-embed-utils/mime-guess"]
 include-exclude = [
   "rust-embed-impl/include-exclude",

examples/axum.rs CHANGED Viewed

@@ -1,65 +1,69 @@
 use axum::{
   extract::Path,
-  http::{header, StatusCode},
+  http::{HeaderMap, StatusCode},
   response::{Html, IntoResponse, Response},
   routing::{get, Router},
 };
 use rust_embed::Embed;
 use std::net::SocketAddr;
+#[derive(Embed)]
+#[folder = "examples/public/"]
+#[compression = "zstd"]
+struct Asset;
 #[tokio::main]
 async fn main() {
-  // Define our app routes, including a fallback option for anything not matched.
   let app = Router::new()
     .route("/", get(index_handler))
     .route("/index.html", get(index_handler))
     .route("/dist/{*file}", get(static_handler))
     .fallback_service(get(not_found));
-  // Start listening on the given address.
   let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
   println!("listening on {}", addr);
   let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
   axum::serve(listener, app.into_make_service()).await.unwrap();
 }
-// We use static route matchers ("/" and "/index.html") to serve our home
-// page.
-async fn index_handler() -> impl IntoResponse {
+async fn index_handler(headers: HeaderMap) -> impl IntoResponse {
-  static_handler(Path("index.html".to_string())).await
+  serve_asset("index.html", &headers)
 }
-// We use a wildcard matcher ("/dist/*file") to match against everything
-// within our defined assets directory. This is the directory on our Asset
-// struct below, where folder = "examples/public/".
-async fn static_handler(Path(path): Path<String>) -> impl IntoResponse {
+async fn static_handler(Path(path): Path<String>, headers: HeaderMap) -> impl IntoResponse {
-  StaticFile(path)
+  serve_asset(&path, &headers)
 }
-// Finally, we use a fallback route for anything that didn't match.
 async fn not_found() -> Html<&'static str> {
   Html("<h1>404</h1><p>Not Found</p>")
 }
+#[cfg_attr(not(feature = "compression"), allow(unused_variables, reason = "headers for compression path only"))]
-#[derive(Embed)]
+fn serve_asset(path: &str, headers: &HeaderMap) -> Response {
-#[folder = "examples/public/"]
+  #[cfg(feature = "compression")]
-struct Asset;
-pub struct StaticFile<T>(pub T);
-impl<T> IntoResponse for StaticFile<T>
-where
-  T: Into<String>,
-{
-  fn into_response(self) -> Response {
+  if let Some(compressed) = Asset::compressed(path) {
-    let path = self.0.into();
+    let encoding = compressed.content_encoding();
-    match Asset::get(path.as_str()) {
+    let accept = headers.get(axum::http::header::ACCEPT_ENCODING).and_then(|v| v.to_str().ok()).unwrap_or("");
-      Some(content) => {
+    if accept.contains(encoding) {
+      return (
+        [
-        let mime = mime_guess::from_path(path).first_or_octet_stream();
+          #[cfg(feature = "mime-guess")]
-        ([(header::CONTENT_TYPE, mime.as_ref())], content.data).into_response()
+          (axum::http::header::CONTENT_TYPE, compressed.metadata.mimetype()),
-      }
-      None => (StatusCode::NOT_FOUND, "404 Not Found").into_response(),
+          (axum::http::header::CONTENT_ENCODING, encoding),
+        ],
+        compressed.data.compressed().to_vec(),
+      )
+        .into_response();
     }
   }
+  match Asset::get(path) {
+    Some(content) => (
+      #[cfg(feature = "mime-guess")]
+      [(axum::http::header::CONTENT_TYPE, content.metadata.mimetype())],
+      content.data,
+    )
+      .into_response(),
+    None => (StatusCode::NOT_FOUND, "404 Not Found").into_response(),
+  }
 }

impl/src/lib.rs CHANGED Viewed

@@ -16,9 +16,10 @@ use std::{
 };
 use syn::{parse_macro_input, Data, DeriveInput, Expr, ExprLit, Fields, Lit, Meta, MetaNameValue};
+#[allow(clippy::too_many_arguments)]
 fn embedded(
   ident: &syn::Ident, relative_folder_path: Option<&str>, absolute_folder_path: Option<String>, prefix: Option<&str>, includes: &[String], excludes: &[String],
-  metadata_only: bool, crate_path: &syn::Path,
+  metadata_only: bool, crate_path: &syn::Path, compression: &str,
 ) -> syn::Result<TokenStream2> {
   extern crate rust_embed_utils;
@@ -35,7 +36,7 @@ fn embedded(
   for rust_embed_utils::FileEntry { rel_path, full_canonical_path } in entries {
     match_values.insert(
       rel_path.clone(),
-      embed_file(relative_folder_path, ident, &rel_path, &full_canonical_path, metadata_only, crate_path)?,
+      embed_file(relative_folder_path, ident, &rel_path, &full_canonical_path, metadata_only, crate_path, compression)?,
     );
     list_values.push(if let Some(prefix) = prefix {
@@ -67,30 +68,74 @@ fn embedded(
         (#path, #bytes),
     }
   });
-  let value_type = if cfg!(feature = "compression") {
+  let use_compression = cfg!(feature = "compression") && !metadata_only;
+  let (entry_type, return_type) = if use_compression {
+    (
-    quote! { fn() -> #crate_path::EmbeddedFile }
+      quote! { fn() -> #crate_path::EmbeddedCompressedFile },
+      quote! { #crate_path::EmbeddedCompressedFile },
+    )
   } else {
-    quote! { #crate_path::EmbeddedFile }
+    (quote! { #crate_path::EmbeddedFile }, quote! { #crate_path::EmbeddedFile })
   };
-  let get_value = if cfg!(feature = "compression") {
+  let get_value = if use_compression {
     quote! {|idx| (ENTRIES[idx].1)()}
   } else {
     quote! {|idx| ENTRIES[idx].1.clone()}
   };
+  let impls = if cfg!(feature = "compression") {
+    if metadata_only {
+      quote! {
+          pub fn compressed(_file_path: &str) -> ::std::option::Option<#crate_path::EmbeddedCompressedFile> {
+            ::std::option::Option::None
+          }
+          pub fn get(file_path: &str) -> ::std::option::Option<#crate_path::EmbeddedFile> {
+            #ident::__file(file_path)
+          }
+      }
+    } else {
+      quote! {
+          pub fn compressed(file_path: &str) -> ::std::option::Option<#crate_path::EmbeddedCompressedFile> {
+            #ident::__file(file_path)
+          }
+          pub fn get(file_path: &str) -> ::std::option::Option<#crate_path::EmbeddedFile> {
+            #ident::__file(file_path).map(|f| #crate_path::EmbeddedFile {
+                data: f.data.decoded().into(),
+                metadata: f.metadata,
+            })
+          }
+      }
+    }
+  } else {
+    quote! {
+        /// Get an embedded file and its metadata.
+        pub fn get(file_path: &str) -> ::std::option::Option<#crate_path::EmbeddedFile> {
+          #ident::__file(file_path)
+        }
+    }
+  };
+  let compressed_trait_impl = if cfg!(feature = "compression") {
+    quote! {
+      fn compressed(file_path: &str) -> ::std::option::Option<#crate_path::EmbeddedCompressedFile> {
+        #ident::compressed(file_path)
+      }
+    }
+  } else {
+    TokenStream2::new()
+  };
   Ok(quote! {
       #not_debug_attr
       impl #ident {
-          /// Get an embedded file and its metadata.
-          pub fn get(file_path: &str) -> ::std::option::Option<#crate_path::EmbeddedFile> {
+          fn __file(file_path: &str) -> ::std::option::Option<#return_type> {
-            #handle_prefix
+              #handle_prefix
-            let key = file_path.replace("\\", "/");
+              let key = file_path.replace("\\", "/");
-            static ENTRIES: &'static [(&'static str, #value_type)] = &[
+              static ENTRIES: &'static [(&'static str, #entry_type)] = &[
-                #(#match_values)*];
+                  #(#match_values)*];
-            let position = ENTRIES.binary_search_by_key(&key.as_str(), |entry| entry.0);
+              let position = ENTRIES.binary_search_by_key(&key.as_str(), |entry| entry.0);
-            position.ok().map(#get_value)
+              position.ok().map(#get_value)
           }
+          #impls
           fn names() -> ::std::slice::Iter<'static, &'static str> {
               const ITEMS: [&str; #array_len] = [#(#list_values),*];
               ITEMS.iter()
@@ -104,6 +149,7 @@ fn embedded(
       #not_debug_attr
       impl #crate_path::RustEmbed for #ident {
+        #compressed_trait_impl
         fn get(file_path: &str) -> ::std::option::Option<#crate_path::EmbeddedFile> {
           #ident::get(file_path)
         }
@@ -117,6 +163,15 @@ fn embedded(
 fn dynamic(
   ident: &syn::Ident, folder_path: Option<String>, prefix: Option<&str>, includes: &[String], excludes: &[String], metadata_only: bool, crate_path: &syn::Path,
 ) -> TokenStream2 {
+  let dynamic_compressed = if cfg!(feature = "compression") {
+    quote! {
+      fn compressed(_file_path: &str) -> ::std::option::Option<#crate_path::EmbeddedCompressedFile> {
+        ::std::option::Option::None
+      }
+    }
+  } else {
+    TokenStream2::new()
+  };
   let (handle_prefix, map_iter) = if let ::std::option::Option::Some(prefix) = prefix {
     (
       quote! { let file_path = file_path.strip_prefix(#prefix)?; },
@@ -221,6 +276,7 @@ fn dynamic(
       #[cfg(debug_assertions)]
       impl #crate_path::RustEmbed for #ident {
+        #dynamic_compressed
         fn get(file_path: &str) -> ::std::option::Option<#crate_path::EmbeddedFile> {
           #ident::get(file_path)
         }
@@ -234,7 +290,7 @@ fn dynamic(
 fn generate_assets(
   ident: &syn::Ident, relative_folder_path: Option<&str>, absolute_folder_path: Option<String>, prefix: Option<String>, includes: Vec<String>, excludes: Vec<String>,
-  metadata_only: bool, crate_path: &syn::Path,
+  metadata_only: bool, crate_path: &syn::Path, compression: &str,
 ) -> syn::Result<TokenStream2> {
   let embedded_impl = embedded(
     ident,
@@ -245,6 +301,7 @@ fn generate_assets(
     &excludes,
     metadata_only,
     crate_path,
+    compression,
   );
   if cfg!(feature = "debug-embed") {
     return embedded_impl;
@@ -259,7 +316,7 @@ fn generate_assets(
 }
 fn embed_file(
-  folder_path: Option<&str>, ident: &syn::Ident, rel_path: &str, full_canonical_path: &str, metadata_only: bool, crate_path: &syn::Path,
+  folder_path: Option<&str>, ident: &syn::Ident, rel_path: &str, full_canonical_path: &str, metadata_only: bool, crate_path: &syn::Path, compression: &str,
 ) -> syn::Result<TokenStream2> {
   let file = rust_embed_utils::read_file_from_fs(Path::new(full_canonical_path)).expect("File should be readable");
   let hash = file.metadata.sha256_hash();
@@ -282,36 +339,37 @@ fn embed_file(
     }
   } else if cfg!(feature = "compression") {
     let folder_path = folder_path.ok_or(syn::Error::new(ident.span(), "`folder` must be provided under `compression` feature."))?;
-    // Print some debugging information
     let full_relative_path = PathBuf::from_iter([folder_path, rel_path]);
     let full_relative_path = full_relative_path.to_string_lossy();
+    let compression_ident = format_ident!("{}", compression);
     quote! {
-      #crate_path::flate!(static BYTES: [u8] from #full_relative_path);
+      #crate_path::flate!(static BYTES: IFlate from #full_relative_path with #compression_ident);
     }
   } else {
     quote! {
       const BYTES: &'static [u8] = include_bytes!(#full_canonical_path);
     }
   };
-  let closure_args = if cfg!(feature = "compression") {
+  Ok(if cfg!(feature = "compression") && !metadata_only {
-    quote! { || }
+    quote! { || {
+        #embedding_code
+        #crate_path::EmbeddedCompressedFile {
+            data: &*BYTES,
+            metadata: #crate_path::utils::__rust_embed_metadata!([#(#hash),*], #last_modified, #created, #crate_path::__mimetype_of!(#full_canonical_path))
+        }
+    } }
   } else {
-    quote! {}
+    quote! {
-  };
+      {
-  Ok(quote! {
-       #closure_args {
         #embedding_code
         #crate_path::EmbeddedFile {
-            data: ::std::borrow::Cow::Borrowed(&BYTES),
+            data: ::std::borrow::Cow::Borrowed(BYTES),
-            // The mimetype is computed by a proc macro (so it does not depend
-            // on the host's `mime-guess` feature) and passed as the final
-            // argument. `__rust_embed_metadata!` is selected target-side: when
-            // the target lacks `mime-guess` it drops this argument without ever
-            // expanding the `__mimetype_of!` call.
             metadata: #crate_path::utils::__rust_embed_metadata!([#(#hash),*], #last_modified, #created, #crate_path::__mimetype_of!(#full_canonical_path))
         }
       }
+    }
   })
 }
@@ -367,6 +425,18 @@ fn impl_rust_embed(ast: &syn::DeriveInput) -> syn::Result<TokenStream2> {
   }
   let folder_path = folder_paths.remove(0);
+  const COMPRESSION_ALGOS: &[&str] = &["deflate", "zstd"];
+  let mut compression = find_attribute_values(ast, "compression");
+  if cfg!(feature = "compression") && (compression.len() > 1 || !compression.first().is_none_or(|v| COMPRESSION_ALGOS.contains(&v.as_str()))) {
+    return Err(syn::Error::new_spanned(
+      ast,
+      format!(
+        "#[derive(RustEmbed)] must contain one attribute like this #[compression = \"deflate\"]\navailable compression algorithm are {COMPRESSION_ALGOS:?}"
+      ),
+    ));
+  }
+  let compression = compression.pop().unwrap_or_else(|| "deflate".to_owned());
   let prefix = find_attribute_values(ast, "prefix").into_iter().next();
   let includes = find_attribute_values(ast, "include");
   let excludes = find_attribute_values(ast, "exclude");
@@ -401,9 +471,17 @@ fn impl_rust_embed(ast: &syn::DeriveInput) -> syn::Result<TokenStream2> {
       (Some(folder_path.clone()), absolute_path)
     } else {
       if cfg!(feature = "compression") {
+        let cargo_manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+        match Path::new(&folder_path).strip_prefix(&cargo_manifest_dir) {
+          Ok(rel) => {
+            let rel_str = rel.to_str().unwrap().to_owned();
+            (Some(rel_str), folder_path)
+          }
-        return Err(syn::Error::new_spanned(ast, "`folder` must be a relative path under `compression` feature."));
+          Err(_) => return Err(syn::Error::new_spanned(ast, "`folder` must be a relative path under `compression` feature.")),
+        }
+      } else {
+        (None, folder_path)
       }
-      (None, folder_path)
     };
     if !Path::new(&absolute_folder_path).exists() && !allow_missing {
@@ -436,10 +514,11 @@ fn impl_rust_embed(ast: &syn::DeriveInput) -> syn::Result<TokenStream2> {
     excludes,
     metadata_only,
     &crate_path,
+    &compression,
   )
 }
-#[proc_macro_derive(RustEmbed, attributes(folder, prefix, include, exclude, allow_missing, metadata_only, crate_path))]
+#[proc_macro_derive(RustEmbed, attributes(folder, prefix, include, exclude, allow_missing, metadata_only, crate_path, compression))]
 pub fn derive_input_object(input: TokenStream) -> TokenStream {
   let ast = parse_macro_input!(input as DeriveInput);
   match impl_rust_embed(&ast) {

src/lib.rs CHANGED Viewed

@@ -3,9 +3,14 @@
 #[cfg_attr(feature = "compression", doc(hidden))]
 pub use include_flate::flate;
+#[cfg(feature = "compression")]
+pub use include_flate;
 extern crate rust_embed_impl;
 pub use rust_embed_impl::*;
+#[cfg(feature = "compression")]
+pub use rust_embed_utils::EmbeddedCompressedFile;
 pub use rust_embed_utils::{EmbeddedFile, Metadata};
 #[doc(hidden)]
@@ -28,6 +33,10 @@ pub extern crate rust_embed_utils as utils;
 /// fn main() {}
 /// ```
 pub trait RustEmbed {
+  /// Get file compressed
+  #[cfg(feature = "compression")]
+  fn compressed(file_path: &str) -> Option<EmbeddedCompressedFile>;
   /// Get an embedded file and its metadata.
   ///
   /// If the feature `debug-embed` is enabled or the binary was compiled in

tests/compression.rs ADDED Viewed

@@ -0,0 +1,92 @@
+use rust_embed::{Embed, EmbeddedCompressedFile, EmbeddedFile};
+#[derive(Embed)]
+#[folder = "examples/public/"]
+struct Asset;
+#[derive(Embed)]
+#[folder = "examples/public/"]
+#[metadata_only = true]
+struct MetadataAsset;
+#[test]
+fn get_returns_decompressed_content() {
+  let file: EmbeddedFile = Asset::get("index.html").expect("index.html exists");
+  assert!(!file.data.is_empty());
+}
+#[test]
+fn get_missing_returns_none() {
+  assert!(Asset::get("missing.html").is_none());
+}
+#[test]
+fn metadata_only_compressed_always_returns_none() {
+  let file: Option<EmbeddedCompressedFile> = MetadataAsset::compressed("index.html");
+  assert!(file.is_none(), "metadata_only structs never have compressed data");
+}
+#[test]
+fn metadata_only_get_returns_empty_data() {
+  let file: EmbeddedFile = MetadataAsset::get("index.html").expect("index.html exists");
+  assert_eq!(file.data.len(), 0);
+}
+#[cfg(any(not(debug_assertions), feature = "debug-embed"))]
+mod release {
+  use super::*;
+  #[test]
+  fn compressed_exists() {
+    let file: Option<EmbeddedCompressedFile> = Asset::compressed("index.html");
+    assert!(file.is_some(), "index.html should have a compressed version");
+  }
+  #[test]
+  fn compressed_missing_returns_none() {
+    let file: Option<EmbeddedCompressedFile> = Asset::compressed("missing.html");
+    assert!(file.is_none());
+  }
+  #[test]
+  fn compressed_decompresses_to_original_content() {
+    let compressed: EmbeddedCompressedFile = Asset::compressed("index.html").expect("index.html exists");
+    let uncompressed: EmbeddedFile = Asset::get("index.html").expect("index.html exists");
+    assert_eq!(compressed.data.decoded(), uncompressed.data.as_ref());
+  }
+  #[test]
+  fn compressed_and_get_share_same_hash() {
+    let compressed: EmbeddedCompressedFile = Asset::compressed("index.html").expect("index.html exists");
+    let uncompressed: EmbeddedFile = Asset::get("index.html").expect("index.html exists");
+    assert_eq!(compressed.metadata.sha256_hash(), uncompressed.metadata.sha256_hash());
+  }
+  #[test]
+  fn compressed_bytes_smaller_than_original_for_text() {
+    let compressed: EmbeddedCompressedFile = Asset::compressed("index.html").expect("index.html exists");
+    let uncompressed: EmbeddedFile = Asset::get("index.html").expect("index.html exists");
+    assert!(
+      compressed.data.compressed().len() < uncompressed.data.len(),
+      "compressed text should be smaller than the original"
+    );
+  }
+  #[test]
+  fn content_encoding_is_valid_http_header_value() {
+    let compressed: EmbeddedCompressedFile = Asset::compressed("index.html").expect("index.html exists");
+    let encoding = compressed.content_encoding();
+    assert!(
+      encoding == "deflate" || encoding == "zstd",
+      "content_encoding should be a known HTTP Content-Encoding value, got: {}",
+      encoding
+    );
+  }
+  #[test]
+  fn compressed_iter_matches_get_iter() {
+    let file_count = Asset::iter().count();
+    let compressed_count = Asset::iter().filter_map(|p| Asset::compressed(p.as_ref())).count();
+    assert_eq!(file_count, compressed_count, "every file should have a compressed version");
+  }
+}

tests/custom_crate_path.rs CHANGED Viewed

@@ -1,5 +1,5 @@
-/// This test checks that the `crate_path` attribute can be used
+// This test checks that the `crate_path` attribute can be used
-/// to specify a custom path to the `rust_embed` crate.
+// to specify a custom path to the `rust_embed` crate.
 mod custom {
   pub mod path {
@@ -17,4 +17,5 @@ mod rust_embed {}
 #[derive(custom::path::rust_embed::RustEmbed)]
 #[crate_path = "custom::path::rust_embed"]
 #[folder = "examples/public/"]
+#[allow(dead_code)]
 struct Asset;

tests/path_traversal_attack.rs CHANGED Viewed

@@ -14,6 +14,7 @@ fn path_traversal_attack_fails() {
 #[derive(Embed)]
 #[folder = "examples/axum-spa/"]
+#[allow(dead_code)]
 struct AxumAssets;
 // TODO:

utils/Cargo.toml CHANGED Viewed

@@ -13,7 +13,8 @@ edition = "2018"
 [dependencies]
 walkdir = "2.3.1"
-sha2 = "0.10.5"
+sha2 = "0.11"
+include-flate = { version = "0.3.3", optional = true }
 mime_guess = { version = "2.0.4", optional = true }
 [dependencies.globset]
@@ -24,3 +25,4 @@ optional = true
 debug-embed = []
 mime-guess = ["mime_guess"]
 include-exclude = ["globset"]
+compression = ["include-flate"]

utils/src/lib.rs CHANGED Viewed

@@ -44,6 +44,24 @@ pub struct EmbeddedFile {
   pub metadata: Metadata,
 }
+/// A file embedded into the binary compressed
+#[cfg(feature = "compression")]
+pub struct EmbeddedCompressedFile {
+  pub data: &'static include_flate::IFlate,
+  pub metadata: Metadata,
+}
+#[cfg(feature = "compression")]
+impl EmbeddedCompressedFile {
+  /// Returns the HTTP `Content-Encoding` header value for this file's compression algorithm.
+  pub fn content_encoding(&self) -> &'static str {
+    match self.data.algo() {
+      include_flate::CompressionMethod::Deflate => "deflate",
+      include_flate::CompressionMethod::Zstd => "zstd",
+    }
+  }
+}
 /// Metadata about an embedded file
 #[derive(Clone)]
 pub struct Metadata {

rust-embed v8.11.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.