wip!: merging hunks

Author: oahshtsua

src/commands/derive.rs

@@ -1,10 +1,69 @@
 use anyhow::{Context, Result};
-use git2::{Repository, Signature, Sort};
+use git2::{Index, IndexEntry, IndexTime, Repository, Signature, Sort, Tree};
 use regex::Regex;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use std::collections::{HashMap, HashSet};
 
+fn get_file_bytes_from_tree(repo: &Repository, tree: &Tree, path: &Path) -> Result<Vec<u8>> {
+    match tree.get_path(path) {
+        Ok(entry) => {
+            let blob = repo.find_blob(entry.id())?;
+            Ok(blob.content().to_vec())
+        }
+        Err(_) => Ok(Vec::new()),
+    }
+}
+
+fn split_lines_including_newline(bytes: &[u8]) -> Vec<Vec<u8>> {
+    let mut out = Vec::new();
+    let mut start = 0usize;
+
+    for (i, &b) in bytes.iter().enumerate() {
+        if b == b'\n' {
+            out.push(bytes[start..=i].to_vec());
+            start = i + 1;
+        }
+    }
+
+    if start < bytes.len() {
+        out.push(bytes[start..].to_vec());
+    }
+    out
+}
+
+fn join_lines(lines: &[Vec<u8>]) -> Vec<u8> {
+    let mut out = Vec::new();
+    for line in lines {
+        out.extend_from_slice(line);
+    }
+    out
+}
+
+fn ensure_length(lines: &mut Vec<Vec<u8>>, len: usize) {
+    while lines.len() < len {
+        lines.push(b"\n".to_vec());
+    }
+}
+
+fn apply_additions(mut base: Vec<u8>, mut additions: Vec<(u32, Vec<u8>)>) -> Vec<u8> {
+    additions.sort_by_key(|(ln, _)| *ln);
+    let mut lines = split_lines_including_newline(&base);
+
+    for (new_lineno, content) in additions {
+        let idx = (new_lineno as usize).saturating_sub(1);
+
+        ensure_length(&mut lines, idx);
+        if idx >= lines.len() {
+            lines.push(content);
+        } else {
+            lines.insert(idx, content);
+        }
+    }
+
+    join_lines(&lines)
+}
+
 pub fn derive(repo: &Repository, name: &str, features: &[String]) -> Result<()> {
     println!("Deriving variant '{}' with features: {:?}", name, features);
     // create a new orphan branch
@@ -13,7 +72,6 @@ pub fn derive(repo: &Repository, name: &str, features: &[String]) -> Result<()>
         .write()
         .context("Failed to create empty tree.")?;
     let tree = repo.find_tree(tree_oid)?;
-    println!("Treeid: {:?}", tree_oid);
 
     let sig = Signature::now("user", "user@example.com")?;
 
@@ -83,17 +141,58 @@ pub fn derive(repo: &Repository, name: &str, features: &[String]) -> Result<()>
                 true
             }),
         )?;
-        for (path, contents) in &additions {
-            println!("Path: {:?}", path);
-            for (no, line) in contents {
-                print!("{:?}: {}", no, String::from_utf8_lossy(line));
+
+        // write changes to disk without touching the worktree
+        if !additions.is_empty() {
+            let variant_parent = repo.find_commit(variant_head_oid)?;
+            let variant_tree = variant_parent.tree()?;
+
+            let mut index = Index::new()?;
+            index.read_tree(&variant_tree)?;
+
+            for (path, contents) in additions {
+                let base = get_file_bytes_from_tree(repo, &variant_tree, &path)?;
+                let merged = apply_additions(base, contents);
+
+                let blob_oid = repo.blob(&merged)?;
+                let path_string = path.to_string_lossy().replace('\\', "/");
+                let entry = IndexEntry {
+                    ctime: IndexTime {
+                        seconds: 0,
+                        nanoseconds: 0,
+                    },
+                    mtime: IndexTime {
+                        seconds: 0,
+                        nanoseconds: 0,
+                    },
+                    dev: 0,
+                    ino: 0,
+                    mode: 0o100644,
+                    uid: 0,
+                    gid: 0,
+                    file_size: merged.len() as u32,
+                    id: blob_oid,
+                    flags: 0,
+                    flags_extended: 0,
+                    path: path_string.into_bytes(),
+                };
+                index.add(&entry)?;
             }
+            let new_tree_oid = index.write_tree_to(repo)?;
+            let new_tree = repo.find_tree(new_tree_oid)?;
+
+            let commit_msg = commit.message().unwrap();
+            variant_head_oid = repo.commit(
+                Some(&ref_name),
+                &sig,
+                &sig,
+                &commit_msg,
+                &new_tree,
+                &[&variant_parent],
+            )?;
         }
     }
 
-    // for each commit that is in the specified feature set, extract the delta
-    // put together the delta
-    // add a custom reference to the newly created branch to keep track of variants
     let var_ref_name = format!("refs/variants/{name}");
     let target_ref = repo.find_reference(&ref_name)?;
     let var_ref_target = target_ref.name().context("Branch has invalid UTF-8 name")?;