Remorhaz\JSON\Path\Processor\Result\ResultFactory

Complexity

Total Complexity

14

Size/Duplication

Total Lines	76
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	createSelectOneResult()	0	3	1
A	createSelectPathsResult()	0	5	1
A	createSelectResult()	0	3	1
A	createValueResult()	0	5	2
A	getValuePath()	0	7	2
A	createSelectOnePathResult()	0	10	3
A	findSingleValue()	0	11	3

<?php

declare(strict_types=1);

namespace Remorhaz\JSON\Path\Processor\Result;

use Remorhaz\JSON\Data\Export\ValueDecoderInterface;
use Remorhaz\JSON\Data\Export\ValueEncoderInterface;
use Remorhaz\JSON\Data\Path\PathInterface;
use Remorhaz\JSON\Path\Processor\PathEncoderInterface;
use Remorhaz\JSON\Data\Value\NodeValueInterface;
use Remorhaz\JSON\Data\Value\ValueInterface;
use Remorhaz\JSON\Path\Value\ValueListInterface;

use function array_map;
use function count;

final class ResultFactory implements ResultFactoryInterface
{

    private $jsonEncoder;

    private $jsonDecoder;

    private $pathsEncoder;

    public function __construct(
        ValueEncoderInterface $jsonEncoder,
        ValueDecoderInterface $jsonDecoder,
        PathEncoderInterface $pathEncoder
    ) {
        $this->jsonEncoder = $jsonEncoder;
        $this->jsonDecoder = $jsonDecoder;
        $this->pathsEncoder = $pathEncoder;
    }

    public function createSelectResult(ValueListInterface $values): SelectResultInterface
    {
        return new SelectResult($this->jsonEncoder, $this->jsonDecoder, ...$values->getValues());
    }

    public function createSelectOneResult(ValueListInterface $values): ValueResultInterface
    {
        return $this->createValueResult($this->findSingleValue($values));
    }

    public function createSelectPathsResult(ValueListInterface $values): SelectPathsResultInterface
    {
        return new SelectPathsResult(
            $this->pathsEncoder,
            ...array_map([$this, 'getValuePath'], $values->getValues())
        );
    }

    private function getValuePath(ValueInterface $value): PathInterface
    {
        if (!$value instanceof NodeValueInterface) {
            throw new Exception\PathNotFoundInValueException($value);
        }

        return $value->getPath();
    }

    public function createSelectOnePathResult(ValueListInterface $values): SelectOnePathResultInterface
    {
        $value = $this->findSingleValue($values);
        $path = isset($value)
            ? $this->getValuePath($value)
            : null;

        return isset($path)
            ? new ExistingSelectOnePathResult($this->pathsEncoder, $path)
            : new NonExistingSelectOnePathResult();
    }

    private function findSingleValue(ValueListInterface $values): ?ValueInterface
    {
        switch (count($values->getValues())) {
            case 0:
                return null;

            case 1:
                return $values->getValue(0);
        }

        throw new Exception\MoreThanOneValueInListException($values);
    }

    public function createValueResult(?ValueInterface $value): ValueResultInterface
    {
        return isset($value)
            ? new ExistingValueResult($this->jsonEncoder, $this->jsonDecoder, $value)
            : new NonExistingValueResult();
    }
}