refactor!: replace ignore_dirs with ignore_paths

structwafel · paolobarbolini · commit 372e3e48e8a5 · 2025-09-19T08:03:49.000+02:00
diff --git a/README.md b/README.md
@@ -50,9 +50,7 @@ This will:
 
 - `compress = false` - compress static files with zstd and gzip, true or false (defaults to false)
 
-- `ignore_dirs = ["my_ignore_dir", "other_ignore_dir"]` - a bracketed list of `&str`s of the paths/subdirectories inside the target directory, which should be ignored and not included. (If this parameter is missing, no subdirectories will be ignored)
-
-- `ignore_files = ["my_ignore_file.txt", "other_ignore_file.js"]` - a bracketed list of `&str`s of the specific files inside the target directory, which should be ignored and not included. (If this parameter is missing, no files will be ignored)
+- `ignore_paths = ["my_ignore_dir", "other_ignore_dir", "my_ignore_file.txt"]` - a bracketed list of `&str`s of paths/subdirectories/files inside the target directory, which should be ignored and not included. (If this parameter is missing, no paths/subdirectories/files will be ignored)
 
 - `strip_html_ext = false` - strips the `.html` or `.htm` from all HTML files included. If the filename is `index.html` or `index.htm`, the `index` part will also be removed, leaving just the root (defaults to false)
 
diff --git a/static-serve-macro/src/error.rs b/static-serve-macro/src/error.rs
@@ -21,8 +21,8 @@ pub(crate) enum Error {
     FilePathIsNotUtf8,
     #[error("Invalid unicode in directory name")]
     InvalidUnicodeInDirectoryName,
-    #[error("Cannot canonicalize ignore directory")]
-    CannotCanonicalizeIgnoreDir(#[source] io::Error),
+    #[error("Cannot canonicalize ignore path")]
+    CannotCanonicalizeIgnorePath(#[source] io::Error),
     #[error("Invalid unicode in directory name")]
     InvalidUnicodeInEntryName,
     #[error("Error while compressing with gzip")]
diff --git a/static-serve-macro/src/lib.rs b/static-serve-macro/src/lib.rs
@@ -155,8 +155,7 @@ impl ToTokens for EmbedAsset {
 
 struct EmbedAssets {
     assets_dir: AssetsDir,
-    validated_ignore_dirs: IgnoreDirs,
-    validated_ignore_files: IgnoreFiles,
+    validated_ignore_paths: IgnorePaths,
     should_compress: ShouldCompress,
     should_strip_html_ext: ShouldStripHtmlExt,
     cache_busted_paths: CacheBustedPaths,
@@ -168,8 +167,7 @@ impl Parse for EmbedAssets {
 
         // Default to no compression
         let mut maybe_should_compress = None;
-        let mut maybe_ignore_dirs = None;
-        let mut maybe_ignore_files = None;
+        let mut maybe_ignore_paths = None;
         let mut maybe_should_strip_html_ext = None;
         let mut maybe_cache_busted_paths = None;
 
@@ -183,13 +181,9 @@ impl Parse for EmbedAssets {
                     let value = input.parse()?;
                     maybe_should_compress = Some(value);
                 }
-                "ignore_dirs" => {
+                "ignore_paths" => {
                     let value = input.parse()?;
-                    maybe_ignore_dirs = Some(value);
-                }
-                "ignore_files" => {
-                    let value = input.parse()?;
-                    maybe_ignore_files = Some(value);
+                    maybe_ignore_paths = Some(value);
                 }
                 "strip_html_ext" => {
                     let value = input.parse()?;
@@ -202,7 +196,7 @@ impl Parse for EmbedAssets {
                 _ => {
                     return Err(syn::Error::new(
                         key.span(),
-                        "Unknown key in embed_assets! macro. Expected `compress`, `ignore_dirs`, `ignore_files`, `strip_html_ext`, or `cache_busted_paths`",
+                        "Unknown key in embed_assets! macro. Expected `compress`, `ignore_paths`, `strip_html_ext`, or `cache_busted_paths`",
                     ));
                 }
             }
@@ -222,11 +216,8 @@ impl Parse for EmbedAssets {
             })
         });
 
-        let ignore_dirs_with_span = maybe_ignore_dirs.unwrap_or(IgnoreDirsWithSpan(vec![]));
-        let validated_ignore_dirs = validate_ignore_dirs(ignore_dirs_with_span, &assets_dir.0)?;
-
-        let ignore_files_with_span = maybe_ignore_files.unwrap_or(IgnoreFilesWithSpan(vec![]));
-        let validated_ignore_files = validate_ignore_files(ignore_files_with_span, &assets_dir.0)?;
+        let ignore_paths_with_span = maybe_ignore_paths.unwrap_or(IgnorePathsWithSpan(vec![]));
+        let validated_ignore_paths = validate_ignore_paths(ignore_paths_with_span, &assets_dir.0)?;
 
         let maybe_cache_busted_paths =
             maybe_cache_busted_paths.unwrap_or(CacheBustedPathsWithSpan(vec![]));
@@ -235,8 +226,7 @@ impl Parse for EmbedAssets {
 
         Ok(Self {
             assets_dir,
-            validated_ignore_dirs,
-            validated_ignore_files,
+            validated_ignore_paths,
             should_compress,
             should_strip_html_ext,
             cache_busted_paths,
@@ -247,16 +237,14 @@ impl Parse for EmbedAssets {
 impl ToTokens for EmbedAssets {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let AssetsDir(assets_dir) = &self.assets_dir;
-        let ignore_dirs = &self.validated_ignore_dirs;
-        let ignore_files = &self.validated_ignore_files;
+        let ignore_paths = &self.validated_ignore_paths;
         let ShouldCompress(should_compress) = &self.should_compress;
         let ShouldStripHtmlExt(should_strip_html_ext) = &self.should_strip_html_ext;
         let cache_busted_paths = &self.cache_busted_paths;
 
         let result = generate_static_routes(
             assets_dir,
-            ignore_dirs,
-            ignore_files,
+            ignore_paths,
             should_compress,
             should_strip_html_ext,
             cache_busted_paths,
@@ -314,100 +302,46 @@ impl Parse for AssetsDir {
     }
 }
 
-struct IgnoreDirs(Vec<PathBuf>);
+struct IgnorePaths(Vec<PathBuf>);
 
-struct IgnoreDirsWithSpan(Vec<(PathBuf, Span)>);
+struct IgnorePathsWithSpan(Vec<(PathBuf, Span)>);
 
-struct IgnoreFiles(Vec<PathBuf>);
-
-struct IgnoreFilesWithSpan(Vec<(PathBuf, Span)>);
-
-impl Parse for IgnoreDirsWithSpan {
+impl Parse for IgnorePathsWithSpan {
     fn parse(input: ParseStream) -> syn::Result<Self> {
         let dirs = parse_dirs(input)?;
 
-        Ok(IgnoreDirsWithSpan(dirs))
-    }
-}
-
-impl Parse for IgnoreFilesWithSpan {
-    fn parse(input: ParseStream) -> syn::Result<Self> {
-        let files = parse_dirs(input)?; // reuse parse_dirs since it's just parsing paths
-
-        Ok(IgnoreFilesWithSpan(files))
+        Ok(IgnorePathsWithSpan(dirs))
     }
 }
 
-fn validate_ignore_dirs(
-    ignore_dirs: IgnoreDirsWithSpan,
+fn validate_ignore_paths(
+    ignore_paths: IgnorePathsWithSpan,
     assets_dir: &LitStr,
-) -> syn::Result<IgnoreDirs> {
-    let mut valid_ignore_dirs = Vec::new();
-    for (dir, span) in ignore_dirs.0 {
+) -> syn::Result<IgnorePaths> {
+    let mut valid_ignore_paths = Vec::new();
+    for (dir, span) in ignore_paths.0 {
         let full_path = PathBuf::from(assets_dir.value()).join(&dir);
         match fs::metadata(&full_path) {
-            Ok(meta) if !meta.is_dir() => {
-                return Err(syn::Error::new(
-                    span,
-                    "The specified ignored directory is not a directory",
-                ));
-            }
-            Ok(_) => valid_ignore_dirs.push(full_path),
+            Ok(_) => valid_ignore_paths.push(full_path),
             Err(e) if matches!(e.kind(), std::io::ErrorKind::NotFound) => {
                 return Err(syn::Error::new(
                     span,
-                    "The specified ignored directory does not exist",
+                    "The specified ignored path does not exist",
                 ))
             }
             Err(e) => {
                 return Err(syn::Error::new(
                     span,
                     format!(
-                        "Error reading ignored directory {}: {}",
+                        "Error reading ignored path {}: {}",
                         dir.to_string_lossy(),
                         DisplayFullError(&e)
                     ),
                 ))
             }
         }
     }
-    Ok(IgnoreDirs(valid_ignore_dirs))
-}
-
-fn validate_ignore_files(
-    ignore_files: IgnoreFilesWithSpan,
-    assets_dir: &LitStr,
-) -> syn::Result<IgnoreFiles> {
-    let mut valid_ignore_files = Vec::new();
-    for (file, span) in ignore_files.0 {
-        let full_path = PathBuf::from(assets_dir.value()).join(&file);
-        match fs::metadata(&full_path) {
-            Ok(meta) if meta.is_dir() => {
-                return Err(syn::Error::new(
-                    span,
-                    "The specified ignored file is a directory. Use ignore_dirs instead.",
-                ));
-            }
-            Ok(_) => valid_ignore_files.push(full_path),
-            Err(e) if matches!(e.kind(), std::io::ErrorKind::NotFound) => {
-                return Err(syn::Error::new(
-                    span,
-                    "The specified ignored file does not exist",
-                ))
-            }
-            Err(e) => {
-                return Err(syn::Error::new(
-                    span,
-                    format!(
-                        "Error reading ignored file {}: {}",
-                        file.to_string_lossy(),
-                        DisplayFullError(&e)
-                    ),
-                ))
-            }
-        }
-    }
-    Ok(IgnoreFiles(valid_ignore_files))
+    Ok(IgnorePaths(valid_ignore_paths))
 }
 
 struct ShouldCompress(LitBool);
@@ -512,8 +446,7 @@ fn parse_dirs(input: ParseStream) -> syn::Result<Vec<(PathBuf, Span)>> {
 
 fn generate_static_routes(
     assets_dir: &LitStr,
-    ignore_dirs: &IgnoreDirs,
-    ignore_files: &IgnoreFiles,
+    ignore_paths: &IgnorePaths,
     should_compress: &LitBool,
     should_strip_html_ext: &LitBool,
     cache_busted_paths: &CacheBustedPaths,
@@ -524,15 +457,13 @@ fn generate_static_routes(
     let assets_dir_abs_str = assets_dir_abs
         .to_str()
         .ok_or(Error::InvalidUnicodeInDirectoryName)?;
-    let canon_ignore_dirs = ignore_dirs
-        .0
-        .iter()
-        .map(|d| d.canonicalize().map_err(Error::CannotCanonicalizeIgnoreDir))
-        .collect::<Result<Vec<_>, _>>()?;
-    let canon_ignore_files = ignore_files
+    let canon_ignore_paths = ignore_paths
         .0
         .iter()
-        .map(|f| f.canonicalize().map_err(Error::CannotCanonicalizeFile))
+        .map(|d| {
+            d.canonicalize()
+                .map_err(Error::CannotCanonicalizeIgnorePath)
+        })
         .collect::<Result<Vec<_>, _>>()?;
     let canon_cache_busted_dirs = cache_busted_paths
         .dirs
@@ -556,19 +487,14 @@ fn generate_static_routes(
             continue;
         }
 
-        // Skip `entry`s which are located in ignored subdirectories
-        if canon_ignore_dirs
+        // Skip `entry`s which are located in ignored paths
+        if canon_ignore_paths
             .iter()
-            .any(|ignore_dir| entry.starts_with(ignore_dir))
+            .any(|ignore_path| entry.starts_with(ignore_path))
         {
             continue;
         }
 
-        // Skip `entry`s which are explicitly ignored files
-        if canon_ignore_files.contains(&entry) {
-            continue;
-        }
-
         let mut is_entry_cache_busted = false;
         if canon_cache_busted_dirs
             .iter()
diff --git a/static-serve/tests/tests.rs b/static-serve/tests/tests.rs
@@ -208,8 +208,8 @@ async fn router_created_compressed_zstd_or_gzip_accepted() {
 }
 
 #[tokio::test]
-async fn router_created_ignore_dirs_one() {
-    embed_assets!("../static-serve/test_assets", ignore_dirs = ["dist"]);
+async fn router_created_ignore_paths_one() {
+    embed_assets!("../static-serve/test_assets", ignore_paths = ["dist"]);
     let router: Router<()> = static_router();
     assert!(router.has_routes());
 
@@ -230,10 +230,10 @@ async fn router_created_ignore_dirs_one() {
 }
 
 #[tokio::test]
-async fn router_created_ignore_dirs_three() {
+async fn router_created_ignore_paths_three() {
     embed_assets!(
         "../static-serve/test_assets",
-        ignore_dirs = ["big", "small", "dist", "with_html"]
+        ignore_paths = ["big", "small", "dist", "with_html"]
     );
     let router: Router<()> = static_router();
     // all directories ignored, so router has no routes
@@ -1084,20 +1084,20 @@ async fn handles_dir_with_cache_control_on_filename_and_dir() {
 async fn router_created_ignore_files() {
     embed_assets!(
         "../static-serve/test_assets/small",
-        ignore_files = ["app.js"]
+        ignore_paths = ["app.js"]
     );
     let router: Router<()> = static_router();
 
     // app.js should be ignored, but styles.css should be available
     assert!(router.has_routes());
 
-    // Request for app.js should succeed
+    // Request for styles.css should succeed
     let request = create_request("/styles.css", &Compression::None);
     let response = get_response(router.clone(), request).await;
     let (parts, _) = response.into_parts();
     assert!(parts.status.is_success());
 
-    // Request for index.html should return 404 since it's ignored
+    // Request for app.js should return 404 since it's ignored
     let request = create_request("/app.js", &Compression::None);
     let response = get_response(router, request).await;
     let (parts, _) = response.into_parts();
@@ -1108,11 +1108,11 @@ async fn router_created_ignore_files() {
 async fn router_created_ignore_multiple_files() {
     embed_assets!(
         "../static-serve/test_assets/big",
-        ignore_files = ["app.js", "styles.css"]
+        ignore_paths = ["app.js", "styles.css"]
     );
     let router: Router<()> = static_router();
 
-    // All files in /big should be ignored, but files in /big/immutable should still be available
+    // app.js and styles.css at root should be ignored, but files in /big/immutable should still be available
     assert!(router.has_routes());
 
     // Request for ignored files should return 404
