refactor: split eval runner matching helpers

Separate required-match allocation, unexpected-match detection, and rule-metric assembly so fixture expectation evaluation stays easy to follow.

Made-with: Cursor

Author: haasonsaas

TODO.md

@@ -70,7 +70,7 @@
 - [x] `src/commands/feedback_eval/report/build/stats.rs`: split threshold confusion-matrix scoring from bucket primitives.
 - [x] `src/commands/doctor/command/display.rs`: separate header/config output, endpoint listing, and inference result rendering.
 - [x] `src/commands/doctor/command/run.rs`: separate endpoint discovery, recommendation flow, and test helpers.
-- [ ] `src/commands/eval/runner/matching.rs`: split required-match search, unexpected-match detection, and rule metric assembly.
+- [x] `src/commands/eval/runner/matching.rs`: split required-match search, unexpected-match detection, and rule metric assembly.
 - [ ] `src/commands/eval/runner/execute/loading.rs`: separate diff resolution from repo-path resolution if it grows again.
 - [ ] `src/commands/feedback_eval/report/examples.rs`: split ranking helpers from example builders.
 - [ ] `src/commands/doctor/system.rs`: carve environment probes vs output helpers.

src/commands/eval/runner/matching.rs

@@ -1,10 +1,18 @@
+#[path = "matching/required.rs"]
+mod required;
+#[path = "matching/rules.rs"]
+mod rules;
+#[path = "matching/unexpected.rs"]
+mod unexpected;
+
 use std::collections::HashSet;
 
 use crate::core;
 
-use super::super::metrics::{compute_rule_metrics, summarize_rule_metrics};
-use super::super::pattern::summarize_for_eval;
 use super::super::{EvalExpectations, EvalRuleMetrics, EvalRuleScoreSummary};
+use required::collect_required_matches;
+use rules::build_rule_match_metrics;
+use unexpected::collect_unexpected_matches;
 
 pub(super) struct FixtureMatchSummary {
     pub(super) failures: Vec<String>,
@@ -20,57 +28,23 @@ pub(super) fn evaluate_fixture_expectations(
     expectations: &EvalExpectations,
     comments: &[core::Comment],
 ) -> FixtureMatchSummary {
-    let mut failures = Vec::new();
-    let mut required_matches = 0usize;
     let required_total = expectations.must_find.len();
-    let mut used_comment_indices = HashSet::new();
-    let mut unexpected_comment_indices = HashSet::new();
-    let mut matched_pairs = Vec::new();
-
-    for (expected_idx, expected) in expectations.must_find.iter().enumerate() {
-        let found = comments
-            .iter()
-            .enumerate()
-            .find(|(comment_idx, comment)| {
-                !used_comment_indices.contains(comment_idx) && expected.matches(comment)
-            })
-            .map(|(comment_idx, _)| comment_idx);
-
-        if let Some(comment_idx) = found {
-            used_comment_indices.insert(comment_idx);
-            matched_pairs.push((expected_idx, comment_idx));
-            required_matches = required_matches.saturating_add(1);
-        } else {
-            failures.push(format!("Missing expected finding: {}", expected.describe()));
-        }
-    }
-
-    for unexpected in &expectations.must_not_find {
-        if let Some((comment_idx, comment)) = comments
-            .iter()
-            .enumerate()
-            .find(|(_, comment)| unexpected.matches(comment))
-        {
-            unexpected_comment_indices.insert(comment_idx);
-            failures.push(format!(
-                "Unexpected finding matched {}:{} '{}'",
-                comment.file_path.display(),
-                comment.line_number,
-                summarize_for_eval(&comment.content)
-            ));
-        }
-    }
-
-    let rule_metrics = compute_rule_metrics(&expectations.must_find, comments, &matched_pairs);
-    let rule_summary = summarize_rule_metrics(&rule_metrics);
+    let required = collect_required_matches(expectations, comments);
+    let unexpected = collect_unexpected_matches(expectations, comments);
+    let (rule_metrics, rule_summary) =
+        build_rule_match_metrics(expectations, comments, &required.matched_pairs);
 
     FixtureMatchSummary {
-        failures,
-        required_matches,
+        failures: required
+            .failures
+            .into_iter()
+            .chain(unexpected.failures)
+            .collect(),
+        required_matches: required.required_matches,
         required_total,
         rule_metrics,
         rule_summary,
-        used_comment_indices,
-        unexpected_comment_indices,
+        used_comment_indices: required.used_comment_indices,
+        unexpected_comment_indices: unexpected.unexpected_comment_indices,
     }
 }

src/commands/eval/runner/matching/required.rs

@@ -0,0 +1,47 @@
+use std::collections::HashSet;
+
+use crate::core;
+
+use super::super::super::EvalExpectations;
+
+pub(super) struct RequiredMatchResults {
+    pub(super) failures: Vec<String>,
+    pub(super) required_matches: usize,
+    pub(super) used_comment_indices: HashSet<usize>,
+    pub(super) matched_pairs: Vec<(usize, usize)>,
+}
+
+pub(super) fn collect_required_matches(
+    expectations: &EvalExpectations,
+    comments: &[core::Comment],
+) -> RequiredMatchResults {
+    let mut failures = Vec::new();
+    let mut required_matches = 0usize;
+    let mut used_comment_indices = HashSet::new();
+    let mut matched_pairs = Vec::new();
+
+    for (expected_idx, expected) in expectations.must_find.iter().enumerate() {
+        let found = comments
+            .iter()
+            .enumerate()
+            .find(|(comment_idx, comment)| {
+                !used_comment_indices.contains(comment_idx) && expected.matches(comment)
+            })
+            .map(|(comment_idx, _)| comment_idx);
+
+        if let Some(comment_idx) = found {
+            used_comment_indices.insert(comment_idx);
+            matched_pairs.push((expected_idx, comment_idx));
+            required_matches = required_matches.saturating_add(1);
+        } else {
+            failures.push(format!("Missing expected finding: {}", expected.describe()));
+        }
+    }
+
+    RequiredMatchResults {
+        failures,
+        required_matches,
+        used_comment_indices,
+        matched_pairs,
+    }
+}

src/commands/eval/runner/matching/rules.rs

@@ -0,0 +1,14 @@
+use crate::core;
+
+use super::super::super::metrics::{compute_rule_metrics, summarize_rule_metrics};
+use super::super::super::{EvalExpectations, EvalRuleMetrics, EvalRuleScoreSummary};
+
+pub(super) fn build_rule_match_metrics(
+    expectations: &EvalExpectations,
+    comments: &[core::Comment],
+    matched_pairs: &[(usize, usize)],
+) -> (Vec<EvalRuleMetrics>, Option<EvalRuleScoreSummary>) {
+    let rule_metrics = compute_rule_metrics(&expectations.must_find, comments, matched_pairs);
+    let rule_summary = summarize_rule_metrics(&rule_metrics);
+    (rule_metrics, rule_summary)
+}

src/commands/eval/runner/matching/unexpected.rs

@@ -0,0 +1,40 @@
+use std::collections::HashSet;
+
+use crate::core;
+
+use super::super::super::pattern::summarize_for_eval;
+use super::super::super::EvalExpectations;
+
+pub(super) struct UnexpectedMatchResults {
+    pub(super) failures: Vec<String>,
+    pub(super) unexpected_comment_indices: HashSet<usize>,
+}
+
+pub(super) fn collect_unexpected_matches(
+    expectations: &EvalExpectations,
+    comments: &[core::Comment],
+) -> UnexpectedMatchResults {
+    let mut failures = Vec::new();
+    let mut unexpected_comment_indices = HashSet::new();
+
+    for unexpected in &expectations.must_not_find {
+        if let Some((comment_idx, comment)) = comments
+            .iter()
+            .enumerate()
+            .find(|(_, comment)| unexpected.matches(comment))
+        {
+            unexpected_comment_indices.insert(comment_idx);
+            failures.push(format!(
+                "Unexpected finding matched {}:{} '{}'",
+                comment.file_path.display(),
+                comment.line_number,
+                summarize_for_eval(&comment.content)
+            ));
+        }
+    }
+
+    UnexpectedMatchResults {
+        failures,
+        unexpected_comment_indices,
+    }
+}