loom-kernel 2.22.2__tar.gz → 2.22.3__tar.gz

{loom_kernel-2.22.2 → loom_kernel-2.22.3}/CHANGELOG.md

@@ -459,6 +459,14 @@
 
 ### core
 
+- **core:** `Rule.check(..., via=fn)` takes the violation from `fn`: a `str`
+  (the message) or a `RuleViolation` fails the rule, `None` passes it. A `bool`
+  or any other result raises `TypeError` naming the field, instead of `True`
+  failing the rule and `False` passing it. The `message=` parameter of
+  `Rule.check` is removed. `Rule.forbid` keeps its boolean condition; a `str`
+  or `RuleViolation` it returns no longer fails the rule. Migrate
+  `Rule.check(F(Order).total, via=lambda v: v <= 0, message="total must be > 0")`
+  to `Rule.check(F(Order).total, via=lambda v: "total must be > 0" if v <= 0 else None)`.
 - **core:** the `LoomType` protocol gains `from_query(params)`, which
   validates query-string values strictly. A number takes the JSON number
   grammar and must be finite, an integer its integer subset within

{loom_kernel-2.22.2 → loom_kernel-2.22.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: loom-kernel
-Version: 2.22.2
+Version: 2.22.3
 Summary: Loom Python project
 License-File: LICENSE
 Classifier: Programming Language :: Python :: 3
@@ -524,8 +524,8 @@ class PricingPreviewUseCase(UseCase[Record, PricingPreviewResponse]):
         ),
     )
     rules = (
-        Rule.check(F(PricingCommand).unit_price, via=lambda v: v <= 0, message="unit_price must be > 0"),
-        Rule.check(F(PricingCommand).country, via=lambda v: v not in TAX_RATES, message="Unsupported country"),
+        Rule.check(F(PricingCommand).unit_price, via=lambda v: "unit_price must be > 0" if v <= 0 else None),
+        Rule.check(F(PricingCommand).country, via=lambda v: None if v in TAX_RATES else "Unsupported country"),
     )
 
     async def execute(self, record_id: int, cmd: PricingCommand = Input()) -> PricingPreviewResponse:

{loom_kernel-2.22.2 → loom_kernel-2.22.3}/README.md

@@ -400,8 +400,8 @@ class PricingPreviewUseCase(UseCase[Record, PricingPreviewResponse]):
         ),
     )
     rules = (
-        Rule.check(F(PricingCommand).unit_price, via=lambda v: v <= 0, message="unit_price must be > 0"),
-        Rule.check(F(PricingCommand).country, via=lambda v: v not in TAX_RATES, message="Unsupported country"),
+        Rule.check(F(PricingCommand).unit_price, via=lambda v: "unit_price must be > 0" if v <= 0 else None),
+        Rule.check(F(PricingCommand).country, via=lambda v: None if v in TAX_RATES else "Unsupported country"),
     )
 
     async def execute(self, record_id: int, cmd: PricingCommand = Input()) -> PricingPreviewResponse:

{loom_kernel-2.22.2 → loom_kernel-2.22.3}/src/loom/core/use_case/rule.py

@@ -47,7 +47,6 @@ class RuleBuilderFn(RuleFn, Protocol):
 class _RuleSpec:
     evaluator: Callable[..., Any]
     field: str | None = None
-    message: str | None = None
     command_sources: tuple[FieldRef, ...] = ()
     param_names: tuple[str, ...] = ()
     include_command: bool = False
@@ -101,13 +100,19 @@ class _RuleSpec:
                 raise ValueError(f"Missing runtime context keys for rule: {', '.join(missing)}")
             args.extend(context[n] for n in self.param_names)
 
-        result = self.evaluator(*args)
+        self._raise_outcome(self.evaluator(*args), command)
+
+    def _raise_outcome(self, result: object, command: Command) -> None:
         if isinstance(result, RuleViolation):
             raise result
         if isinstance(result, str):
             raise RuleViolation(self._resolved_field(command), result)
-        if result is True:  # intentional: only boolean True signals failure, not any truthy value
-            raise RuleViolation(self._resolved_field(command), self._resolved_message())
+        if result is not None:
+            raise TypeError(
+                f"Rule.check on field '{self._resolved_field(command)}': the evaluator "
+                f"returned {type(result).__name__}; return the violation message (str), "
+                "a RuleViolation, or None when the value is valid."
+            )
 
     def _resolved_field(self, command: Command) -> str:
         candidates = (
@@ -118,9 +123,6 @@ class _RuleSpec:
         )
         return next((c for c in candidates if c is not None), type(command).__name__)
 
-    def _resolved_message(self) -> str:
-        return self.message or "Rule check failed"
-
 
 @dataclass(frozen=True, slots=True)
 class _RequirePresentSpec:
@@ -152,15 +154,19 @@ class Rule:
     @staticmethod
     def check(
         *targets: FieldRef,
-        via: Callable[..., Any],
-        message: str | None = None,
+        via: Callable[..., str | RuleViolation | None],
     ) -> RuleBuilderFn:
+        """Validate fields with ``via``, which receives the targets' values.
+
+        ``via`` returns the violation message (``str``), a ``RuleViolation``, or
+        ``None`` when the values are valid. Any other result, a ``bool``
+        included, raises ``TypeError``.
+        """
         if not targets:
             raise ValueError("Rule.check(...) requires at least one target.")
         return _RuleSpec(
             evaluator=via,
             field=targets[0].leaf,
-            message=message,
             command_sources=tuple(targets),
         )
 
@@ -170,9 +176,12 @@ class Rule:
         *,
         message: str,
     ) -> RuleBuilderFn:
+        def _violation(*args: Any) -> str | None:
+            # Only boolean True signals failure, not any truthy value.
+            return message if condition(*args) is True else None
+
         return _RuleSpec(
-            evaluator=condition,
-            message=message,
+            evaluator=_violation,
             include_command=True,
             include_fields_set=True,
         )