Stateless rule engine to assert statements given a context.
$ composer require "subzeta/ruling" : "^2.0"require '/path/to/vendor/autoload.php';
use subzeta\Ruling\Ruling;
$my = new \stdClass();
$my->sensitivity = 80;
$my->joyfulness = 10;
(new Ruling())
->given([
'sensitivity' => $my->sensitivity,
'joyfulness' => $my->joyfulness
])->when(
':sensitivity is greater than 90 or :joyfulness is less than 20'
)->then(function() {
echo 'Hell yeah, I should listen music right now!';
})->otherwise(function() {
echo 'I\'m happy enough, thanks.';
})->execute();
// Outputs: Hell yeah, I should listen music right now!There are three main entrances:
Returns the interpreted rules. Using the example above the output would be: ['80 > 90 || 10 < 20']
Returns a boolean indicating the output. Using the example above the output would be: true
Fires the success or fail callback if defined. Using the example above the output would be: 'Hell yeah, I should listen it!'
Different types of exceptions are thrown when something goes wrong:
When the provided context isn't valid (accepts: ['string-key-1' => value-1, ..., 'string-key-x' => value-x]).
When the provided rules aren't valid (accepts: 'string' or ['string-1', ..., 'string-x'])
When the provided success/fail callback isn't callable (accepts: function(){return 'Hey Ho! Let's go!';})
| Type | Operator | Representation |
|---|---|---|
| Comparison | is greater than | > |
| Comparison | is greater or equal to | >= |
| Comparison | is less than | < |
| Comparison | is less or equal to | <= |
| Comparison | is equal to (alias: is) | == |
| Comparison | is not equal to (aliases: is not, isn't) | != |
| Comparison | same as | === |
| Comparison | not same as | !== |
| Logical | and | && |
| Logical | or | || |
| Containment | contained in (alias: in) | in |
- It's not necessary to provide callbacks for execute method, it will return a boolean instead as assert does.
- Rules respect the operator precedence and evaluate the parenthesis from right to left.
$ phpunit- Increase the number of unit tests to prevent bad contexts or bad formatted rules from being executed.
- Improve the interpreted method response.
- Allow aliases ("is equal to" can be written as "is" and "is not equal to" as "is not"/"isn't").
- Context values may permit callable functions too.
- Added the strict comparison operators (same as, not same as).
- It can be interesting to implement a kind of dump method to show the interpreted rule.
- Added the "in" operator.
- Context accepts array values.
MIT