Kir\MySQL\Builder\Expr\DBExprFilter

Complexity

Total Complexity

16

Size/Duplication

Total Lines	116
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	3
Bugs	1	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	19	4
A	getExpression()	0	3	1
A	isValid()	0	8	1
A	getValue()	0	3	1
A	buildKey()	0	9	3
A	isValidArray()	0	9	2
A	recursiveGet()	0	14	4

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

use Exception;

class DBExprFilter implements OptionalExpression {
	/** @var */
	private $expression;
	/** @var mixed */
	private $value;
	/** @var string[] */
	private $keyPath;
	/** @var callable|null */
	private $validator;
	/** @var callable */
	private $validationResultHandler;

	/**
	 * @param string $expression
	 * @param array $data
	 * @param string|string[] $keyPath
	 * @param callable|null $validator
	 * @param callable|null $validationResultHandler
	 * @throws Exception
	 */
	public function __construct($expression, array $data, $keyPath, $validator = null, $validationResultHandler = null) {
		$this->expression = $expression;
		$this->value = $data;
		$this->keyPath = $this->buildKey($keyPath);
		$this->value = $this->recursiveGet($data, $this->keyPath, null);
		if($validator === null) {
			$validator = function ($data) {
				if(is_array($data)) {
					return $this->isValidArray($data);
				}
				return (string) $data !== '';
			};
		}
		if($validationResultHandler === null) {
			$validationResultHandler = function () {};
		}
		$this->validator = $validator;
		$this->validationResultHandler = $validationResultHandler;
	}

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

	/**
	 * @return bool
	 */
	public function isValid() {
		$result = call_user_func($this->validator, $this->value);
		call_user_func($this->validationResultHandler, $result, [
			'value' => $this->value,
			'key' => join('.', $this->keyPath),
		]);
		return $result;
	}

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

	/**
	 * @param string|string[] $keyPath
	 * @return string
	 * @throws Exception
	 */
	private function buildKey($keyPath) {
		if(is_string($keyPath)) {
			$keyPath = explode('.', $keyPath);
		}
		if(!is_array($keyPath)) {
			throw new Exception('Invalid key');
		}
		return $keyPath;
	}

	/**
	 * @param array $array
	 * @return bool
	 */
	private function isValidArray(array $array) {
		$data = array_filter($array, function ($value) {
			if(is_array($value)) {
				return $this->isValidArray($value);
			}
			return (string) $value !== '';
		});
		return count($data) > 0;
	}

	/**
	 * @param array $array
	 * @param array $path
	 * @param mixed $default
	 * @return array
	 */
	private function recursiveGet($array, $path, $default) {
		$count = count($path);
		if (!$count) {
			return $default;
		}
		for($idx = 0; $idx < $count; $idx++) {
			$part = $path[$idx];
			if(!array_key_exists($part, $array)) {
				return $default;
			}
			$array = $array[$part];
		}
		return $array;
	}
}