pkgs/rollup: Finish first mvp

1 files changed, 120 insertions, 80 deletions

diff --git a/pkgs/by-name/ro/rollup/src/main.rs b/pkgs/by-name/ro/rollup/src/main.rs
index 8285e702..48b395a5 100644
--- a/pkgs/by-name/ro/rollup/src/main.rs
+++ b/pkgs/by-name/ro/rollup/src/main.rs
@@ -1,105 +1,145 @@
-use core::fmt;
-use std::{path::PathBuf, process::Command};
+use std::{
+    io::Write,
+    path::PathBuf,
+    process::{Command, Stdio},
+};
 
-use anyhow::{Context, Result};
+use anyhow::{Context, Result, bail};
 use clap::Parser;
 
+use crate::parse::Patch;
+
+mod parse;
+
 #[derive(Parser)]
 struct Cli {
     /// The file to pull the patch to rollup from.
-    patch_file: PathBuf,
-}
+    patch_files: Vec<PathBuf>,
 
-struct Diff {
-    files: Vec<FileDiff>,
-}
-
-struct FileDiff {
-    from: PathBuf,
+    /// Which repository to use as a target for the rollup
+    ///
+    /// Needs to be clean.
+    #[arg(short, long)]
     to: PathBuf,
-    diff: String,
-    index: String,
-}
 
-impl fmt::Display for FileDiff {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(
-            f,
-            "diff --git a/{} b/{}",
-            self.from.display(),
-            self.to.display()
-        )?;
-        writeln!(f, "--- a/{}", self.from.display())?;
-        writeln!(f, "+++ b/{}", self.to.display())?;
-        writeln!(f, "index {}", self.index)?;
-        writeln!(f, "{}", self.diff)?;
-
-        Ok(())
-    }
-}
-
-macro_rules! take {
-    ($line:expr, $prefix:literal) => {
-        $line.strip_prefix($prefix).unwrap().trim()
-    };
+    #[arg(short, long)]
+    debug: bool,
 }
 
 fn main() -> Result<()> {
     let args = Cli::parse();
 
-    let data = Command::new("filterdiff")
-        .arg(&args.patch_file)
-        .output()
-        .context("Failed to run `filterdiff` for patch analysis")?;
+    let mut patches = vec![];
+    for file in &args.patch_files {
+        patches.push(parse::parse_file(file, args.debug)?);
+    }
 
-    let stdout = String::from_utf8(data.stdout).unwrap();
+    eprintln!("Successfully parsed all {} patch files.", patches.len());
 
-    let mut diff = Diff { files: vec![] };
-    let mut file_diff_from = None;
-    let mut file_diff_to = None;
-    let mut file_diff_diff: Option<String> = None;
-    let mut file_diff_index: Option<String> = None;
-    for (idx, line) in stdout.lines().enumerate() {
-        eprintln!("{}", line);
+    {
+        let git_check = Command::new("git")
+            .args([
+                "-C",
+                args.to.display().to_string().as_str(),
+                "status",
+                "--porcelain",
+            ])
+            .output()
+            .context("Failed to run `git status --procelain`")?;
+        if !git_check.stdout.is_empty() {
+            bail!(
+                "`--to` (`{}`) workspace is dirty, refusing to continue.",
+                args.to.display()
+            );
+        }
+    }
 
-        if line.starts_with("---") {
-            file_diff_from = Some(PathBuf::from(take!(line, "--- a/")));
-        } else if line.starts_with("+++") {
-            file_diff_to = Some(PathBuf::from(take!(line, "+++ b/")));
-        } else if line.starts_with("index") {
-            file_diff_index = Some(take!(line, "index").to_owned());
-        } else if line.starts_with("diff --git") {
-            if idx != 0 {
-                diff.files.push(FileDiff {
-                    from: file_diff_from.take().unwrap(),
-                    to: file_diff_to.take().unwrap(),
-                    diff: file_diff_diff.take().unwrap(),
-                    index: file_diff_index.take().unwrap(),
-                });
-            }
-        } else {
-            match file_diff_diff.as_mut() {
-                Some(str) => {
-                    str.push_str(line);
-                    str.push('\n');
+    for (idx, patch) in patches.iter().enumerate() {
+        eprintln!(
+            "Applying {}. patch: `{}`...",
+            idx + 1,
+            args.patch_files[idx].display()
+        );
+
+        let mut final_diffs = vec![];
+        for file_diff in &patch.files {
+            match file_diff {
+                parse::FileDiff::Add { path, .. } => {
+                    if args.to.join(path).exists() {
+                        bail!("A file was added, that already existed. This should be impossible.")
+                    }
+                    final_diffs.push(file_diff.to_owned());
                 }
-                None => {
-                    let mut base = line.to_owned();
-                    base.push('\n');
-                    file_diff_diff = Some(base);
+                parse::FileDiff::Remove { path, .. } => {
+                    if args.to.join(path).exists() {
+                        final_diffs.push(file_diff.to_owned());
+                    } else {
+                        eprintln!(
+                            "Dropping remove of `{}`, as the file does not exist in the rollup target.",
+                            path.display()
+                        );
+                    }
+                }
+                parse::FileDiff::Change { from, to, .. } => {
+                    if args.to.join(from).exists() {
+                        if from != to && args.to.join(to).exists() {
+                            bail!(
+                                "A rename (`{}` -> `{}`) tried to rename a path to an already existing path. This should be impossible.",
+                                from.display(),
+                                to.display()
+                            )
+                        }
+                        final_diffs.push(file_diff.to_owned());
+                    } else {
+                        eprintln!(
+                            "Dropping change to `{}`, as the file does not exist in the rollup target.",
+                            from.display()
+                        );
+                    }
                 }
             }
         }
-    }
-    diff.files.push(FileDiff {
-        from: file_diff_from.unwrap(),
-        to: file_diff_to.unwrap(),
-        diff: file_diff_diff.unwrap(),
-        index: file_diff_index.unwrap(),
-    });
 
-    for file in diff.files {
-        eprintln!("{}", file)
+        let filtered_patch = Patch {
+            files: final_diffs,
+            commit_message: patch.commit_message.clone(),
+        };
+
+        let mut apply_child = Command::new("git")
+            .args(["-C", args.to.display().to_string().as_str(), "apply", "-"])
+            .stdin(Stdio::piped())
+            .spawn()?;
+        let mut stdin = apply_child.stdin.take().expect("is piped");
+        write!(stdin, "{}", filtered_patch)?;
+        drop(stdin);
+        let status = apply_child.wait()?;
+        if !status.success() {
+            bail!("git apply failed.")
+        }
+
+        let add = Command::new("git")
+            .args(["-C", args.to.display().to_string().as_str(), "add", "."])
+            .status()?;
+        if !add.success() {
+            bail!("git add ., failed.")
+        }
+
+        let mut commit_child = Command::new("git")
+            .args([
+                "-C",
+                args.to.display().to_string().as_str(),
+                "commit",
+                "--file=-",
+            ])
+            .stdin(Stdio::piped())
+            .spawn()?;
+        let mut stdin = commit_child.stdin.take().expect("is piped");
+        write!(stdin, "{}", filtered_patch.commit_message)?;
+        drop(stdin);
+        let status = apply_child.wait()?;
+        if !status.success() {
+            bail!("git commit failed.")
+        }
     }
 
     Ok(())