Merge pull request #9723 from gitbutlerapp/kv-branch-40

Crating or updating a rule now triggers rules to be evaluated

Author: krlvi

Cargo.lock

@@ -19,6 +19,7 @@ serde_regex = "1.1.0"
 serde_json = "1.0.138"
 gitbutler-command-context.workspace = true
 but-db.workspace = true
+but-core.workspace = true
 but-hunk-assignment.workspace = true
 but-graph.workspace = true
 but-workspace.workspace = true

crates/but-rules/Cargo.toml

@@ -1,5 +1,5 @@
 use but_graph::VirtualBranchesTomlMetadata;
-use but_hunk_assignment::{HunkAssignment, WorktreeChanges, assign, assignments_to_requests};
+use but_hunk_assignment::{HunkAssignment, assign, assignments_to_requests};
 use but_hunk_dependency::ui::HunkDependencies;
 use but_workspace::{StackId, StacksFilter, ui::StackEntry};
 use gitbutler_command_context::CommandContext;
@@ -8,9 +8,10 @@ use std::str::FromStr;
 
 use crate::{Filter, StackTarget};
 
-pub fn on_filesystem_change(
+pub fn process_workspace_rules(
     ctx: &mut CommandContext,
-    worktree_changes: &WorktreeChanges,
+    assignments: &[HunkAssignment],
+    dependencies: &Option<HunkDependencies>,
 ) -> anyhow::Result<usize> {
     let mut updates = 0;
     let rules = super::list_rules(ctx)?
@@ -43,7 +44,7 @@ pub fn on_filesystem_change(
         match rule.action {
             super::Action::Explicit(super::Operation::Assign { target }) => {
                 if let Some(stack_id) = get_or_create_stack_id(ctx, target, &stacks_in_ws) {
-                    let assignments = matching(worktree_changes.clone(), rule.filters.clone())
+                    let assignments = matching(assignments, rule.filters.clone())
                         .into_iter()
                         .filter(|e| e.stack_id != Some(stack_id))
                         .map(|mut e| {
@@ -52,8 +53,7 @@ pub fn on_filesystem_change(
                         })
                         .collect_vec();
                     updates +=
-                        handle_assign(ctx, assignments, worktree_changes.dependencies.as_ref())
-                            .unwrap_or_default();
+                        handle_assign(ctx, assignments, dependencies.as_ref()).unwrap_or_default();
                 }
             }
             _ => continue,
@@ -133,22 +133,22 @@ fn handle_assign(
     }
 }
 
-fn matching(worktree_changes: WorktreeChanges, filters: Vec<Filter>) -> Vec<HunkAssignment> {
+fn matching(wt_assignments: &[HunkAssignment], filters: Vec<Filter>) -> Vec<HunkAssignment> {
     if filters.is_empty() {
-        return worktree_changes.assignments;
+        return wt_assignments.to_vec();
     }
     let mut assignments = Vec::new();
     for filter in filters {
         match filter {
             Filter::PathMatchesRegex(regex) => {
-                for change in worktree_changes.assignments.iter() {
+                for change in wt_assignments.iter() {
                     if regex.is_match(&change.path) {
                         assignments.push(change.clone());
                     }
                 }
             }
             Filter::ContentMatchesRegex(regex) => {
-                for change in worktree_changes.assignments.iter() {
+                for change in wt_assignments.iter() {
                     if let Some(diff) = change.diff.clone() {
                         let diff = diff.to_string();
                         let matching_lines: Vec<&str> =

crates/but-rules/src/handler.rs

@@ -1,3 +1,4 @@
+use but_hunk_dependency::ui::hunk_dependencies_for_workspace_changes_by_worktree_dir;
 use gitbutler_command_context::CommandContext;
 use serde::{Deserialize, Serialize};
 
@@ -156,6 +157,7 @@ pub fn create_rule(
         .workspace_rules()
         .insert(rule.clone().try_into()?)
         .map_err(|e| anyhow::anyhow!("Failed to insert workspace rule: {}", e))?;
+    process_rules(ctx).ok(); // Reevaluate rules after creating
     Ok(rule)
 }
 
@@ -213,6 +215,7 @@ pub fn update_rule(
         .workspace_rules()
         .update(&req.id, rule.clone().try_into()?)
         .map_err(|e| anyhow::anyhow!("Failed to update workspace rule: {}", e))?;
+    process_rules(ctx).ok(); // Reevaluate rules after updating
     Ok(rule)
 }
 
@@ -227,3 +230,25 @@ pub fn list_rules(ctx: &mut CommandContext) -> anyhow::Result<Vec<WorkspaceRule>
         .collect::<Result<Vec<WorkspaceRule>, _>>()?;
     Ok(rules)
 }
+
+fn process_rules(ctx: &mut CommandContext) -> anyhow::Result<()> {
+    let wt_changes = but_core::diff::worktree_changes(&ctx.gix_repo()?)?;
+
+    let dependencies = hunk_dependencies_for_workspace_changes_by_worktree_dir(
+        ctx,
+        &ctx.project().path,
+        &ctx.project().gb_dir(),
+        Some(wt_changes.changes.clone()),
+    )?;
+
+    let (assignments, _) = but_hunk_assignment::assignments_with_fallback(
+        ctx,
+        false,
+        Some(wt_changes.changes),
+        Some(&dependencies),
+    )
+    .map_err(|e| anyhow::anyhow!("Failed to get assignments: {}", e))?;
+
+    handler::process_workspace_rules(ctx, &assignments, &Some(dependencies))?;
+    Ok(())
+}

crates/but-rules/src/lib.rs

@@ -103,7 +103,11 @@ impl Handler {
                 .map(|err| serde_error::Error::new(&**err)),
         };
         if ctx.app_settings().feature_flags.rules {
-            if let Ok(update_count) = but_rules::handler::on_filesystem_change(ctx, &changes) {
+            if let Ok(update_count) = but_rules::handler::process_workspace_rules(
+                ctx,
+                &assignments,
+                &dependencies.as_ref().ok().cloned(),
+            ) {
                 if update_count > 0 {
                     // Getting these again since they were updated
                     let (assignments, assignments_error) =