refactor: extract file-gathering into new internal FileSpec API

Author: ErichDonGubler

moz-webgpu-cts/src/main.rs

@@ -154,16 +154,18 @@ struct ExecReportSpec {
     report_globs: Vec<String>,
 }
 
-impl ExecReportSpec {
-    fn paths(self) -> Result<Vec<PathBuf>, AlreadyReportedToCommandline> {
-        let Self {
-            report_paths,
-            report_globs,
-        } = self;
+struct FileSpec {
+    paths: Vec<PathBuf>,
+    globs: Vec<String>,
+}
 
-        let report_globs = {
+impl FileSpec {
+    fn into_paths(self, what: impl Display) -> Result<Vec<PathBuf>, AlreadyReportedToCommandline> {
+        let Self { paths, globs } = self;
+
+        let globs = {
             let mut found_glob_parse_err = false;
-            let globs = report_globs
+            let globs = globs
                 .into_iter()
                 .filter_map(|glob| match Glob::diagnosed(&glob) {
                     Ok((glob, _diagnostics)) => Some(glob.into_owned().partition()),
@@ -186,16 +188,16 @@ impl ExecReportSpec {
                 .collect::<Vec<_>>();
 
             if found_glob_parse_err {
-                log::error!("failed to parse one or more WPT report globs; bailing");
+                log::error!("failed to parse one or more globs for {what}; bailing");
                 return Err(AlreadyReportedToCommandline);
             }
 
             globs
         };
 
-        let report_paths_from_glob = {
+        let paths_from_globs = {
             let mut found_glob_walk_err = false;
-            let files = report_globs
+            let files = globs
                 .iter()
                 .flat_map(|(base_path, glob)| {
                     glob.walk(base_path)
@@ -205,12 +207,12 @@ impl ExecReportSpec {
                                 found_glob_walk_err = true;
                                 let ctx_msg = if let Some(path) = e.path() {
                                     format!(
-                                        "failed to enumerate files for glob `{}` at path {}",
+                                        "failed to enumerate {what} from glob `{}` at path {}",
                                         glob,
                                         path.display()
                                     )
                                 } else {
-                                    format!("failed to enumerate files for glob `{glob}`")
+                                    format!("failed to enumerate {what} from glob `{glob}`")
                                 };
                                 let e = Report::msg(e).wrap_err(ctx_msg);
                                 eprintln!("{e:?}");
@@ -222,44 +224,68 @@ impl ExecReportSpec {
                 .collect::<Vec<_>>();
 
             if found_glob_walk_err {
-                log::error!(concat!(
-                    "failed to enumerate files with WPT report globs, ",
-                    "see above for more details"
-                ));
+                log::error!(
+                    concat!(
+                        "failed to enumerate {} from globs, ",
+                        "see above for more details"
+                    ),
+                    what
+                );
                 return Err(AlreadyReportedToCommandline);
             }
 
             files
         };
 
-        if report_paths_from_glob.is_empty() && !report_globs.is_empty() {
-            if report_paths.is_empty() {
-                log::error!(concat!(
-                    "reports were specified exclusively via glob search, ",
-                    "but none were found; bailing"
-                ));
+        if paths_from_globs.is_empty() && !globs.is_empty() {
+            if paths.is_empty() {
+                log::error!(
+                    concat!(
+                        "{} were specified exclusively via glob search, ",
+                        "but none were found; bailing"
+                    ),
+                    what
+                );
                 return Err(AlreadyReportedToCommandline);
             } else {
-                log::warn!(concat!(
-                    "reports were specified via path and glob search, ",
-                    "but none were found via glob; ",
-                    "continuing with report paths"
-                ))
+                log::warn!(
+                    concat!(
+                        "{} were specified via path and glob search, ",
+                        "but none were found via glob; ",
+                        "continuing with direct paths"
+                    ),
+                    what
+                )
             }
         }
 
-        let exec_report_paths = report_paths
+        let exec_report_paths = paths
             .into_iter()
-            .chain(report_paths_from_glob)
+            .chain(paths_from_globs)
             .collect::<Vec<_>>();
 
-        log::trace!("working with the following WPT report files: {exec_report_paths:#?}");
-        log::info!("working with {} WPT report files", exec_report_paths.len());
+        log::trace!("working with the following {what}: {exec_report_paths:#?}");
+        log::info!("working with {} {what}", exec_report_paths.len());
 
         Ok(exec_report_paths)
     }
 }
 
+impl ExecReportSpec {
+    fn paths(self) -> Result<Vec<PathBuf>, AlreadyReportedToCommandline> {
+        let Self {
+            report_paths,
+            report_globs,
+        } = self;
+
+        FileSpec {
+            paths: report_paths,
+            globs: report_globs,
+        }
+        .into_paths("WPT report(s)")
+    }
+}
+
 #[derive(Clone, Copy, Debug, ValueEnum)]
 enum UpdateExpectedPreset {
     /// alias: `new-fx`