Json Logic PHP

https://github.com/jwadhams/json-logic-php
Admin
This parser accepts JsonLogic rules and executes them in PHP, allowing you to share rules between...
Tokens:23,424
Snippets:151
Trust Score:8.5
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Example: non-rule input

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Example showing uses_data with non-rule input, which returns an empty array.

```php
JsonLogic::uses_data([1, 2, 3]); // []
```

--------------------------------

### all/none/some examples

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/operations.md

Examples of quantifiers over scoped data. some checks if any element matches, all checks if all match, none checks if none match.

```php
$data = ["items" => [1, 2, 3]];
JsonLogic::apply(["some" => [["var" => "items"], ["==" => [["var" => ""], 2]]]], $data); // true
JsonLogic::apply(["all"  => [["var" => "items"], [">" => [["var" => ""], 0]]]], $data);  // true
JsonLogic::apply(["none" => [["var" => "items"], ["==" => [["var" => ""], 9]]]], $data);  // true
```

--------------------------------

### reduce example

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/operations.md

Example of reduce operator that folds over scoped data with an accumulator, using a rule that adds accumulator and current.

```php
JsonLogic::apply(
    ["reduce" => [["var" => "nums"], ["+" => [["var" => "accumulator"], ["var" => "current"]]], 0]],
    ["nums" => [1, 2, 3]]
);
// 6
```

--------------------------------

### get_values unary fix applied (default) example

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Shows the difference between default behavior (wrapping) and passing false to get the raw operand.

```php
JsonLogic::get_values(["var" => "a"]);
// ["a"]

JsonLogic::get_values(["var" => "a"], false);
// "a"   (raw operand, not wrapped)
```

--------------------------------

### Example: nested var keys

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Example showing uses_data with a nested rule. It returns the unique data keys referenced by 'var' operations, here 'temp' and 'pie.filling'.

```php
$rule = ["and" => [
    ["<" => [["var" => "temp"], 110]],
    ["==" => [["var" => "pie.filling"], "apple"]]
]];

JsonLogic::uses_data($rule);
// ["temp", "pie.filling"]
```

--------------------------------

### Install json-logic-php via Composer

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/README.md

Install the json-logic-php package via Composer. The package autoloads under PSR-0, so the class resolves automatically from src/JWadhams/JsonLogic.php.

```bash
composer require jwadhams/json-logic-php
```

--------------------------------

### get_operator basic usage example

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Shows how to call get_operator with a simple equality rule and echo the result.

```php
use JWadhams\JsonLogic;

$op = JsonLogic::get_operator(["==" => [1, 1]]);
echo $op; // "=="
```

--------------------------------

### if/?: usage example

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/operations.md

Example of using the if operator with a condition comparing a variable to 110, returning 'cool' or 'hot' based on the data.

```php
JsonLogic::apply(
    ["if" => [["==" => [["var" => "temp"], 110]], "cool", "hot"]],
    ["temp" => 100]
); // "cool"
```

--------------------------------

### and/or short-circuit examples

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/operations.md

Examples of and/or operators with short-circuit evaluation. and returns first falsy or last operand; or returns first truthy or last operand.

```php
JsonLogic::apply(["and" => [[">" => [3, 1]], ["<" => [1, 3]]]]); // true
JsonLogic::apply(["or"  => [false, ["==" => [1, 2]]]]);          // false
```

--------------------------------

### var operator usage examples

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/operations.md

Examples of using the 'var' operator with JsonLogic::apply, demonstrating data access with dot-notation, fallback defaults, numeric indexing, and returning the whole data when the key is empty.

```php
JsonLogic::apply(["var" => "a"], ["a" => 1, "b" => 2]);          // 1
JsonLogic::apply(["var" => ["a", "fallback"]], ["b" => 2]);      // "fallback"
JsonLogic::apply(["var" => 1], ["apple", "banana", "carrot"]);   // "banana"  (numeric index)
JsonLogic::apply(["var" => ""], ["a" => 1]);                     // ["a" => 1] (whole data)
```

--------------------------------

### Usage examples for missing and missing_some

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/operations.md

Shows how to use the missing and missing_some operations with sample data. The first call returns missing keys, the second returns an empty array because at least one key is present, and the third returns the missing key because the minimum is not met.

```php
$data = ["a" => 1];
JsonLogic::apply(["missing" => ["a", "b"]], $data);       // ["b"]
JsonLogic::apply(["missing_some" => [1, ["a", "b"]]], $data); // []
JsonLogic::apply(["missing_some" => [2, ["a", "b"]]], $data); // ["b"]
```

--------------------------------

### rule_like structural pattern matching example

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Demonstrates structural pattern matching with nested arrays. The pattern uses a wildcard '*' and type guards, and the rule matches it exactly, returning true.

```php
$pattern = ["*" => ["number", ["+" => "array"]]];
$rule    = ["*" => [0.01, ["+" => [["var" => "goods"], ["var" => "services"]]]]];

JsonLogic::rule_like($rule, $pattern); // true
```

--------------------------------

### get_values array and nested-rule operands example

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Shows how get_values handles array operands and nested single-rule operands, wrapping the latter.

```php
JsonLogic::get_values(["==" => [1, 1]]);
// [1, 1]

JsonLogic::get_values(["var" => ["<" => [1, 2]]]);
// [ ["<" => [1, 2]] ]   // a single rule operand is itself wrapped
```

--------------------------------

### Dynamic-arity operation example

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Registers a custom operator that multiplies two operands, then applies it with variables from a data context.

```php
JsonLogic::add_operation("times", function ($a, $b) {
    return $a * $b;
});
JsonLogic::apply(
    ["times" => [["var" => "a"], ["var" => "b"]]],
    ["a" => 6, "b" => 7]
);
// 42
```

--------------------------------

### filter example

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/operations.md

Example of filter operator that keeps elements where the template evaluates truthy, then reindexes with array_values.

```php
JsonLogic::apply(
    ["filter" => [["var" => "items"], [">" => [["var" => ""], 5]]]],
    ["items" => [1, 10, 3, 7]]
);
// [10, 7]
```

--------------------------------

### rule_like type guards and wildcard examples

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Shows type guards and wildcard matching. The first call checks if 42 is a number, the second checks if an array is an array (but not logic), and the third uses the wildcard pattern '@' to match any rule.

```php
JsonLogic::rule_like(42, "number");      // true
JsonLogic::rule_like(["a", "b"], "array"); // true  (not logic, so not "array" per guard)
JsonLogic::rule_like(["var" => "a"], "@"); // true  (wildcard)
```

--------------------------------

### Closure with side effects example

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Registers a custom operator that increments a total and returns it. Demonstrates unary sugar for a single operand and side effects via closure.

```php
use JWadhams\JsonLogic;

$total = 0;
JsonLogic::add_operation("add_to_total", function ($b = 1) use (&$total) {
    $total += $b;
    return $total;
});

JsonLogic::apply(["add_to_total" => []]);  // 1
JsonLogic::apply(["add_to_total" => 41]);  // 42  (unary sugar for [41])
// $total == 42
```

--------------------------------

### if/?: pattern examples

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/operations.md

Shows the pattern for if/?: operator with multiple else-if branches. The operator iterates condition-consequent pairs, evaluating only the first truthy condition's consequent.

```php
// pattern
if( 0 ){ 1 }else{ 2 };
if( 0 ){ 1 }else if( 2 ){ 3 }else{ 4 };
if( 0 ){ 1 }else if( 2 ){ 3 }else if( 4 ){ 5 }else{ 6 };
```

--------------------------------

### JsonLogic rule in JSON and PHP with json_decode

Source: https://github.com/jwadhams/json-logic-php/blob/master/README.md

Shows the basic JsonLogic rule format in JSON, the equivalent PHP associative array produced by json_decode with $assoc=true, and examples of applying the rule to both an array and an object. Accepts either associative arrays or objects.

```json
{"==" : ["apples", "apples"]}
```

```php
json_decode('{"==" : ["apples", "apples"]}', true);
// ["==" => ["apples", "apples"]]
```

```php
$rule = '{"==":["apples", "apples"]}';

//Decode the JSON string to an array, and evaluate it.
JWadhams\JsonLogic::apply( json_decode($rule, true) );
// true

//Decode the JSON string to an object, and evaluate it.
JWadhams\JsonLogic::apply( json_decode($rule, false) );
// true
```

--------------------------------

### Syntactic sugar for var operator

Source: https://github.com/jwadhams/json-logic-php/blob/master/README.md

Syntactic sugar for unary operators: the array around the value is omitted. This is equivalent to the previous example.

```php
JWadhams\JsonLogic::apply(
	[ "var" => "a" ],
	[ "a" => 1, "b" => 2 ]
);
// 1
```

--------------------------------

### Catch \Exception("Unrecognized operator $op") from JsonLogic::apply()

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/errors.md

Catch the library's only intentional error, thrown when apply() receives a rule with an operator not in the custom or built-in registries. The message is exactly "Unrecognized operator fubar" for this example. Use this pattern to handle invalid rules gracefully.

```php
use JWadhams\JsonLogic;

try {
    $result = JsonLogic::apply(["fubar" => [1, 2]]);
} catch (\Exception $e) {
    // $e->getMessage() === "Unrecognized operator fubar"
    error_log("Rule rejected: " . $e->getMessage());
}
```

--------------------------------

### truthy: Coerce value to boolean with JavaScript semantics

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Implements JsonLogic truthiness: the string "0" is truthy (matching JavaScript semantics); all other values are coerced with (bool). Used by the !! and ! operators and by if, and, or, filter, all. The example shows the special case and standard coercion.

```php
public static function truthy($logic)
```

```php
if ($logic === "0") {
    return true;
}
return (bool)$logic;
```

```php
JsonLogic::truthy("0"); // true
JsonLogic::truthy(0);   // false
JsonLogic::truthy("");  // false
JsonLogic::truthy([]);  // false
JsonLogic::truthy("a"); // true
```

--------------------------------

### is_logic: Check if value is a JsonLogic rule

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Tests whether a value is a JsonLogic rule: a single-key array whose key is a string. Returns true only if the array has exactly one element with a string key. The example shows true for a rule-shaped array and false for arrays with multiple keys or non-array values.

```php
public static function is_logic($array)
```

```php
return (
    is_array($array)
    and
    count($array) === 1
    and
    is_string(static::get_operator($array))
);
```

```php
JsonLogic::is_logic(["==" => [1, 1]]); // true
JsonLogic::is_logic([1, 2]);           // false  (two keys / not rule shaped)
JsonLogic::is_logic("apples");         // false
```

--------------------------------

### Manual download with curl

Source: https://github.com/jwadhams/json-logic-php/blob/master/README.md

Alternative manual download of the self-contained library file for those not using Composer.

```bash
curl -O https://raw.githubusercontent.com/jwadhams/json-logic-php/master/src/JWadhams/JsonLogic.php
```

--------------------------------

### Always and Never rules with apply

Source: https://github.com/jwadhams/json-logic-php/blob/master/README.md

If the first argument is a non-object, non-associative-array, it is returned immediately, ignoring the data argument. Useful for 'Always' (true) or 'Never' (false) rules.

```php
//Always
JWadhams\JsonLogic::apply(true, $data_will_be_ignored);
// true

//Never
JWadhams\JsonLogic::apply(false, $i_wasnt_even_supposed_to_be_here);
// false
```

--------------------------------

### rule_like

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Documentation for the static method rule_like in the JsonLogic class, which performs structural rule matching against patterns with wildcards and type guards.

```APIDOC
## `rule_like`

### Description
Structural rule matching against patterns, with wildcards and type guards. Returns `true` if `$rule` matches `$pattern`.

### Method
`public static function rule_like($rule, $pattern)`

### Parameters
- **$rule** (mixed) - Required - The value/rule to test
- **$pattern** (mixed) - Required - Pattern: `"@"` wildcard, `"number"`, `"string"`, `"array"` type guards, a JSON string starting with `{`, a logic rule (operator equality, with `"@"` op wildcard), or an array of patterns

### Return Value
`true` on match, `false` otherwise.

### Behavior
- A string `$pattern` starting with `{` is decoded as JSON (assoc arrays).
- `$pattern === $rule` → `true` (plain equality; the comment notes "TODO : Deep object equivalency?").
- `$pattern === "@"` → `true` (wildcard).
- `$pattern === "number"` → `is_numeric($rule)`.
- `$pattern === "string"` → `is_string($rule)`.
- `$pattern === "array"` → `is_array($rule)` and not `is_logic($rule)`.
- If `$pattern` is logic: `$rule` must also be logic; recursion happens only when the pattern's operator is `"@"` or equals the rule's operator, descending via `get_values($rule, false)` and `get_values($pattern, false)`; otherwise `false`.
- If `$pattern` is an array: `$rule` must be an array of equal length; elements are compared positionally (order matters — the source notes `+` is commutative but `-`, `if`, `var` are not); any failure fails the match.
- Otherwise `false` (not logic, not array, not an exact match).

### Example — type guards and wildcard
```php
JsonLogic::rule_like(42, "number");      // true
JsonLogic::rule_like(["a", "b"], "array"); // true  (not logic, so not "array" per guard)
JsonLogic::rule_like(["var" => "a"], "@"); // true  (wildcard)
```

### Example — structural pattern matching
```php
$pattern = ["*" => ["number", ["+" => "array"]]];
$rule    = ["*" => [0.01, ["+" => [["var" => "goods"], ["var" => "services"]]]]];

JsonLogic::rule_like($rule, $pattern); // true
```
```

--------------------------------

### JsonLogic Static Methods

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Documentation for the static methods get_operator and get_values of the JWadhams\JsonLogic class.

```APIDOC
## get_operator

### Description
Returns the first key of the given rule, i.e. the operator name.

### Method
PHP static method

### Endpoint
`JWadhams\JsonLogic::get_operator($logic)`

### Parameters
- **$logic** (mixed) - Required - A JsonLogic rule: an array/object map with the operator in key position

### Request Example
```php
use JWadhams\JsonLogic;

$op = JsonLogic::get_operator(["==" => [1, 1]]);
```

### Response
#### Success Response
- Returns the first key of `$logic` — the operator name when `$logic` is a well-formed single-key rule.

#### Response Example
```php
// "=="
```

### Notes
- Throws: none explicitly. The source performs no guard; calling with an empty array would raise a native indexing error.

## get_values

### Description
Returns the operands of a rule. With `$fix_unary = true` (the default), non-array values and single-rule values are wrapped into a one-element array, implementing the unary syntactic sugar.

### Method
PHP static method

### Endpoint
`JWadhams\JsonLogic::get_values($logic, $fix_unary = true)`

### Parameters
- **$logic** (mixed) - Required - A JsonLogic rule
- **$fix_unary** (boolean) - Optional - When `true`, wraps a scalar operand or a nested single-key rule operand into `[ $values ]` so every rule yields an array of operands. Default: `true`.

### Request Example
```php
JsonLogic::get_values(["var" => "a"]);
```

### Response
#### Success Response
- Returns an array of operand values for the rule's operator.

#### Response Example
```php
// ["a"]
```

### Notes
- Example with `$fix_unary = false`: `JsonLogic::get_values(["var" => "a"], false)` returns `"a"` (raw operand, not wrapped).
- Example with array operands: `JsonLogic::get_values(["==" => [1, 1]])` returns `[1, 1]`.
- Example with nested rule operand: `JsonLogic::get_values(["var" => ["<" => [1, 2]]])` returns `[ ["<" => [1, 2]] ]`.
```

--------------------------------

### Import JWadhams\JsonLogic class

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/README.md

Import the JsonLogic class using a use statement or fully qualified name. The library exports exactly one symbol: the class JWadhams\JsonLogic.

```php
use JWadhams\JsonLogic;      // class import
// or fully qualified
JWadhams\JsonLogic::apply(...);
```

--------------------------------

### in operation implementation

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/operations.md

PHP implementation of the 'in' operation. For an array, it checks membership; for a string, it checks substring containment; otherwise returns false.

```php
'in' => function ($a, $b) {
    if (is_array($b)) {
        return in_array($a, $b);
    }
    if (is_string($b)) {
        return strpos($b, $a) !== false;
    }
    return false;
}
```

--------------------------------

### Custom operation and error handling

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/apply.md

Registers a custom operation `sqrt` using the runtime built-in `sqrt` function, then applies it. Also demonstrates error handling: applying an unrecognized operator `fubar` throws an exception with message "Unrecognized operator fubar".

```php
JsonLogic::add_operation("sqrt", 'sqrt');
JsonLogic::apply(["sqrt" => 1764]);
// 42

try {
    JsonLogic::apply(["fubar" => [1, 2]]);
} catch (\Exception $e) {
    echo $e->getMessage(); // "Unrecognized operator fubar"
}
```

--------------------------------

### rule_like($rule, $pattern)

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/README.md

Checks if a rule matches a given pattern.

```APIDOC
## rule_like($rule, $pattern)

### Description
Checks if a rule matches a given pattern.

### Method
N/A (static method)

### Endpoint
N/A

### Parameters
- **$rule** (array) - Required - The rule to check.
- **$pattern** (array) - Required - The pattern to match against.

### Response
Returns true if the rule matches the pattern, false otherwise.

### Response Example
```php
$matches = JsonLogic::rule_like(['==', 1, 1], ['==', 1, 1]); // returns true
```
```

--------------------------------

### Basic static rule with JsonLogic::apply

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/apply.md

Applies a static rule with no data. The rule uses the equality operator `==` with operands `[1, 1]`, and the result is `true`.

```php
use JWadhams\JsonLogic;

$result = JsonLogic::apply(["==" => [1, 1]]);
// true
```

--------------------------------

### Class declaration for JWadhams\JsonLogic

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

The complete class declaration with its private static registry and all public static method signatures, exactly as declared in src/JWadhams/JsonLogic.php.

```php
namespace JWadhams;

class JsonLogic
{
    private static $custom_operations = [];

    public static function get_operator($logic)
    public static function get_values($logic, $fix_unary = true)
    public static function is_logic($array)
    public static function truthy($logic)
    public static function apply($logic = [], $data = [])
    public static function uses_data($logic)
    public static function rule_like($rule, $pattern)
    public static function add_operation($name, $callable)
}
```

--------------------------------

### JWadhams\JsonLogic::apply

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/apply.md

Evaluates a JsonLogic rule against optional data and returns the result. This is the primary entry point for the library.

```APIDOC
## JWadhams\JsonLogic::apply

### Description
Evaluates a JsonLogic rule against optional data and returns the result. This is the primary entry point for the library.

### Method
PHP static method

### Signature
```php
public static function apply($logic = [], $data = [])
```

### Parameters
- **$logic** (mixed) - Optional - The rule to evaluate. A well-formed rule is an array/object with exactly one string key (the operator) and an array of operand values. Non-rule values are passed through or mapped. Objects are cast to arrays first.
- **$data** (mixed) - Optional - The data environment that `var` and the scoped operators read from. Any PHP value: array, object, scalar.

### Return Value
mixed - The evaluation result, dependent on the rule. Literals are returned unchanged; operators return their closure's result; `if`/`and`/`or` return operand values; `filter`/`map`/`reduce`/`all`/`none`/`some` return arrays/booleans as documented in operations.md.

### Exceptions
- **\Exception** - Thrown when the rule's operator is neither in the custom registry nor the built-in table. Message: "Unrecognized operator $op".

### Evaluation Pipeline
1. **Object normalization**: If `$logic` is an object, cast it to an array with `(array)$logic`.
2. **Non-rule handling**: If `is_logic($logic)` is false:
   - If `$logic` is an array, map `apply($l, $data)` over each element.
   - Otherwise, return `$logic` unchanged.
3. **Built-in operator table**: A local `$operators` array maps operator names to closures.
4. **Operand extraction**: `$op = get_operator($logic)`, `$values = get_values($logic)` (unary fixing applied).
5. **Special-cased operators**: `if`/`?:`, `and`, `or`, `filter`, `map`, `reduce`, `all`, `none`, `some` are handled before generic dispatch.
6. **Operation resolution**: Consult `isset(self::$custom_operations[$op])` first, then `isset($operators[$op])`; if neither, throw exception. Custom operations shadow built-ins.
7. **Recursion + invocation**: Every operand is evaluated via `self::apply($value, $data)`, then the resolved operation is invoked with evaluated operands spread as arguments via `call_user_func_array($operation, $values)`.

### Data Flow
`$data` is threaded unchanged through every recursive `apply()` call, except inside `filter`/`map`/`reduce`/`all`/`none`/`some`, where each element is substituted as the data argument for scoped rules.
```

--------------------------------

### get_operator used with get_values to decompose a rule

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Demonstrates extracting both the operator and values from a compound rule using get_operator and get_values.

```php
$rule = ["and" => [ [">" => [3, 1]], ["<" => [1, 3]] ]];

$op     = JsonLogic::get_operator($rule);
$values = JsonLogic::get_values($rule);
// $op     == "and"
// $values == [ [">" => [3, 1]], ["<" => [1, 3]] ]
```

--------------------------------

### `missing`

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/operations.md

The `missing` operation returns a list of keys from the provided operands that are missing in the data context. A key is considered missing when `var` yields `null` or an empty string.

```APIDOC
## `missing`

### Description
Returns a list of keys from the provided operands that are missing in the data context. A key is considered missing when `var` yields `null` or an empty string.

### Method
N/A (PHP function)

### Endpoint
N/A

### Parameters
- **operands** (mixed) - Required - Accepts many key operands, or a single array operand (as produced by `if`/`merge` in composed rules).

### Request Example
```php
JsonLogic::apply(["missing" => ["a", "b"]], ["a" => 1]);
```

### Response
#### Success Response
- **missing** (array) - List of keys that are missing (i.e., `var` yields `null` or `""`).

#### Response Example
```php
["b"]
```
```

--------------------------------

### Simple equality rule with JsonLogic apply

Source: https://github.com/jwadhams/json-logic-php/blob/master/README.md

A simple rule that compares 1 and 1, equivalent to `1 == 1`. The operator is always the key, and values are typically an array, each being a string, number, boolean, array, or null.

```php
JWadhams\JsonLogic::apply( [ "==" => [1, 1] ] );
// true
```

--------------------------------

### missing_some operation implementation

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/operations.md

PHP implementation of the 'missing_some' operation. Returns an empty array when at least the minimum number of options are present, otherwise returns the list of missing keys. The options parameter must be an array.

```php
'missing_some' => function ($minimum, $options) use ($data) {
    $are_missing = static::apply(['missing'=>$options], $data);
    if (count($options) - count($are_missing) >= $minimum) {
        return [];
    } else {
        return $are_missing;
    }
}
```

--------------------------------

### apply($logic = [], $data = [])

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/README.md

Applies a JsonLogic rule to the provided data and returns the result. This is the primary entry point for evaluating rules.

```APIDOC
## apply($logic = [], $data = [])

### Description
Applies a JsonLogic rule to the provided data and returns the result. This is the primary entry point for evaluating rules.

### Method
N/A (static method)

### Endpoint
N/A

### Parameters
- **$logic** (array) - Optional - The logic rule to apply (default empty array).
- **$data** (array) - Optional - The data to apply the rule to (default empty array).

### Response
Returns the result of applying the rule to the data.

### Response Example
```php
$result = JsonLogic::apply(['==', 1, 1], []); // returns true
```
```

--------------------------------

### Data-driven rule with unary sugar and dot-notation

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/apply.md

Applies a data-driven rule using `and`, `<`, and `==` operators. Uses unary sugar for `var` operands and dot-notation to access nested data (`pie.filling`). The result is `true`.

```php
$rules = ["and" => [
    ["<" => [["var" => "temp"], 110]],
    ["==" => [["var" => "pie.filling"], "apple"]]
]];
$data  = ["temp" => 100, "pie" => ["filling" => "apple"]];

JsonLogic::apply($rules, $data);
// true
```

--------------------------------

### missing operation implementation

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/operations.md

PHP implementation of the 'missing' operation. Accepts multiple key operands or a single array operand. A key is considered missing when 'var' yields null or an empty string.

```php
'missing' => function () use ($data) {
    $values = func_get_args();
    if (!static::is_logic($values) and isset($values[0]) and is_array($values[0])) {
        $values = $values[0];
    }
    $missing = [];
    foreach ($values as $data_key) {
        $value = static::apply(['var'=>$data_key], $data);
        if ($value === null or $value === "") {
            array_push($missing, $data_key);
        }
    }
    return $missing;
}
```

--------------------------------

### uses_data method implementation

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Implementation of the uses_data method. It casts objects to arrays, then recursively collects keys referenced by 'var' operations, returning unique keys. Note the caveat: if the argument to 'var' is itself a rule, it is pushed as-is rather than resolved.

```php
if (is_object($logic)) {
    $logic = (array)$logic;
}
$collection = [];

if (self::is_logic($logic)) {
    $op = array_keys($logic)[0];
    $values = (array)$logic[$op];

    if ($op === "var") {
        //This doesn't cover the case where the arg to var is itself a rule.
        $collection[] = $values[0];
    } else {
        //Recursion!
        foreach ($values as $value) {
            $collection = array_merge($collection, self::uses_data($value));
        }
    }
}

return array_unique($collection);
```

--------------------------------

### `missing_some`

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/operations.md

The `missing_some` operation returns an empty array when at least the specified minimum number of options are present; otherwise, it returns the list of missing keys.

```APIDOC
## `missing_some`

### Description
Returns an empty array when at least the specified minimum number of options are present; otherwise, returns the list of missing keys.

### Method
N/A (PHP function)

### Endpoint
N/A

### Parameters
- **minimum** (integer) - Required - The minimum number of options that must be present.
- **options** (array) - Required - The list of keys to check for presence.

### Request Example
```php
JsonLogic::apply(["missing_some" => [1, ["a", "b"]]], ["a" => 1]);
```

### Response
#### Success Response
- **result** (array) - Empty array if at least `minimum` options are present; otherwise, the list of missing keys.

#### Response Example
```php
[]
```
```

--------------------------------

### JWadhams\JsonLogic::rule_like

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Checks whether a rule matches a given pattern.

```APIDOC
## `JWadhams\JsonLogic::rule_like($rule, $pattern)`

### Description
Checks whether a rule matches a given pattern. The pattern can contain wildcards (`*`) that match any value.

### Method
`rule_like` (static)

### Parameters
- **$rule** (mixed) - Required - The rule to check.
- **$pattern** (mixed) - Required - The pattern to match against.

### Return Value
- **bool** - `true` if the rule matches the pattern, `false` otherwise.

### Example
```php
$matches = JWadhams\JsonLogic::rule_like(['==', [1, 1]], ['==', ['*', '*']]); // true
```
```

--------------------------------

### get_values method signature

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Declares the public static method get_values with an optional $fix_unary parameter.

```php
public static function get_values($logic, $fix_unary = true)
```

--------------------------------

### get_values($logic, $fix_unary = true)

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/README.md

Extracts the values (arguments) from a logic rule array.

```APIDOC
## get_values($logic, $fix_unary = true)

### Description
Extracts the values (arguments) from a logic rule array.

### Method
N/A (static method)

### Endpoint
N/A

### Parameters
- **$logic** (array) - Required - The logic rule array.
- **$fix_unary** (bool) - Optional - Whether to fix unary operators (default true).

### Response
Returns an array of values from the logic rule.

### Response Example
```php
$values = JsonLogic::get_values(['==', 1, 1]); // returns [1, 1]
```
```

--------------------------------

### Compound rule with and, >, < operators

Source: https://github.com/jwadhams/json-logic-php/blob/master/README.md

A compound rule nesting 'and', '>' and '<' operators. The PHP infix equivalent is shown for comparison.

```php
JWadhams\JsonLogic::apply(
	[ "and" => [
		[ ">" => [3,1] ],
		[ "<" => [1,3] ]
	] ]
);
// true
```

```php
( (3 > 1) and (1 < 3) )
```

--------------------------------

### Array of rules and literal passthrough

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/apply.md

Shows two behaviors: applying an array of rules evaluates each element and returns an array of results, and applying a non-rule value returns it immediately without evaluation.

```php
JsonLogic::apply([["==" => [1, 1]], ["!=" => [1, 2]]]);
// [true, true]   (array of rules — each element evaluated)

JsonLogic::apply(true, "ignored");
// true   (non-rule: returned immediately)
```

--------------------------------

### get_operator method signature

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Declares the public static method get_operator that takes a rule and returns the operator name.

```php
public static function get_operator($logic)
```

--------------------------------

### uses_data($logic)

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/README.md

Checks whether a logic rule references any data variables.

```APIDOC
## uses_data($logic)

### Description
Checks whether a logic rule references any data variables.

### Method
N/A (static method)

### Endpoint
N/A

### Parameters
- **$logic** (array) - Required - The logic rule to inspect.

### Response
Returns true if the rule uses data variables, false otherwise.

### Response Example
```php
$usesData = JsonLogic::uses_data(['var', 'a']); // returns true
```
```

--------------------------------

### add_operation

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Registers a custom operator in the global static registry `$custom_operations`. Once registered, `apply()` resolves the name from this registry before the built-in table, so a custom operation can shadow a built-in.

```APIDOC
## `add_operation`

### Description
Registers a custom operator in the global static registry `$custom_operations`. Once registered, `apply()` resolves the name from this registry before the built-in table, so a custom operation can shadow a built-in.

### Method
`public static function add_operation($name, $callable)`

### Parameters
- **$name** (string) - Required - Operator name used as the rule's single key (e.g. `"times"`)
- **$callable** (callable or string) - Required - A closure, the name of a runtime built-in function, or a `Class::method` static-call string, invoked via `call_user_func_array` with the evaluated operands

### Return
none (no `return` statement in the method body).

### Throws
none explicitly.

### Example — closure with side effects (pattern from `tests/JsonLogicTest.php`):
```php
use JWadhams\JsonLogic;

$total = 0;
JsonLogic::add_operation("add_to_total", function ($b = 1) use (&$total) {
    $total += $b;
    return $total;
});

JsonLogic::apply(["add_to_total" => []]);  // 1
JsonLogic::apply(["add_to_total" => 41]);  // 42  (unary sugar for [41])
// $total == 42
```

### Example — passing rule operands to a dynamic-arity operation:
```php
JsonLogic::add_operation("times", function ($a, $b) {
    return $a * $b;
});
JsonLogic::apply(
    ["times" => [["var" => "a"], ["var" => "b"]]],
    ["a" => 6, "b" => 7]
);
// 42
```

A registered name may shadow a built-in (e.g. redefining `"log"` or `"+"`); the registry persists for the lifetime of the process. See [apply.md](apply.md) for the resolution order and [errors.md](../errors.md) for the unknown-operator failure mode.
```

--------------------------------

### is_logic($array)

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/README.md

Checks if the given array is a valid logic rule.

```APIDOC
## is_logic($array)

### Description
Checks if the given array is a valid logic rule (i.e., an array with an operator as its first element).

### Method
N/A (static method)

### Endpoint
N/A

### Parameters
- **$array** (mixed) - Required - The value to check.

### Response
Returns true if the array is a logic rule, false otherwise.

### Response Example
```php
$isLogic = JsonLogic::is_logic(['==', 1, 1]); // returns true
```
```

--------------------------------

### var operator closure implementation

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/operations.md

The closure for the 'var' operator, which performs data lookup using dot-notation. It returns the entire data when the key is null or empty, otherwise it traverses the data structure, supporting arrays, ArrayAccess, and objects. Returns the default value if a property is not found.

```php
'var' => function ($a = null, $default = null) use ($data) {
    if ($a === null or $a === "") {
        return $data;
    }
    //Descending into data using dot-notation
    foreach (explode('.', $a) as $prop) {
        if ((is_array($data) || $data instanceof \ArrayAccess) && isset($data[$prop])) {
            $data = $data[$prop];
        } elseif (is_object($data) && isset($data->{$prop})) {
            $data = $data->{$prop};
        } else {
            return $default; //Trying to get a value from a primitive
        }
    }
    return $data;
}
```

--------------------------------

### add_operation method signature

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Declares the static method that registers a custom operator in the global static registry $custom_operations.

```php
public static function add_operation($name, $callable)
```

--------------------------------

### get_operator method body

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Returns the first key of the rule array, which is the operator name.

```php
return array_keys($logic)[0];
```

--------------------------------

### JWadhams\JsonLogic::get_values

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Extracts the values (arguments) from a logic rule array.

```APIDOC
## `JWadhams\JsonLogic::get_values($logic, $fix_unary = true)`

### Description
Extracts the values (arguments) from a logic rule array. If the rule is unary and `$fix_unary` is true, the values are wrapped in an array.

### Method
`get_values` (static)

### Parameters
- **$logic** (array) - Required - The logic rule array.
- **$fix_unary** (bool) - Optional - Whether to fix unary rules. Defaults to `true`.

### Return Value
- **array** - The values (arguments) of the rule.

### Example
```php
$logic = ['==', [1, 1]];
$values = JWadhams\JsonLogic::get_values($logic); // [1, 1]
```
```

--------------------------------

### Access data property with var operator

Source: https://github.com/jwadhams/json-logic-php/blob/master/README.md

Uses the `var` operator to access a data property. The rule and data are passed as two arguments.

```php
JWadhams\JsonLogic::apply(
	[ "var" => ["a"] ], // Rule
	[ "a" => 1, "b" => 2 ]   // Data
);
// 1
```

--------------------------------

### JWadhams\JsonLogic::uses_data

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Determines whether the given logic rule uses any data references.

```APIDOC
## `JWadhams\JsonLogic::uses_data($logic)`

### Description
Determines whether the given logic rule uses any data references (i.e., contains a `var` operation).

### Method
`uses_data` (static)

### Parameters
- **$logic** (array) - Required - The logic rule to inspect.

### Return Value
- **bool** - `true` if the rule uses data, `false` otherwise.

### Example
```php
$usesData = JWadhams\JsonLogic::uses_data(['var', 'a']); // true
```
```

--------------------------------

### add_operation method body

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

The body of add_operation, which stores the callable in the custom operations registry.

```php
self::$custom_operations[$name] = $callable;
```

--------------------------------

### get_operator($logic)

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/README.md

Returns the operator name from a logic rule array.

```APIDOC
## get_operator($logic)

### Description
Returns the operator name from a logic rule array.

### Method
N/A (static method)

### Endpoint
N/A

### Parameters
- **$logic** (array) - Required - The logic rule array.

### Response
Returns the operator name (string) or null if not a logic rule.

### Response Example
```php
$operator = JsonLogic::get_operator(['==', 1, 1]); // returns '=='
```
```

--------------------------------

### Complex rule mixing literals and data

Source: https://github.com/jwadhams/json-logic-php/blob/master/README.md

A complex rule mixing literals and data access with nested 'var' operators, using dot notation for nested properties (e.g., 'pie.filling'). Evaluates to true when temp < 110 and pie.filling == 'apple'.

```php
$rules = [ "and" => [
	[ "<" => [ [ "var" => "temp" ], 110 ] ],
	[ "==" => [ [ "var" => "pie.filling" ], "apple" ] ]
] ];

$data = [ "temp" => 100, "pie" => [ "filling" => "apple" ] ];

JWadhams\JsonLogic::apply($rules, $data);
// true
```

--------------------------------

### get_values method body

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Returns the operands of a rule, wrapping scalar or single-rule operands into an array when $fix_unary is true.

```php
$op = static::get_operator($logic);
$values = $logic[$op];

//easy syntax for unary operators, like ["var" => "x"] instead of strict ["var" => ["x"]]
if ($fix_unary and (!is_array($values) or static::is_logic($values))) {
    $values = [ $values ];
}
return $values;
```

--------------------------------

### JWadhams\JsonLogic::get_operator

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/JsonLogic.md

Returns the operator name from a logic rule array.

```APIDOC
## `JWadhams\JsonLogic::get_operator($logic)`

### Description
Returns the operator name from a logic rule array. The rule must be an array with exactly one key, which is the operator name.

### Method
`get_operator` (static)

### Parameters
- **$logic** (array) - Required - The logic rule array.

### Return Value
- **string** - The operator name.

### Example
```php
$logic = ['==', [1, 1]];
$operator = JWadhams\JsonLogic::get_operator($logic); // '=='
```
```

--------------------------------

### `in`

Source: https://github.com/jwadhams/json-logic-php/blob/master/_autodocs/api-reference/operations.md

The `in` operation checks if a value is contained within an array or a string. For arrays, it performs a membership test; for strings, it checks substring containment.

```APIDOC
## `in`

### Description
Checks if a value is contained within an array or a string. For arrays, it performs a membership test; for strings, it checks substring containment.

### Method
N/A (PHP function)

### Endpoint
N/A

### Parameters
- **a** (mixed) - Required - The value to search for.
- **b** (mixed) - Required - The array or string to search within.

### Request Example
```php
JsonLogic::apply(["in" => ["a", ["a", "b"]]]);
```

### Response
#### Success Response
- **result** (boolean) - `true` if `a` is found in `b`; otherwise, `false`.

#### Response Example
```php
true
```
```

--------------------------------

### Access array by numeric index with var operator

Source: https://github.com/jwadhams/json-logic-php/blob/master/README.md

Uses the `var` operator with a numeric index to access an array element by index.

```php
JWadhams\JsonLogic::apply(
	[ "var" => 1 ],
	[ "apple", "banana", "carrot" ]
);
// "banana"
```
Tokens:
Raw