internal: refactor render

crates/moonbuild/src/entry.rs

@@ -67,23 +67,17 @@ pub fn n2_run_interface(
     output_path: PathBuf,
 ) -> anyhow::Result<Option<usize>> {
     let logger = Arc::new(Mutex::new(vec![]));
+    let use_fancy = terminal::use_fancy();
 
     let catcher = logger.clone();
     let render_and_catch = move |output: &str| {
-        let raw_content_lines: Vec<&str> = output.split('\n').filter(|it| !it.is_empty()).collect();
-
-        for output_content in raw_content_lines {
-            catcher.lock().unwrap().push(output_content.to_owned());
-            match serde_json_lenient::from_str::<moonutil::render::MooncDiagnostic>(output_content)
-            {
-                Ok(report) => {
-                    report.render();
-                }
-                Err(_) => {
-                    println!("{}", output_content);
-                }
-            }
-        }
+        output
+            .split('\n')
+            .filter(|it| !it.is_empty())
+            .for_each(|content| {
+                catcher.lock().unwrap().push(content.to_owned());
+                moonutil::render::MooncDiagnostic::render(content, use_fancy);
+            });
     };
 
     let mut progress = create_progress_console(false, quiet, Some(Box::new(render_and_catch)));
@@ -118,17 +112,12 @@ pub fn n2_run_interface(
         let raw_json = std::fs::read_to_string(&output_path)
             .context(format!("failed to open `{}`", output_path.display()))?;
 
-        let raw_json_lines: Vec<&str> = raw_json.split('\n').filter(|it| !it.is_empty()).collect();
-        for line in raw_json_lines {
-            match serde_json_lenient::from_str::<moonutil::render::MooncDiagnostic>(line) {
-                Ok(report) => {
-                    report.render();
-                }
-                Err(_) => {
-                    println!("{}", line);
-                }
-            }
-        }
+        raw_json
+            .split('\n')
+            .filter(|it| !it.is_empty())
+            .for_each(|content| {
+                moonutil::render::MooncDiagnostic::render(content, use_fancy);
+            });
     } else {
         let mut output_file = std::fs::File::create(output_path)?;
 

crates/moonutil/Cargo.toml

@@ -22,6 +22,8 @@ semver.workspace = true
 fs4.workspace = true
 petgraph.workspace = true
 ariadne.workspace = true
+env_logger.workspace = true
+log.workspace = true
 
 [dev-dependencies]
 expect-test.workspace = true

crates/moonutil/src/render.rs

@@ -25,34 +25,57 @@ pub struct Position {
 }
 
 impl MooncDiagnostic {
-    pub fn render(&self) {
-        let (kind, color) = self.get_level_and_color();
+    pub fn render(content: &str, use_fancy: bool) {
+        match serde_json_lenient::from_str::<MooncDiagnostic>(content) {
+            Ok(diagnostic) => {
+                let (kind, color) = diagnostic.get_level_and_color();
 
-        // for no-location diagnostic, like Missing main function in the main package(4067)
-        if self.location.path.is_empty() {
-            println!(
-                "{}",
-                format!("[{}] {}: {}", self.error_code, kind, self.message).fg(color)
-            );
-        } else {
-            let source_file_path = &self.location.path;
-            let source_file = std::fs::read_to_string(source_file_path)
-                .unwrap_or_else(|_| panic!("failed to read {}", source_file_path));
+                // for no-location diagnostic, like Missing main function in the main package(4067)
+                if diagnostic.location.path.is_empty() {
+                    println!(
+                        "{}",
+                        format!(
+                            "[{}] {}: {}",
+                            diagnostic.error_code, kind, diagnostic.message
+                        )
+                        .fg(color)
+                    );
+                } else {
+                    let source_file_path = &diagnostic.location.path;
+                    let source_file = std::fs::read_to_string(source_file_path)
+                        .unwrap_or_else(|_| panic!("failed to read {}", source_file_path));
 
-            ariadne::Report::build(kind, source_file_path, self.location.start.offset as usize)
-                .with_code(self.error_code)
-                .with_message(&self.message)
-                .with_label(
-                    ariadne::Label::new((
+                    let mut report_builder = ariadne::Report::build(
+                        kind,
                         source_file_path,
-                        self.location.start.offset as usize..self.location.end.offset as usize,
-                    ))
-                    .with_message((&self.message).fg(color))
-                    .with_color(color),
-                )
-                .finish()
-                .print((source_file_path, ariadne::Source::from(source_file)))
-                .unwrap();
+                        diagnostic.location.start.offset as usize,
+                    )
+                    .with_code(diagnostic.error_code)
+                    .with_message(&diagnostic.message)
+                    .with_label(
+                        ariadne::Label::new((
+                            source_file_path,
+                            diagnostic.location.start.offset as usize
+                                ..diagnostic.location.end.offset as usize,
+                        ))
+                        .with_message((&diagnostic.message).fg(color))
+                        .with_color(color),
+                    );
+
+                    if !use_fancy {
+                        let config = ariadne::Config::default().with_color(false);
+                        report_builder = report_builder.with_config(config);
+                    }
+
+                    report_builder
+                        .finish()
+                        .print((source_file_path, ariadne::Source::from(source_file)))
+                        .unwrap();
+                }
+            }
+            Err(_) => {
+                println!("{}", content);
+            }
         }
     }