wip!: blame + deletion based no-history derivation

Author: oahshtsua

src/commands.rs

@@ -3,7 +3,7 @@ pub mod diff;
 pub mod init;
 pub mod list;
 
-pub use derive::derive;
+pub use derive::{derive, derive_no_history};
 pub use diff::diff;
 pub use init::init;
 pub use list::list;

src/commands/derive.rs

@@ -1,6 +1,11 @@
 use anyhow::{Context, Result};
-use git2::{Diff, Index, IndexEntry, IndexTime, Oid, Repository, Signature, Sort, Tree};
+use git2::{
+    BlameOptions, Diff, Index, IndexEntry, IndexTime, Oid, Repository, Signature, Sort, Status,
+    Tree, TreeWalkResult,
+};
 use regex::Regex;
+use std::fs::File;
+use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
 
 use std::collections::{HashMap, HashSet};
@@ -263,6 +268,90 @@ pub fn derive(repo: &Repository, name: &str, features: &[String]) -> Result<()>
     Ok(())
 }
 
+pub fn derive_no_history(repo: &Repository, name: &str, features: &[String]) -> Result<()> {
+    let statuses = repo.statuses(None)?;
+    for entry in statuses.iter() {
+        let s = entry.status();
+        if s != Status::CURRENT {
+            println!("Repository is not clean!");
+            return Ok(());
+        }
+    }
+
+    let ref_name = format!("refs/heads/variant/{name}");
+    let sig = repo.signature()?;
+    let variant_head_oid = create_variant_initial_commit(repo, &ref_name, &sig)?;
+
+    let target_features: HashSet<String> = features.iter().cloned().collect();
+    let head = repo.head()?;
+    let tree = head.peel_to_tree()?;
+
+    let mut tree_builder = repo.treebuilder(None)?;
+
+    tree.walk(git2::TreeWalkMode::PreOrder, |root, entry| {
+        if let Some(name) = entry.name() {
+            let path = Path::new(root).join(name);
+            let content = process_file(repo, &path, &target_features).unwrap();
+
+            let oid = repo.blob(content.as_bytes()).unwrap();
+            tree_builder.insert(path, oid, 0o100644).unwrap();
+        }
+        TreeWalkResult::Ok
+    })?;
+
+    let variant_tree_oid = tree_builder.write()?;
+    let variant_tree = repo.find_tree(variant_tree_oid)?;
+    let variant_parent = repo.find_commit(variant_head_oid)?;
+
+    repo.commit(
+        Some(&ref_name),
+        &sig,
+        &sig,
+        "derive no history",
+        &variant_tree,
+        &[&variant_parent],
+    )?;
+    Ok(())
+}
+
+fn process_file(
+    repo: &Repository,
+    name: &PathBuf,
+    target_features: &HashSet<String>,
+) -> Result<String> {
+    let file = File::open(name)?;
+    let reader = BufReader::new(file);
+    let mut lines: Vec<String> = reader.lines().collect::<Result<_, _>>()?;
+
+    let mut commit_cache: HashMap<Oid, bool> = HashMap::new();
+
+    let mut blame_opts = BlameOptions::new();
+    let blame = repo.blame_file(Path::new(name), Some(&mut blame_opts))?;
+
+    for (i, line) in lines.iter_mut().enumerate() {
+        let line_no = i + 1;
+
+        let hunk = blame
+            .get_line(line_no)
+            .context("Cant get line info in hunk")?;
+
+        let oid = hunk.final_commit_id();
+
+        let contains_feature = commit_cache.entry(oid).or_insert_with(|| {
+            let commit = repo.find_commit(oid).unwrap();
+            let summary = commit.summary().unwrap();
+            extract_scope(summary).is_some_and(|feature| target_features.contains(feature))
+        });
+
+        if !*contains_feature {
+            *line = String::new();
+        }
+    }
+
+    // lines.retain(|line| !line.is_empty());
+    Ok(lines.join("\n"))
+}
+
 // TODO: building each time can be expensive. Look for an alternative
 fn extract_scope(commit: &str) -> Option<&str> {
     let re = Regex::new(r"^(?P<type>[a-z]+)(?:\((?P<scope>[^)]+)\))?(?P<breaking>!)?:").unwrap();

src/main.rs

@@ -22,6 +22,9 @@ enum Commands {
         /// The set of features to use for the derivation
         #[arg(short, long = "feature", required = true)]
         features: Vec<String>,
+        /// use the no-history derivation
+        #[arg(long = "history")]
+        history: bool,
     },
     /// List the commits exist in the target branch but not in the current branch
     Diff {
@@ -47,8 +50,17 @@ fn main() -> Result<()> {
         Commands::Init => {
             commands::init(&repo).context("Failed to initialize VMS support")?;
         }
-        Commands::Derive { name, features } => {
-            commands::derive(&repo, &name, &features).context("Failed to derive variant")?;
+        Commands::Derive {
+            name,
+            features,
+            history,
+        } => {
+            if history {
+                commands::derive(&repo, &name, &features).context("Failed to derive variant")?;
+            } else {
+                commands::derive_no_history(&repo, &name, &features)
+                    .context("Failed to derive variant")?;
+            }
         }
         Commands::Diff { target, reverse } => {
             commands::diff(&repo, &target, reverse).context(format!(