Kir\MySQL\Builder\Expr\DBExprFilter

Complexity

Total Complexity

12

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Importance

Changes	2
Bugs	1	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	18	4
A	getValue()	0	2	1
A	getExpression()	0	2	1
A	buildKey()	0	8	3
A	isValid()	0	13	3

<?php
namespace Kir\MySQL\Builder\Expr;

use Kir\MySQL\Builder\Helpers\RecursiveStructureAccess;
use RuntimeException;

class DBExprFilter implements OptionalExpression {
	/** @var bool */
	private $hasValue;
	/** @var mixed */
	private $value;
	/** @var null|callable(mixed): bool */
	private $validator;
	/** @var callable(bool, array{key: mixed, value: string}) */
	private $validationResultHandler;
	/** @var string[] */
	private array $keyPath;

	/**
	 * @param string $expression
	 * @param array<string, mixed> $data
	 * @param string|string[] $keyPath
	 * @param callable|null $validator
	 * @param callable|null $validationResultHandler
	 */
	public function __construct(
		private string $expression,
		array $data,
		string|array $keyPath,
		$validator = null,
		$validationResultHandler = null
	) {
		$this->keyPath = $this->buildKey($keyPath);
		$this->value = RecursiveStructureAccess::recursiveGet($data, $this->keyPath, null);
		$this->hasValue = is_scalar($this->value) ? trim((string) $this->value) !== '' : !empty($this->value);
		if($validator === null) {
			$validator = static fn() => true;
		}
		$this->validator = $validator;
		if($validationResultHandler === null) {
			$validationResultHandler = static function () {};
		}
		$this->validationResultHandler = $validationResultHandler;
	}

	/**
	 * @return string
	 */
	public function getExpression(): string {
		return $this->expression;
	}

	/**
	 * @return bool
	 */
	public function isValid(): bool {
		if(!$this->hasValue) {
			return false;
		}
		if($this->validator !== null) {
			$result = call_user_func($this->validator, $this->value);
			call_user_func($this->validationResultHandler, $result, [
				'value' => $this->value,
				'key' => implode('.', $this->keyPath),
			]);
			return $result;
		}
		return true;
	}

	/**
	 * @return array{mixed}

The doc comment array{mixed} at position 2 could not be parsed: Expected ':' at position 2, but found 'mixed'.

	 */
	public function getValue(): array {
		return [$this->value];
	}

	/**
	 * @param string|string[] $keyPath
	 * @return string[]
	 */
	private function buildKey($keyPath): array {
		if(is_string($keyPath)) {
			$keyPath = explode('.', $keyPath);
		}
		if(!is_array($keyPath)) {

The condition is_array($keyPath) is always true.

			throw new RuntimeException('Invalid key');
		}
		return $keyPath;
	}
}