Clean up patch code, add nice output

Author: NicholasLYang

Cargo.lock

@@ -69,6 +69,7 @@ human-panic = "1.2.1"
 human_format = "1.1.0"
 humantime = "2.1.0"
 ignore = "0.4.22"
+indicatif = { workspace = true }
 itertools = { workspace = true }
 jsonc-parser = { version = "0.21.0" }
 lazy_static = { workspace = true }

crates/turborepo-lib/Cargo.toml

@@ -4,7 +4,7 @@ mod tags;
 mod tsconfig;
 
 use std::{
-    collections::{HashMap, HashSet},
+    collections::{BTreeMap, HashMap, HashSet},
     fs::OpenOptions,
     io::Write,
     sync::{Arc, LazyLock, Mutex},
@@ -13,6 +13,7 @@ use std::{
 pub use config::{BoundariesConfig, Permissions, Rule};
 use git2::Repository;
 use globwalk::Settings;
+use indicatif::ProgressIterator;
 use miette::{Diagnostic, NamedSource, Report, SourceSpan};
 use regex::Regex;
 use swc_common::{
@@ -235,7 +236,8 @@ impl Run {
         let repo = Repository::discover(self.repo_root()).ok().map(Mutex::new);
         let mut result = BoundariesResult::default();
         let global_implicit_dependencies = self.get_implicit_dependencies(&PackageName::Root);
-        for (package_name, package_info) in packages {
+        println!("Checking packages...");
+        for (package_name, package_info) in packages.into_iter().progress() {
             if !self.filtered_pkgs().contains(package_name)
                 || matches!(package_name, PackageName::Root)
             {
@@ -475,43 +477,56 @@ impl Run {
         Ok(())
     }
 
-    pub fn add_ignore(
+    pub fn patch_file(
         &self,
         file_path: &AbsoluteSystemPath,
-        span: SourceSpan,
-        reason: String,
+        file_patches: Vec<(SourceSpan, String)>,
     ) -> Result<(), Error> {
+        // Deduplicate and sort by offset
+        let file_patches = file_patches
+            .into_iter()
+            .map(|(span, patch)| (span.offset(), patch.into()))
+            .collect::<BTreeMap<usize, String>>();
+
         let contents = file_path
             .read_to_string()
             .map_err(|_| Error::FileNotFound(file_path.to_owned()))?;
-        let contents_before_span = &contents[..span.offset()];
 
-        // Find the last newline before the span
-        let newline_idx = contents_before_span.rfind('\n');
         let mut options = OpenOptions::new();
         options.read(true).write(true).truncate(true);
         let mut file = file_path
             .open_with_options(options)
             .map_err(|_| Error::FileNotFound(file_path.to_owned()))?;
 
-        if let Some(newline_idx) = newline_idx {
-            file.write_all(contents[..newline_idx].as_bytes())
-                .map_err(|_| Error::FileWriteError(file_path.to_owned()))?;
-            file.write_all(b"\n")
-                .map_err(|_| Error::FileWriteError(file_path.to_owned()))?;
+        let mut last_idx = 0;
+        for (idx, reason) in file_patches {
+            let contents_before_span = &contents[last_idx..idx];
+
+            // Find the last newline before the span (note this is the index into the slice,
+            // not the full file)
+            let newline_idx = contents_before_span.rfind('\n');
+
+            // If newline exists, we write all the contents before newline
+            if let Some(newline_idx) = newline_idx {
+                file.write_all(contents[last_idx..(last_idx + newline_idx)].as_bytes())
+                    .map_err(|_| Error::FileWriteError(file_path.to_owned()))?;
+                file.write_all(b"\n")
+                    .map_err(|_| Error::FileWriteError(file_path.to_owned()))?;
+            }
+
             file.write_all(b"// @boundaries-ignore ")
                 .map_err(|_| Error::FileWriteError(file_path.to_owned()))?;
             file.write_all(reason.as_bytes())
                 .map_err(|_| Error::FileWriteError(file_path.to_owned()))?;
-            file.write_all(contents[newline_idx..].as_bytes())
-                .map_err(|_| Error::FileWriteError(file_path.to_owned()))?;
-        } else {
-            file.write_all(b"// @boundaries-ignore\n")
-                .map_err(|_| Error::FileWriteError(file_path.to_owned()))?;
-            file.write_all(contents.as_bytes())
+            file.write_all(b"\n")
                 .map_err(|_| Error::FileWriteError(file_path.to_owned()))?;
+
+            last_idx = idx;
         }
 
+        file.write_all(contents[last_idx..].as_bytes())
+            .map_err(|_| Error::FileWriteError(file_path.to_owned()))?;
+
         Ok(())
     }
 }

crates/turborepo-lib/src/boundaries/mod.rs

@@ -1,7 +1,8 @@
-use std::collections::HashSet;
+use std::collections::HashMap;
 
 use dialoguer::{Confirm, Input};
-use miette::Report;
+use miette::{Report, SourceSpan};
+use turbopath::AbsoluteSystemPath;
 use turborepo_signals::{listeners::get_signal, SignalHandler};
 use turborepo_telemetry::events::command::CommandEventBuilder;
 use turborepo_ui::{color, BOLD_GREEN};
@@ -25,20 +26,11 @@ pub async fn run(
     let result = run.check_boundaries().await?;
 
     if let Some(ignore) = ignore {
-        let mut seen_locations = HashSet::new();
+        let mut patches: HashMap<&AbsoluteSystemPath, Vec<(SourceSpan, String)>> = HashMap::new();
         for diagnostic in &result.diagnostics {
             let Some((path, span)) = diagnostic.path_and_span() else {
                 continue;
             };
-            if seen_locations.contains(&(path, span)) {
-                continue;
-            }
-            seen_locations.insert((path, span));
-
-            let short_path = match run.repo_root().anchor(path) {
-                Ok(path) => path.to_string(),
-                Err(_) => path.to_string(),
-            };
 
             let reason = match ignore {
                 BoundariesIgnore::All => Some(reason.clone().unwrap_or_else(|| {
@@ -47,6 +39,10 @@ pub async fn run(
                 BoundariesIgnore::Prompt => {
                     print!("\x1B[2J\x1B[1;1H");
                     println!("{:?}", Report::new(diagnostic.clone()));
+                    let short_path = match run.repo_root().anchor(path) {
+                        Ok(path) => path.to_string(),
+                        Err(_) => path.to_string(),
+                    };
                     let prompt = format!("Add @boundaries-ignore to {}?", short_path);
                     if Confirm::new()
                         .with_prompt(prompt)
@@ -69,14 +65,22 @@ pub async fn run(
             };
 
             if let Some(reason) = reason {
-                println!(
-                    "{} {}",
-                    color!(run.color_config(), BOLD_GREEN, "patching"),
-                    short_path
-                );
-                run.add_ignore(path, span, reason)?;
+                patches.entry(path).or_default().push((span, reason));
             }
         }
+
+        for (path, file_patches) in patches {
+            let short_path = match run.repo_root().anchor(path) {
+                Ok(path) => path.to_string(),
+                Err(_) => path.to_string(),
+            };
+            println!(
+                "{} {}",
+                color!(run.color_config(), BOLD_GREEN, "patching"),
+                short_path
+            );
+            run.patch_file(path, file_patches)?;
+        }
     } else {
         result.emit(run.color_config());
     }