Railt\SDL\Backend\HashTable\ValueFactory

Complexity

Total Complexity

21

Size/Duplication

Total Lines	121
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	make()	0	6	2
B	create()	0	34	10
A	fromIterator()	0	19	5
A	addCaster()	0	7	2
A	each()	0	4	2

<?php

/**
 * This file is part of Railt package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Railt\SDL\Backend\HashTable;

use Phplrt\Source\Exception\NotAccessibleException;
use Railt\Dumper\Facade;
use Railt\SDL\Exception\TypeErrorException;
use Railt\SDL\Frontend\Ast\Node;
use Railt\TypeSystem\Value\BooleanValue;
use Railt\TypeSystem\Value\FloatValue;
use Railt\TypeSystem\Value\InputObjectValue;
use Railt\TypeSystem\Value\IntValue;
use Railt\TypeSystem\Value\ListValue;

The type Railt\TypeSystem\Value\ListValue was not found. Maybe you did not declare it correctly or list all dependencies?

use Railt\TypeSystem\Value\NullValue;
use Railt\TypeSystem\Value\StringValue;
use Railt\TypeSystem\Value\ValueInterface;

/**
 * Class ValueFactory
 */
class ValueFactory
{
    /**
     * @var array|\Closure[]
     */
    protected array $casters = [];

    /**
     * @param \Closure $caster
     * @param bool $append
     * @return $this
     */
    public function addCaster(\Closure $caster, bool $append = true): self
    {
        $this->casters = $append
            ? [...$this->casters, $caster]
            : [$caster, ...$this->casters];

        return $this;
    }

    /**
     * @param iterable|mixed[] $values
     * @param Node|null $ctx
     * @return iterable|ValueInterface[]
     * @throws NotAccessibleException
     * @throws TypeErrorException
     * @throws \RuntimeException
     */
    public function each(iterable $values, Node $ctx = null): iterable
    {
        foreach ($values as $name => $value) {
            yield $name => $this->make($value, $ctx);

The expression yield $name => $this->make($value, $ctx) returns the type Generator which is incompatible with the documented return type Railt\TypeSystem\Value\ValueInterface[]|iterable.

        }
    }

    /**
     * @param mixed $value
     * @param Node|null $context
     * @return ValueInterface
     * @throws TypeErrorException
     * @throws NotAccessibleException
     * @throws \RuntimeException
     */
    public function make($value, Node $context = null): ValueInterface
    {
        try {
            return $this->create($value);
        } catch (\Throwable $e) {
            throw TypeErrorException::fromAst($e->getMessage(), $context, $e);
        }
    }

    /**
     * @param mixed $value
     * @return ValueInterface
     * @throws \InvalidArgumentException
     * @throws \OverflowException
     */
    private function create($value): ValueInterface
    {
        switch (true) {
            case $value instanceof ValueInterface:
                return $value;

            case \is_bool($value):
                return BooleanValue::parse($value);

            case \is_float($value):
                return FloatValue::parse($value);

            case \is_int($value):
                return IntValue::parse($value);

            case $value === null:
                return NullValue::parse($value);

            case \is_string($value):
                return StringValue::parse($value);

            case \is_iterable($value):
                return $this->fromIterator($value);

            default:
                foreach ($this->casters as $caster) {
                    if ($result = $caster($value)) {
                        return $result;
                    }
                }

                $error = 'Value of type %s can not be converted to GraphQL type';

                throw new \InvalidArgumentException(\sprintf($error, Facade::dump($value)));
        }
    }

    /**
     * @param iterable $iterator
     * @return ValueInterface
     * @throws \InvalidArgumentException
     * @throws \OverflowException
     */
    private function fromIterator(iterable $iterator): ValueInterface
    {
        [$result, $isObject] = [[], false];

        foreach ($iterator as $key => $value) {
            if (\is_string($key)) {
                $isObject = true;
            }

            if ($isObject) {
                $result[$key] = $this->create($value);
            } else {
                $result[] = $this->create($value);
            }
        }

        return $isObject
            ? InputObjectValue::parse($result)
            : ListValue::parse($result);
    }
}