respect-validation/docs/validators/OneOf.md
Henrique Moody b701fac656
Create ShortCircuit validator and ShortCircuitable interface
This commit introduces a mechanism for validators to return early once
the validation outcome is determined, rather than evaluating all child
validators.

The ShortCircuit validator evaluates validators sequentially and stops
at the first failure, similar to how PHP's && operator works. This is
useful when later validators depend on earlier ones passing, or when
you want only the first error message.

The ShortCircuitCapable interface allows composite validators (AllOf,
AnyOf, OneOf, NoneOf, Each, All) to implement their own short-circuit
logic.

Why "ShortCircuit" instead of "FailFast":

The name "FailFast" was initially considered but proved misleading.
While AllOf stops on failure (fail fast), AnyOf stops on success
(succeed fast), and OneOf stops on the second success. The common
behavior is not about failing quickly, but about returning as soon as
the outcome is determined—which is exactly what short-circuit
evaluation means. This terminology is familiar to developers from
boolean operators (&& and ||), making the behavior immediately
understandable.

Co-authored-by: Alexandre Gomes Gaigalas <alganet@gmail.com>
Assisted-by: Claude Code (Opus 4.5)
2026-02-05 17:32:42 +01:00

81 lines
2.5 KiB
Markdown

<!--
SPDX-License-Identifier: MIT
SPDX-FileCopyrightText: (c) Respect Project Contributors
SPDX-FileContributor: Alexandre Gomes Gaigalas <alganet@gmail.com>
SPDX-FileContributor: Bradyn Poulsen <bradyn@bradynpoulsen.com>
SPDX-FileContributor: Henrique Moody <henriquemoody@gmail.com>
-->
# OneOf
- `OneOf(Validator $validator1, Validator $validator2)`
- `OneOf(Validator $validator1, Validator $validator2, Validator ...$validators)`
Will validate if exactly one inner validator passes.
```php
v::oneOf(v::digit(), v::alpha())->assert('AB');
// Validation passes successfully
v::oneOf(v::digit(), v::alpha())->assert('12');
// Validation passes successfully
v::oneOf(v::digit(), v::alpha())->assert('AB12');
// → - "AB12" must pass one of the rules
// → - "AB12" must consist only of digits (0-9)
// → - "AB12" must consist only of letters (a-z)
v::oneOf(v::digit(), v::alpha())->assert('*');
// → - "*" must pass one of the rules
// → - "*" must consist only of digits (0-9)
// → - "*" must consist only of letters (a-z)
```
The chains above validate if the input is either a digit or an alphabetic
character, one or the other, but not neither nor both.
## Templates
### `OneOf::TEMPLATE_NONE`
Used when none of the validators have passed.
| Mode | Template |
| ---------: | :------------------------------------- |
| `default` | {{subject}} must pass one of the rules |
| `inverted` | {{subject}} must pass one of the rules |
### `OneOf::TEMPLATE_MORE_THAN_ONE`
Used when more than one validator has passed.
| Mode | Template |
| ---------: | :------------------------------------------ |
| `default` | {{subject}} must pass only one of the rules |
| `inverted` | {{subject}} must pass only one of the rules |
## Template placeholders
| Placeholder | Description |
| ----------- | ---------------------------------------------------------------- |
| `subject` | The validated input or the custom validator name (if specified). |
## Categorization
- Composite
- Nesting
## Changelog
| Version | Description |
| ------: | :------------------------------------------- |
| 3.0.0 | Require at least two validators to be passed |
| 0.3.9 | Created |
## See Also
- [AllOf](AllOf.md)
- [AnyOf](AnyOf.md)
- [NoneOf](NoneOf.md)
- [ShortCircuit](ShortCircuit.md)
- [When](When.md)