implement patch manually without using external software

sys/Cargo.toml

@@ -12,6 +12,9 @@ repository = "https://github.com/DelSkayn/rquickjs.git"
 
 [build-dependencies]
 cc = "1"
+diffy = "0.3.0"
+newline-converter = "0.3.0"
+path-absolutize = "3.1.1"
 
 [build-dependencies.bindgen-rs]
 package = "bindgen"

sys/build.rs

@@ -1,10 +1,12 @@
 use std::{
     env, fs,
-    io::Write,
-    path::Path,
-    process::{Command, Stdio},
+    path::{Path, PathBuf},
 };
 
+use diffy::{apply, Patch};
+use newline_converter::dos2unix;
+use path_absolutize::Absolutize;
+
 fn main() {
     #[cfg(feature = "logging")]
     pretty_env_logger::init();
@@ -131,21 +133,87 @@ fn feature_to_define(name: impl AsRef<str>) -> String {
 }
 
 fn patch<D: AsRef<Path>, P: AsRef<Path>>(out_dir: D, patch: P) {
-    let mut child = Command::new("patch")
-        .args(["-p1"])
-        .stdin(Stdio::piped())
-        .current_dir(out_dir)
-        .spawn()
-        .expect("Unable to execute patch, you may need to install it: {}");
-    println!("Applying patch {}", patch.as_ref().display());
-    {
-        let patch = fs::read(patch).expect("Unable to read patch");
-
-        let stdin = child.stdin.as_mut().unwrap();
-        stdin.write_all(&patch).expect("Unable to apply patch");
+    struct Patches<'a>(&'a str);
+
+    // A backtracking attempt to find a valid diff when there are multiple patches in one file (also known as patchset)
+    impl<'a> Iterator for Patches<'a> {
+        type Item = Patch<'a, str>;
+        fn next(&mut self) -> Option<Self::Item> {
+            let mut range = self.0.len();
+
+            loop {
+                let input = if let Some(input) = self.0.get(..range) {
+                    input
+                } else {
+                    range -= 1;
+                    continue;
+                };
+                match Patch::from_str(input) {
+                    Ok(x) if x.hunks().is_empty() => break None,
+                    Err(_) if range < 1 => break None,
+                    Ok(x) => {
+                        self.0 = &self.0[range..];
+                        break Some(x);
+                    }
+                    Err(_) => range -= 1,
+                }
+            }
+        }
     }
 
-    child.wait_with_output().expect("Unable to apply patch");
+    println!("Appliyng patch {}", patch.as_ref().display());
+    {
+        let out_dir = out_dir.as_ref();
+        let patch = fs::read_to_string(patch).expect("Unable to read patch");
+        let patch = dos2unix(&patch);
+        for patch in Patches(&patch) {
+            let original = patch
+                .original()
+                .and_then(|x| {
+                    if x.chars().next().unwrap_or_default() == '/' {
+                        Some(x)
+                    } else {
+                        x.split_once('/').map(|(_, b)| b)
+                    }
+                })
+                .or(patch.original())
+                .expect("Cannot find original file name");
+            let modified = patch
+                .modified()
+                .and_then(|x| x.split_once('/').map(|(_, b)| b))
+                .or(patch.modified())
+                .expect("Cannot find modified file name");
+
+            let original_path = if original.chars().next().unwrap_or_default() == '/' {
+                PathBuf::new()
+            } else {
+                out_dir.to_path_buf()
+            }
+            .join(original)
+            .absolutize()
+            .unwrap()
+            .to_path_buf();
+            let modified_path = out_dir.join(modified).absolutize().unwrap().to_path_buf();
+
+            let original = if !original_path.exists() {
+                String::new()
+            } else {
+                fs::read_to_string(original_path).expect("Unable to read original file")
+            };
+            let original = dos2unix(&original);
+            match apply(&original, &patch) {
+                Ok(patched) => {
+                    if let Some(parent) = modified_path.parent() {
+                        if !parent.exists() {
+                            fs::create_dir_all(parent).unwrap();
+                        }
+                    }
+                    fs::write(modified_path, patched).expect("Unable to write the patched content")
+                }
+                Err(e) => eprintln!("Unable to write the patched content: {}", e),
+            }
+        }
+    }
 }
 
 #[cfg(not(feature = "bindgen"))]