TournamentGenerator\Containers\ContainerQuery

Complexity

Total Complexity

50

Size/Duplication

Total Lines	308
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	0	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	getFirst()	0	6	2
A	get()	0	27	3
A	filterUnique()	0	14	5
A	ids()	0	3	1
B	sortByPropertyCallback()	0	23	11
A	desc()	0	3	1
A	sortBy()	0	3	1
B	pluckData()	0	16	7
A	getContainer()	0	2	1
A	sort()	0	13	4
A	applyFilters()	0	5	2
A	addSorter()	0	3	1
A	sortData()	0	9	4
A	filter()	0	3	1
A	whereId()	0	5	2
A	unique()	0	3	1
A	only()	0	6	2

<?php


namespace TournamentGenerator\Containers;

use Closure;
use Exception;
use TournamentGenerator\Helpers\Sorter\BaseSorter;
use TournamentGenerator\Interfaces\WithId;

/**
 * Class ContainerQuery
 *
 * Container query is a helper class to filter, sort, etc. the values of the container hierarchy.
 *
 * @package TournamentGenerator\Containers
 * @author  Tomáš Vojík <vojik@wboy.cz>
 * @since   0.4
 */
class ContainerQuery
{

	/** @var BaseContainer Queried container */
	protected BaseContainer $container;
	/** @var Closure[] Filter closures */
	protected array      $filters      = [];
	protected Closure    $sortClosure;
	protected string     $sortProperty;
	protected bool       $desc         = false;
	protected BaseSorter $sorter;
	protected bool       $topLevelOnly = false;
	protected bool       $uniqueOnly   = false;
	protected ?string    $pluck        = null;

	/**
	 * ContainerQuery constructor.
	 *
	 * @param BaseContainer $container Queried container
	 */
	public function __construct(BaseContainer $container, bool $topLevelOnly = false) {
		$this->container = $container;
		$this->topLevelOnly = $topLevelOnly;
	}

	/**
	 * Gets the first result of container query
	 *
	 * @return mixed|null
	 */
	public function getFirst() {
		$data = $this->get();
		if (count($data) === 0) {
			return null;
		}
		return reset($data);
	}

	/**
	 * Get the result
	 *
	 * @return array
	 */
	public function get() : array {
		// Get initial data
		if ($this->topLevelOnly) {
			$data = $this->container->getTopLevel();
		}
		else {
			$data = $this->container->get();
		}

		// Unique
		$this->filterUnique($data);

		// Filters
		$this->applyFilters($data);

		// Sorting
		$this->sortData($data);

		// Order reverse
		if ($this->desc) {
			$data = array_reverse($data, true);
		}

		// "Pluck" a specific value from an object
		$this->pluckData($data);

		return $data;
	}

	/**
	 *  Filter data to contain only unique values
	 *
	 * @param array $data
	 */
	protected function filterUnique(array &$data) : void {
		if ($this->uniqueOnly) {
			if (reset($data) instanceof WithId) {
				$ids = [];
				foreach ($data as $key => $obj) {
					if (in_array($obj->getId(), $ids, true)) {
						unset($data[$key]);
						continue;
					}
					$ids[] = $obj->getId();
				}
			}
			else {
				$data = array_unique($data);
			}
		}
	}

	/**
	 * Apply predefined filters on data
	 *
	 * @param $data
	 */
	protected function applyFilters(&$data) : void {
		foreach ($this->filters as $filter) {
			$data = array_filter($data, $filter);
		}
		$data = array_values($data); // Reset array keys
	}

	/**
	 * Sort data using a predefined filters
	 *
	 * @param array $data
	 */
	protected function sortData(array &$data) : void {
		if (isset($this->sorter)) {
			$data = $this->sorter->sort($data);
		}
		elseif (isset($this->sortClosure)) {
			uasort($data, $this->sortClosure);
		}
		elseif (isset($this->sortProperty)) {
			uasort($data, [$this, 'sortByPropertyCallback']);
		}
	}

	/**
	 * Pluck a predefined value from data values
	 *
	 * @param $data
	 */
	protected function pluckData(&$data) : void {
		if (!empty($this->pluck)) {
			$data = array_map(function($item) {
				if (is_array($item) && isset($item[$this->pluck])) {
					return $item[$this->pluck];
				}
				if (is_object($item)) {
					if (property_exists($item, $this->pluck)) {

It seems like $this->pluck can also be of type null; however, parameter $property of property_exists() does only seem to accept string, maybe add an additional type check?

						return $item->{$this->pluck};
					}
					if (method_exists($item, $this->pluck)) {

It seems like $this->pluck can also be of type null; however, parameter $method of method_exists() does only seem to accept string, maybe add an additional type check?

						return $item->{$this->pluck}();
					}
				}
				return $item;
			}, $data);
		}
	}

	/**
	 * Get query results as an container
	 *
	 * @return BaseContainer
	 * @throws Exception
	 */
	public function getContainer() : BaseContainer {
		return BaseContainer::fromArray($this->get());
	}

	/**
	 * Add a filter callback
	 *
	 * @param Closure $callback
	 *
	 * @return $this
	 */
	public function filter(Closure $callback) : ContainerQuery {
		$this->filters[] = $callback;
		return $this;
	}

	/**
	 * Filter results to only contain those with a specific ID
	 *
	 * @param string|int $id
	 *
	 * @return ContainerQuery
	 */
	public function whereId($id) : ContainerQuery {
		$this->filters[] = static function($object) use ($id) {
			return $object instanceof WithId && $object->getId() === $id;
		};
		return $this;
	}

	/**
	 * Sort in descending order
	 *
	 * @return $this
	 */
	public function desc() : ContainerQuery {
		$this->desc = true;
		return $this;
	}

	/**
	 * Sort a result using a callback - maintaining the index association
	 *
	 * @param Closure|null $callback
	 *
	 * @return $this
	 */
	public function sort(?Closure $callback = null) : ContainerQuery {
		if (is_null($callback)) {
			$this->sortClosure = static function($a, $b) {
				if ($a === $b) {
					return 0;
				}
				return $a < $b ? -1 : 1;
			};
		}
		else {
			$this->sortClosure = $callback;
		}
		return $this;
	}

	/**
	 * Sort a result set by a given property
	 *
	 * @warning Sort callback has a priority.
	 *
	 * @param string $property
	 *
	 * @return $this
	 */
	public function sortBy(string $property) : ContainerQuery {
		$this->sortProperty = $property;
		return $this;
	}

	/**
	 * @param BaseSorter $sorter
	 *
	 * @return $this
	 */
	public function addSorter(BaseSorter $sorter) : ContainerQuery {
		$this->sorter = $sorter;
		return $this;
	}

	/**
	 * Get only unique values
	 *
	 * @return $this
	 */
	public function unique() : ContainerQuery {
		$this->uniqueOnly = true;
		return $this;
	}

	/**
	 * Get only the object's ids
	 *
	 * @return $this
	 * @throws Exception
	 */
	public function ids() : ContainerQuery {
		$this->only('getId');
		return $this;
	}

	/**
	 * Pluck a specific key from all values
	 *
	 * @param string $property Property, array key or method to extract from values
	 *
	 * @return ContainerQuery
	 * @throws Exception
	 */
	public function only(string $property) : ContainerQuery {
		if (!empty($this->pluck)) {
			throw new Exception('only() can be only called once.');
		}
		$this->pluck = $property;
		return $this;
	}

	/**
	 * Sort function for sorting by a defined property
	 *
	 * @param array|object $value1
	 * @param array|object $value2
	 *
	 * @return int
	 */
	protected function sortByPropertyCallback($value1, $value2) : int {
		// Get values
		$property = $this->sortProperty ?? '';
		$property1 = null;
		$property2 = null;
		if (is_object($value1) && isset($value1->$property)) {
			$property1 = $value1->$property;
		}
		elseif (is_array($value1) && isset($value1[$property])) {
			$property1 = $value1[$property];
		}
		if (is_object($value2) && isset($value2->$property)) {
			$property2 = $value2->$property;
		}
		elseif (is_array($value2) && isset($value2[$property])) {
			$property2 = $value2[$property];
		}

		// Compare values
		if ($property1 === $property2) {
			return 0;
		}
		return $property1 < $property2 ? -1 : 1;
	}

}