BUTCLI: add commit marking

Author: krlvi

Cargo.lock

@@ -14,6 +14,7 @@ anyhow = "1.0.99"
 itertools.workspace = true
 serde.workspace = true
 regex = "1.11.2"
+gix = { workspace = true }
 chrono = { version = "0.4.41", features = [] }
 serde_regex = "1.1.0"
 serde_json = "1.0.143"

crates/but-rules/Cargo.toml

@@ -1,7 +1,7 @@
 use but_graph::VirtualBranchesTomlMetadata;
 use but_hunk_assignment::{HunkAssignment, assign, assignments_to_requests};
 use but_hunk_dependency::ui::HunkDependencies;
-use but_workspace::{StackId, StacksFilter, ui::StackEntry};
+use but_workspace::{DiffSpec, StackId, StacksFilter, commit_engine, ui::StackEntry};
 use gitbutler_command_context::CommandContext;
 use itertools::Itertools;
 use std::str::FromStr;
@@ -26,6 +26,9 @@ pub fn process_workspace_rules(
             matches!(
                 &r.action,
                 super::Action::Explicit(super::Operation::Assign { .. })
+            ) || matches!(
+                &r.action,
+                super::Action::Explicit(super::Operation::Amend { .. })
             )
         })
         .collect_vec();
@@ -60,6 +63,10 @@ pub fn process_workspace_rules(
                         handle_assign(ctx, assignments, dependencies.as_ref()).unwrap_or_default();
                 }
             }
+            super::Action::Explicit(super::Operation::Amend { commit_id }) => {
+                let assignments = matching(assignments, rule.filters.clone());
+                handle_amend(ctx, assignments, commit_id).unwrap_or_default();
+            }
             _ => continue,
         };
     }
@@ -137,6 +144,32 @@ fn handle_assign(
     }
 }
 
+fn handle_amend(
+    ctx: &mut CommandContext,
+    assignments: Vec<HunkAssignment>,
+    commit_id: String,
+) -> anyhow::Result<()> {
+    let changes: Vec<DiffSpec> = assignments.into_iter().map(|a| a.into()).collect();
+    let project = ctx.project();
+    let mut guard = project.exclusive_worktree_access();
+    let repo = but_core::open_repo_for_merging(project.worktree_path())?;
+    commit_engine::create_commit_and_update_refs_with_project(
+        &repo,
+        project,
+        None,
+        commit_engine::Destination::AmendCommit {
+            commit_id: gix::ObjectId::from_str(&commit_id)?,
+            // TODO: Expose this in the UI for 'edit message' functionality.
+            new_message: None,
+        },
+        None,
+        changes,
+        ctx.app_settings().context_lines,
+        guard.write_permission(),
+    )?;
+    Ok(())
+}
+
 fn matching(wt_assignments: &[HunkAssignment], filters: Vec<Filter>) -> Vec<HunkAssignment> {
     if filters.is_empty() {
         return wt_assignments.to_vec();

crates/but-rules/src/handler.rs

@@ -46,6 +46,14 @@ impl WorkspaceRule {
         }
     }
 
+    pub fn target_commit_id(&self) -> Option<String> {
+        if let Action::Explicit(Operation::Amend { commit_id }) = &self.action {
+            Some(commit_id.clone())
+        } else {
+            None
+        }
+    }
+
     pub fn id(&self) -> String {
         self.id.clone()
     }

crates/but-rules/src/lib.rs

@@ -100,6 +100,13 @@ pub(crate) fn commit_graph(repo_path: &Path, json: bool, short: bool) -> anyhow:
                 }
             }
             for commit in branch.commits.iter() {
+                let marked =
+                    crate::mark::commit_marked(ctx, commit.id.to_string()).unwrap_or_default();
+                let mark = if marked {
+                    Some("◀ Marked ▶".red().bold())
+                } else {
+                    None
+                };
                 let state_str = match commit.state {
                     but_workspace::ui::CommitState::LocalOnly => "{local}".normal(),
                     but_workspace::ui::CommitState::LocalAndRemote(_) => "{pushed}".cyan(),
@@ -115,14 +122,15 @@ pub(crate) fn commit_graph(repo_path: &Path, json: bool, short: bool) -> anyhow:
                     .format("%Y-%m-%d %H:%M:%S")
                     .to_string();
                 println!(
-                    "{}● {}{} {} {} {} {}",
+                    "{}● {}{} {} {} {} {} {}",
                     "│ ".repeat(nesting),
                     &commit.id.to_string()[..2].blue().underline(),
                     &commit.id.to_string()[2..7].blue(),
                     state_str,
                     conflicted_str,
                     commit.author.name,
-                    time_string.dimmed()
+                    time_string.dimmed(),
+                    mark.clone().unwrap_or_default()
                 );
                 println!(
                     "{}│ {}",

crates/but/src/log/mod.rs

@@ -23,15 +23,41 @@ pub(crate) fn handle(
             target_result
         ));
     }
+    // Hack - delete all other rules
+    for rule in but_rules::list_rules(ctx)? {
+        but_rules::delete_rule(ctx, &rule.id())?;
+    }
     match target_result[0].clone() {
         crate::id::CliId::Branch { name } => mark_branch(ctx, name, delete),
-        crate::id::CliId::Commit { oid } => mark_commit(oid, delete),
+        crate::id::CliId::Commit { oid } => mark_commit(ctx, oid, delete),
         _ => bail!("Nope"),
     }
 }
 
-fn mark_commit(_oid: gix::ObjectId, _delete: bool) -> anyhow::Result<()> {
-    bail!("Not implemented yet");
+fn mark_commit(ctx: &mut CommandContext, oid: gix::ObjectId, delete: bool) -> anyhow::Result<()> {
+    if delete {
+        let rules = but_rules::list_rules(ctx)?;
+        for rule in rules {
+            if rule.target_commit_id() == Some(oid.to_string()) {
+                but_rules::delete_rule(ctx, &rule.id())?;
+            }
+        }
+        println!("Mark was removed");
+        return Ok(());
+    }
+    let action = but_rules::Action::Explicit(Operation::Amend {
+        commit_id: oid.to_string(),
+    });
+    let req = but_rules::CreateRuleRequest {
+        trigger: but_rules::Trigger::FileSytemChange,
+        filters: vec![but_rules::Filter::PathMatchesRegex(regex::Regex::new(
+            ".*",
+        )?)],
+        action,
+    };
+    but_rules::create_rule(ctx, req)?;
+    println!("Changes will be amended into commit → {}", &oid.to_string());
+    Ok(())
 }
 
 fn mark_branch(ctx: &mut CommandContext, branch_name: String, delete: bool) -> anyhow::Result<()> {
@@ -69,3 +95,10 @@ pub(crate) fn stack_marked(ctx: &mut CommandContext, stack_id: StackId) -> anyho
         .any(|r| r.target_stack_id() == Some(stack_id.to_string()));
     Ok(rules)
 }
+
+pub(crate) fn commit_marked(ctx: &mut CommandContext, commit_id: String) -> anyhow::Result<bool> {
+    let rules = but_rules::list_rules(ctx)?
+        .iter()
+        .any(|r| r.target_commit_id() == Some(commit_id.clone()));
+    Ok(rules)
+}