Softonic\GraphQL\DataObjects\AbstractCollection

Complexity

Total Complexity

29

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	has()	0	10	3
A	getIterator()	0	4	1
A	count()	0	13	4
A	isEmpty()	0	4	1
A	__get()	0	19	5
A	hasItem()	0	12	4
A	hasChildren()	0	10	3
A	filter()	0	13	3
A	areAllArgumentsCollections()	0	4	2
A	filterItems()	0	17	3
	buildFilteredCollection()	0	1	?
	buildSubCollection()	0	1	?

<?php

namespace Softonic\GraphQL\DataObjects;

use IteratorAggregate;
use RecursiveIteratorIterator;
use Softonic\GraphQL\DataObjects\Mutation\MutationObject;
use Softonic\GraphQL\DataObjects\Query\Collection;
use Softonic\GraphQL\Exceptions\InaccessibleArgumentException;
use Softonic\GraphQL\Traits\CollectionArrayAccess;

abstract class AbstractCollection extends AbstractObject implements IteratorAggregate, \ArrayAccess
{
    use CollectionArrayAccess;

    public function has(string $key): bool
    {
        foreach ($this->arguments as $argument) {
            if ($argument->has($key)) {
                return true;
            }
        }

        return false;
    }

    public function getIterator(): RecursiveIteratorIterator
    {
        return new RecursiveIteratorIterator(new CollectionIterator($this->arguments));
    }

    public function count(): int
    {
        $count = 0;
        foreach ($this->arguments as $argument) {
            if ($argument instanceof AbstractCollection) {
                $count += $argument->count();
            } elseif ($argument instanceof AbstractItem) {
                ++$count;
            }
        }

        return $count;
    }

    public function isEmpty(): bool
    {
        return $this->count() === 0;
    }

    public function __get(string $key): AbstractCollection
    {
        if (empty($this->arguments)) {
            throw InaccessibleArgumentException::fromEmptyArguments($key);
        }

        $items = [];
        foreach ($this->arguments as $argument) {
            if ($argument->{$key} instanceof Collection) {
                foreach ($argument->{$key} as $item) {
                    $items[] = $item;
                }
            } else {
                $items[] = $argument->{$key};
            }
        }

        return $this->buildSubCollection($items, $key);
    }

    public function hasItem(array $itemData): bool
    {
        foreach ($this->arguments as $argument) {
            $method = $argument instanceof AbstractCollection ? 'hasItem' : 'equals';

            if ($argument->$method($itemData)) {
                return true;
            }
        }

        return false;
    }

    public function hasChildren(): bool
    {
        foreach ($this->arguments as $argument) {
            if ($argument instanceof MutationObject) {
                return true;
            }
        }

        return false;
    }

    public function filter(array $filters): AbstractCollection
    {
        $filteredData = [];
        if ($this->areAllArgumentsCollections()) {
            foreach ($this->arguments as $argument) {
                $filteredData[] = $argument->filter($filters);
            }
        } else {
            $filteredData = $this->filterItems($this->arguments, $filters);
        }

        return $this->buildFilteredCollection($filteredData);
    }

    private function areAllArgumentsCollections(): bool
    {
        return (!empty($this->arguments[0]) && $this->arguments[0] instanceof AbstractCollection);
    }

    private function filterItems(array $arguments, array $filters): array
    {
        $filteredItems = array_filter(
            $arguments,
            function ($item) use ($filters) {
                foreach ($filters as $filterKey => $filterValue) {
                    if (!($item->{$filterKey} == $filterValue)) {
                        return false;
                    }
                }

                return true;
            }
        );

        return array_values($filteredItems);
    }

    abstract protected function buildFilteredCollection($items);

    abstract protected function buildSubCollection(array $items, string $key);
}