implemented mime mode

- required for picoserve
- moved testdata

src/lib.rs

@@ -1,3 +1,4 @@
+use mime::{Mime};
 use proc_macro::TokenStream;
 use quote::quote;
 use syn::spanned::Spanned;
@@ -10,6 +11,7 @@ use std::path::{Path, PathBuf};
 enum EmbedMode {
     Bytes,
     Str,
+    BytesMime,
 }
 
 #[proc_macro_derive(Embed, attributes(dir, mode))]
@@ -44,6 +46,7 @@ pub fn embed(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
 
     for entry in collect_files(&absolue_path) {
         let rel_path = entry
+            .0
             .strip_prefix(&absolue_path)
             .unwrap()
             .to_str()
@@ -56,6 +59,11 @@ pub fn embed(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
         let arm = match mode {
             EmbedMode::Bytes => generate_byte_arm(&rel_path, include_string),
             EmbedMode::Str => generate_str_arm(&rel_path, include_string),
+            EmbedMode::BytesMime => generate_mime_arm(
+                &rel_path,
+                include_string,
+                entry.1.unwrap_or(mime::APPLICATION_OCTET_STREAM),
+            ),
         };
 
         match_arms.push(arm);
@@ -65,26 +73,33 @@ pub fn embed(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let mut expanded = match mode {
         EmbedMode::Bytes => generate_byte_impl(struct_name, match_arms),
         EmbedMode::Str => generate_str_impl(struct_name, match_arms),
+        EmbedMode::BytesMime => generate_mime_impl(struct_name, match_arms),
     };
 
     #[cfg(feature = "picoserve")]
     {
-        expanded.extend(generate_picoserv_impl(struct_name));
+        if matches!(mode,EmbedMode::BytesMime) {
+            expanded.extend(generate_picoserv_impl(struct_name));
+        }
     }
 
     proc_macro::TokenStream::from(expanded)
 }
 
-fn collect_files(dir: &Path) -> Vec<PathBuf> {
+fn collect_files(dir: &Path) -> Vec<(PathBuf, Option<Mime>)> {
     let mut files = Vec::new();
+
     for entry in fs::read_dir(dir).unwrap() {
         let path = entry.unwrap().path();
+
         if path.is_file() {
-            files.push(path);
+            let mime_type = mime_guess::from_path(&path);
+            files.push((path, mime_type.first()));
         } else if path.is_dir() {
             files.extend(collect_files(&path));
         }
     }
+
     files
 }
 
@@ -108,21 +123,22 @@ fn extract_dir_path(attr: &Attribute) -> String {
 fn extract_mode(attr: &Attribute) -> EmbedMode {
     let meta = match &attr.meta {
         Meta::NameValue(meta) => meta,
-        _ => panic!("Expected #[mode = \"bytes\"|\"str\"] as a name-value attribute."),
+        _ => panic!("Expected #[mode = \"bytes\"|\"str\"|\"mime\"] as a name-value attribute."),
     };
 
     let expr_lit = match &meta.value {
         Expr::Lit(expr_lit) => expr_lit,
-        _ => panic!("Expected #[mode = \"bytes\"|\"str\"] with a string literal."),
+        _ => panic!("Expected #[mode = \"bytes\"|\"str\"|\"mime\"] with a string literal."),
     };
 
     match &expr_lit.lit {
         Lit::Str(str) => match str.value().as_str() {
             "bytes" => EmbedMode::Bytes,
             "str" => EmbedMode::Str,
-            other => panic!("Unknown mode: {other}. Use `bytes` or `str`."),
+            "mime" => EmbedMode::BytesMime,
+            other => panic!("Unknown mode: {other}. Use `bytes`,`str` or `mime`."),
         },
-        _ => panic!("Expected #[mode = \"bytes\"|\"str\"] to be a string."),
+        _ => panic!("Expected #[mode = \"bytes\"|\"str\"|\"mime\"] to be a string."),
     }
 }
 
@@ -170,6 +186,29 @@ fn generate_str_impl(
     }
 }
 
+fn generate_mime_arm(rel: &str, include: &str, mime_type: Mime) -> proc_macro2::TokenStream {
+    let mime_str = mime_type.essence_str();
+    quote! {
+        #rel => Some((include_bytes!(#include),#mime_str)),
+    }
+}
+
+fn generate_mime_impl(
+    struct_name: &Ident,
+    match_arms: Vec<proc_macro2::TokenStream>,
+) -> proc_macro2::TokenStream {
+    quote! {
+        impl #struct_name {
+            pub fn get(name: &str) -> Option<(&'static [u8],&'static str)> {
+                match name {
+                    #(#match_arms)*
+                    _ => None,
+                }
+            }
+        }
+    }
+}
+
 #[cfg(feature = "picoserve")]
 fn generate_picoserv_impl(struct_name: &Ident) -> proc_macro2::TokenStream {
     quote! {
@@ -198,7 +237,7 @@ fn generate_picoserv_impl(struct_name: &Ident) -> proc_macro2::TokenStream {
                 match requested_file {
                     Some(content) => {
                         let response =
-                            picoserve::response::Response::new(picoserve::response::StatusCode::OK, content);
+                            picoserve::response::Response::new(picoserve::response::StatusCode::OK, content.0);
 
 
                         response_writer