Cleanup file status logging

Author: Hendrik van Antwerpen

tree-sitter-stack-graphs/src/cli/analyze.rs

@@ -6,9 +6,9 @@
 // ------------------------------------------------------------------------------------------------
 
 use anyhow::anyhow;
+use anyhow::Context as _;
 use clap::Args;
 use clap::ValueHint;
-use colored::Colorize as _;
 use stack_graphs::graph::StackGraph;
 use stack_graphs::partial::PartialPaths;
 use stack_graphs::stitching::Database;
@@ -29,6 +29,8 @@ use crate::CancellationFlag;
 use crate::LoadError;
 use crate::NoCancellation;
 
+use super::util::FileStatusLogger;
+
 /// Analyze sources
 #[derive(Args)]
 pub struct AnalyzeArgs {
@@ -75,31 +77,25 @@ impl AnalyzeArgs {
                     .filter(|e| e.file_type().is_file())
                 {
                     let source_path = source_entry.path();
-                    self.run_with_context(source_root, source_path, loader)?;
+                    self.analyze_file_with_context(source_root, source_path, loader)?;
                 }
             } else {
                 let source_root = source_path.parent().unwrap();
-                self.run_with_context(source_root, source_path, loader)?;
+                self.analyze_file_with_context(source_root, source_path, loader)?;
             }
         }
         Ok(())
     }
 
-    /// Run test file and add error context to any failures that are returned.
-    fn run_with_context(
+    /// Analyze file and add error context to any failures that are returned.
+    fn analyze_file_with_context(
         &self,
         source_root: &Path,
         source_path: &Path,
         loader: &mut Loader,
     ) -> anyhow::Result<()> {
-        let result = self.analyze_file(source_root, source_path, loader);
-        if result.is_err() {
-            if !self.verbose {
-                eprint!("{}: ", source_path.display());
-            }
-            eprintln!("{}", "error".red());
-        }
-        result
+        self.analyze_file(source_root, source_path, loader)
+            .with_context(|| format!("Error analyzing file {}", source_path.display()))
     }
 
     fn analyze_file(
@@ -108,38 +104,31 @@ impl AnalyzeArgs {
         source_path: &Path,
         loader: &mut Loader,
     ) -> anyhow::Result<()> {
-        let mut cancellation_flag: Arc<dyn CancellationFlag> = Arc::new(NoCancellation);
-        if let Some(max_file_time) = self.max_file_time {
-            cancellation_flag = CancelAfterDuration::new(max_file_time);
-        }
+        let mut file_status = FileStatusLogger::new(source_path, self.verbose);
 
         let source = std::fs::read_to_string(source_path)?;
-        let lc = match loader.load_for_file(source_path, Some(&source), cancellation_flag.as_ref())
-        {
+        let lc = match loader.load_for_file(source_path, Some(&source), &NoCancellation) {
             Ok(Some(sgl)) => sgl,
             Ok(None) => return Ok(()),
             Err(crate::loader::LoadError::Cancelled(_)) => {
-                eprintln!(
-                    "{}: {}",
-                    source_path.display(),
-                    "language loading timed out".yellow()
-                );
+                file_status.warn("language loading timed out")?;
                 return Ok(());
             }
-            Err(e) => {
-                eprint!("{}: ", source_path.display());
-                return Err(e.into());
-            }
+            Err(e) => return Err(e.into()),
         };
 
-        if self.verbose {
-            eprint!("{}: ", source_path.display());
+        let mut cancellation_flag: Arc<dyn CancellationFlag> = Arc::new(NoCancellation);
+        if let Some(max_file_time) = self.max_file_time {
+            cancellation_flag = CancelAfterDuration::new(max_file_time);
         }
 
+        file_status.processing()?;
+
         let mut graph = StackGraph::new();
-        let file = graph
-            .add_file(&source_path.to_string_lossy())
-            .map_err(|_| anyhow!("Duplicate file {}", source_path.display()))?;
+        let file = match graph.add_file(&source_path.to_string_lossy()) {
+            Ok(file) => file,
+            Err(_) => return Err(anyhow!("Duplicate file {}", source_path.display())),
+        };
 
         let relative_source_path = source_path.strip_prefix(source_root).unwrap();
         let result = if let Some(fa) = source_path
@@ -168,18 +157,12 @@ impl AnalyzeArgs {
         match result {
             Err(LoadError::ParseErrors(parse_errors)) => {
                 let parse_error = map_parse_errors(source_path, &parse_errors, &source, "");
-                if !self.verbose {
-                    eprint!("{}: ", source_path.display());
-                }
-                eprintln!("{}", "parsing failed".red());
+                file_status.error("parsing failed")?;
                 eprintln!("{}", parse_error);
                 return Ok(());
             }
             Err(LoadError::Cancelled(_)) => {
-                if !self.verbose {
-                    eprint!("{}: ", source_path.display());
-                }
-                eprintln!("{}", "parsing timed out".yellow());
+                file_status.warn("parsing timed out")?;
                 return Ok(());
             }
             Err(e) => return Err(e.into()),
@@ -200,17 +183,12 @@ impl AnalyzeArgs {
         ) {
             Ok(_) => {}
             Err(_) => {
-                if !self.verbose {
-                    eprint!("{}: ", source_path.display());
-                }
-                eprintln!("{}", "path computation timed out".yellow());
+                file_status.warn("path computation timed out")?;
                 return Ok(());
             }
         }
 
-        if self.verbose {
-            eprintln!("{}", "success".green());
-        }
+        file_status.ok("success")?;
         Ok(())
     }
 }

tree-sitter-stack-graphs/src/cli/util.rs

@@ -6,8 +6,10 @@
 // ------------------------------------------------------------------------------------------------
 
 use anyhow::anyhow;
+use colored::Colorize;
 use std::ffi::OsStr;
 use std::ffi::OsString;
+use std::io::Write;
 use std::path::Path;
 use std::path::PathBuf;
 use std::time::Duration;
@@ -157,3 +159,56 @@ pub fn map_parse_errors(
 pub fn duration_from_seconds_str(s: &str) -> Result<Duration, anyhow::Error> {
     Ok(Duration::new(s.parse()?, 0))
 }
+
+pub struct FileStatusLogger<'a> {
+    path: &'a Path,
+    verbose: bool,
+    path_logged: bool,
+}
+
+impl<'a> FileStatusLogger<'a> {
+    pub fn new(path: &'a Path, verbose: bool) -> Self {
+        Self {
+            path,
+            verbose,
+            path_logged: false,
+        }
+    }
+
+    pub fn processing(&mut self) -> Result<(), anyhow::Error> {
+        self.print_path(false)?;
+        Ok(())
+    }
+
+    pub fn ok(&mut self, status: &str) -> Result<(), anyhow::Error> {
+        self.print_path(false)?;
+        if self.verbose {
+            println!("{}", status.green());
+            self.path_logged = false;
+        }
+        Ok(())
+    }
+
+    pub fn warn(&mut self, status: &str) -> Result<(), anyhow::Error> {
+        self.print_path(true)?;
+        println!("{}", status.yellow());
+        self.path_logged = false;
+        Ok(())
+    }
+
+    pub fn error(&mut self, status: &str) -> Result<(), anyhow::Error> {
+        self.print_path(true)?;
+        println!("{}", status.red());
+        self.path_logged = false;
+        Ok(())
+    }
+
+    fn print_path(&mut self, force: bool) -> Result<(), anyhow::Error> {
+        if (self.verbose || force) && !self.path_logged {
+            print!("{}: ", self.path.display());
+            std::io::stdout().flush()?;
+            self.path_logged = true;
+        }
+        Ok(())
+    }
+}