<?php
/* ============================================================================
* Copyright 2020 Zindex Software
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* ============================================================================ */
namespace Opis\JsonSchema\Errors;
use Opis\JsonSchema\JsonPointer;
class ErrorFormatter
{
/**
* @param ValidationError $error
* @param bool $multiple True if the same key can have multiple errors
* @param ?callable(ValidationError,?string=null):mixed $formatter
* @param ?callable(ValidationError):string $key_formatter
* @return array
*/
public function format(
ValidationError $error,
bool $multiple = true,
?callable $formatter = null,
?callable $key_formatter = null
): array {
if (!$formatter) {
$formatter = [$this, 'formatErrorMessage'];
}
if (!$key_formatter) {
$key_formatter = [$this, 'formatErrorKey'];
}
$list = [];
/**
* @var ValidationError $error
* @var string $message
*/
foreach ($this->getErrors($error) as $error => $message) {
$key = $key_formatter($error);
if ($multiple) {
if (!isset($list[$key])) {
$list[$key] = [];
}
$list[$key][] = $formatter($error, $message);
} else {
if (!isset($list[$key])) {
$list[$key] = $formatter($error, $message);
}
}
}
return $list;
}
/**
* @param ValidationError|null $error
* @param string $mode One of: flag, basic, detailed or verbose
* @return array
*/
public function formatOutput(?ValidationError $error, string $mode = "flag"): array
{
if ($error === null) {
return ['valid' => true];
}
if ($mode === 'flag') {
return ['valid' => false];
}
if ($mode === 'basic') {
return [
'valid' => false,
'errors' => $this->formatFlat($error, [$this, 'formatOutputError']),
];
}
if ($mode === 'detailed' || $mode === 'verbose') {
$isVerbose = $mode === 'verbose';
return $this->getNestedErrors($error, function (ValidationError $error, ?array $subErrors = null) use ($isVerbose) {
$info = $this->formatOutputError($error);
$info['valid'] = false;
if ($isVerbose) {
$id = $error->schema()->info();
$id = $id->root() ?? $id->id();
if ($id) {
$id = rtrim($id, '#');
}
$info['absoluteKeywordLocation'] = $id . $info['keywordLocation'];
}
if ($subErrors) {
$info['errors'] = $subErrors;
if (!$isVerbose) {
unset($info['error']);
}
}
return $info;
}
);
}
return ['valid' => false];
}
/**
* @param ValidationError $error
* @param ?callable(ValidationError,?array):mixed $formatter
* @return mixed
*/
public function formatNested(ValidationError $error, ?callable $formatter = null)
{
if (!$formatter) {
$formatter = function (ValidationError $error, ?array $subErrors = null): array {
$ret = [
'message' => $this->formatErrorMessage($error),
'keyword' => $error->keyword(),
'path' => $this->formatErrorKey($error),
];
if ($subErrors) {
$ret['errors'] = $subErrors;
}
return $ret;
};
}
return $this->getNestedErrors($error, $formatter);
}
/**
* @param ValidationError $error
* @param ?callable(ValidationError):mixed $formatter
* @return array
*/
public function formatFlat(ValidationError $error, ?callable $formatter = null): array
{
if (!$formatter) {
$formatter = [$this, 'formatErrorMessage'];
}
$list = [];
foreach ($this->getFlatErrors($error) as $error) {
$list[] = $formatter($error);
}
return $list;
}
/**
* @param ValidationError $error
* @param ?callable(ValidationError):mixed $formatter
* @param ?callable(ValidationError):string $key_formatter
* @return array
*/
public function formatKeyed(
ValidationError $error,
?callable $formatter = null,
?callable $key_formatter = null
): array {
if (!$formatter) {
$formatter = [$this, 'formatErrorMessage'];
}
if (!$key_formatter) {
$key_formatter = [$this, 'formatErrorKey'];
}
$list = [];
foreach ($this->getLeafErrors($error) as $error) {
$key = $key_formatter($error);
if (!isset($list[$key])) {
$list[$key] = [];
}
$list[$key][] = $formatter($error);
}
return $list;
}
/**
* @param ValidationError $error
* @param string|null $message The message to use, if null $error->message() is used
* @return string
*/
public function formatErrorMessage(ValidationError $error, ?string $message = null): string
{
$message ??= $error->message();
$args = $this->getDefaultArgs($error) + $error->args();
if (!$args) {
return $message;
}
return preg_replace_callback(
'~{([^}]+)}~imu',
static function (array $m) use ($args) {
if (!isset($args[$m[1]])) {
return $m[0];
}
$value = $args[$m[1]];
if (is_array($value)) {
return implode(', ', $value);
}
return (string) $value;
},
$message
);
}
public function formatErrorKey(ValidationError $error): string
{
return JsonPointer::pathToString($error->data()->fullPath());
}
protected function getDefaultArgs(ValidationError $error): array
{
$data = $error->data();
$info = $error->schema()->info();
$path = $info->path();
$path[] = $error->keyword();
return [
'data:type' => $data->type(),
'data:value' => $data->value(),
'data:path' => JsonPointer::pathToString($data->fullPath()),
'schema:id' => $info->id(),
'schema:root' => $info->root(),
'schema:base' => $info->base(),
'schema:draft' => $info->draft(),
'schema:keyword' => $error->keyword(),
'schema:path' => JsonPointer::pathToString($path),
];
}
protected function formatOutputError(ValidationError $error): array
{
$path = $error->schema()->info()->path();
$path[] = $error->keyword();
return [
'keywordLocation' => JsonPointer::pathToFragment($path),
'instanceLocation' => JsonPointer::pathToFragment($error->data()->fullPath()),
'error' => $this->formatErrorMessage($error),
];
}
/**
* @param ValidationError $error
* @param callable(ValidationError,?array):mixed $formatter
* @return mixed
*/
protected function getNestedErrors(ValidationError $error, callable $formatter)
{
if ($subErrors = $error->subErrors()) {
foreach ($subErrors as &$subError) {
$subError = $this->getNestedErrors($subError, $formatter);
unset($subError);
}
}
return $formatter($error, $subErrors);
}
/**
* @param ValidationError $error
* @return iterable|ValidationError[]
*/
protected function getFlatErrors(ValidationError $error): iterable
{
yield $error;
foreach ($error->subErrors() as $subError) {
yield from $this->getFlatErrors($subError);
}
}
/**
* @param ValidationError $error
* @return iterable|ValidationError[]
*/
protected function getLeafErrors(ValidationError $error): iterable
{
if ($subErrors = $error->subErrors()) {
foreach ($subErrors as $subError) {
yield from $this->getLeafErrors($subError);
}
} else {
yield $error;
}
}
/**
* @param ValidationError $error
* @return iterable
*/
protected function getErrors(ValidationError $error): iterable
{
$data = $error->schema()->info()->data();
$map = null;
$pMap = null;
if (is_object($data)) {
switch ($error->keyword()) {
case 'required':
if (isset($data->{'$error'}->required) && is_object($data->{'$error'}->required)) {
$e = $data->{'$error'}->required;
$found = false;
foreach ($error->args()['missing'] as $prop) {
if (isset($e->{$prop})) {
yield $error => $e->{$prop};
$found = true;
}
}
if ($found) {
return;
}
if (isset($e->{'*'})) {
yield $error => $e->{'*'};
return;
}
unset($e, $found, $prop);
}
break;
case '$filters':
if (($args = $error->args()) && isset($args['args']['$error'])) {
yield $error => $args['args']['$error'];
return;
}
unset($args);
break;
}
if (isset($data->{'$error'})) {
$map = $data->{'$error'};
if (is_string($map)) {
// We have an global error
yield $error => $map;
return;
}
if (is_object($map)) {
if (isset($map->{$error->keyword()})) {
$pMap = $map->{'*'} ?? null;
$map = $map->{$error->keyword()};
if (is_string($map)) {
yield $error => $map;
return;
}
} elseif (isset($map->{'*'})) {
yield $error => $map->{'*'};
return;
}
}
}
}
if (!is_object($map)) {
$map = null;
}
$subErrors = $error->subErrors();
if (!$subErrors) {
yield $error => $pMap ?? $error->message();
return;
}
if (!$map) {
foreach ($subErrors as $subError) {
yield from $this->getErrors($subError);
}
return;
}
foreach ($subErrors as $subError) {
$path = $subError->data()->path();
if (count($path) !== 1) {
yield from $this->getErrors($subError);
} else {
$path = $path[0];
if (isset($map->{$path})) {
yield $subError => $map->{$path};
} elseif (isset($map->{'*'})) {
yield $subError => $map->{'*'};
} else {
yield from $this->getErrors($subError);
}
}
}
}
}