feat: short-circuit rule evaluation on HARD_FAIL

Author: baranylcn

gateframe/cli/trend.py

@@ -37,9 +37,7 @@ def _print_report(report) -> None:  # noqa: ANN001
 
     for ct in report.contract_trends:
         runs = len(ct.run_summaries)
-        avg_pass = (
-            sum(s.pass_rate for s in ct.run_summaries) / runs if runs else 0.0
-        )
+        avg_pass = sum(s.pass_rate for s in ct.run_summaries) / runs if runs else 0.0
         flag = " [REGRESSION]" if ct.regressed else ""
         print(f"\n  {ct.contract_name}{flag}")
         print(f"    direction : {ct.direction}")

gateframe/core/contract.py

@@ -40,19 +40,23 @@ def __init__(
 
     def validate(self, output: Any, **context: Any) -> ValidationResult:  # noqa: ANN401
         failures: list[FailureResult] = []
+        rules_run = 0
 
         for rule in self.rules:
+            rules_run += 1
             result = rule.validate(output, **context)
             if result is not None:
                 failures.append(result)
+                if result.failure_mode is FailureMode.HARD_FAIL:
+                    break
 
         failure_modes = {f.failure_mode for f in failures}
 
         return ValidationResult(
             passed=len(failures) == 0,
             contract_name=self.name,
             failures=failures,
-            rules_applied=len(self.rules),
+            rules_applied=rules_run,
             rules_failed=len(failures),
             has_hard_fail=FailureMode.HARD_FAIL in failure_modes,
             has_soft_fail=FailureMode.SOFT_FAIL in failure_modes,

tests/core/test_contract.py

@@ -48,13 +48,36 @@ def test_single_failure(self) -> None:
         assert result.failures[0].rule_name == "b"
 
     def test_multiple_failures(self) -> None:
-        contract = ValidationContract("test", [_FailingRule("a"), _FailingRule("b")])
+        contract = ValidationContract(
+            "test",
+            [_FailingRule("a", FailureMode.SOFT_FAIL), _FailingRule("b", FailureMode.SOFT_FAIL)],
+        )
         result = contract.validate({})
         assert result.passed is False
         assert len(result.failures) == 2
         assert result.rules_applied == 2
         assert result.rules_failed == 2
 
+    def test_hard_fail_short_circuits_remaining_rules(self) -> None:
+        contract = ValidationContract(
+            "test",
+            [_FailingRule("a", FailureMode.HARD_FAIL), _FailingRule("b", FailureMode.SOFT_FAIL)],
+        )
+        result = contract.validate({})
+        assert result.has_hard_fail is True
+        assert result.rules_applied == 1
+        assert result.rules_failed == 1
+        assert result.failures[0].rule_name == "a"
+
+    def test_soft_fail_does_not_short_circuit(self) -> None:
+        contract = ValidationContract(
+            "test",
+            [_FailingRule("a", FailureMode.SOFT_FAIL), _FailingRule("b", FailureMode.HARD_FAIL)],
+        )
+        result = contract.validate({})
+        assert result.rules_applied == 2
+        assert result.rules_failed == 2
+
     def test_empty_rules_list(self) -> None:
         contract = ValidationContract("empty", [])
         result = contract.validate("anything")