Railt\SDL\Backend\HashTable\VariablesVisitor

Complexity

Total Complexity

9

Size/Duplication

Total Lines	72
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	resolve()	0	7	2
A	enter()	0	14	4
A	__construct()	0	3	1
A	fetch()	0	9	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\Contracts\Ast\NodeInterface;
use Phplrt\Source\Exception\NotAccessibleException;
use Phplrt\Visitor\Visitor;
use Railt\SDL\Backend\HashTableInterface;
use Railt\SDL\Exception\TypeErrorException;
use Railt\SDL\Frontend\Ast\Definition\ArgumentDefinitionNode;
use Railt\SDL\Frontend\Ast\Definition\InputFieldDefinitionNode;
use Railt\SDL\Frontend\Ast\Executable\ArgumentNode;
use Railt\SDL\Frontend\Ast\Value\VariableValueNode;
use Railt\TypeSystem\Value\ValueInterface;

/**
 * Class VariablesVisitor
 */
class VariablesVisitor extends Visitor
{
    /**
     * @var HashTableInterface
     */
    private HashTableInterface $hash;

    /**
     * VariablesVisitor constructor.
     *
     * @param HashTableInterface $hash
     */
    public function __construct(HashTableInterface $hash)
    {
        $this->hash = $hash;
    }

    /**
     * @param NodeInterface $node
     * @return mixed|ValueInterface|null
     * @throws NotAccessibleException
     * @throws TypeErrorException
     * @throws \RuntimeException
     */
    public function enter(NodeInterface $node)
    {
        switch (true) {
            case $node instanceof InputFieldDefinitionNode:
            case $node instanceof ArgumentDefinitionNode:
                $node->defaultValue = $this->resolve($node->defaultValue);

Accessing defaultValue on the interface Phplrt\Contracts\Ast\NodeInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

                break;

            case $node instanceof ArgumentNode:
                $node->value = $this->resolve($node->value);
                break;
        }

        return null;
    }

    /**
     * @param ValueInterface|null $value
     * @return ValueInterface|null
     * @throws NotAccessibleException
     * @throws TypeErrorException
     * @throws \RuntimeException
     */
    private function resolve(?ValueInterface $value): ?ValueInterface
    {
        if ($value instanceof VariableValueNode) {
            return $this->fetch($value);
        }

        return $value;
    }

    /**
     * @param VariableValueNode $var
     * @return ValueInterface
     * @throws NotAccessibleException
     * @throws TypeErrorException
     * @throws \RuntimeException
     */
    private function fetch(VariableValueNode $var): ValueInterface
    {
        $value = $this->hash->get($var->getName(), $var);

        if ($value instanceof VariableValueNode) {
            return $this->fetch($value);
        }

        return $value;
    }
}