Factory - Code Metrics - Inspection of "Add directives support" - railt/sdl - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed
Push — master ( 1595cb...050b68 )

by Kirill
created 2020-02-07 12:33 UTC
Factory A

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	198
Duplicated Lines	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
wmc	21
eloc	63
dl	0
loc	198
rs	10
c	1
b	0
f	0
7 Methods

Rating	Name	Size	Complexity
A	assertGenericArguments()	13	2
B	make()	26	9
A	__construct()	5	1
A	ref()	9	2
A	assertMissingTypeArguments()	19	3
A	compileGenericType()	15	2
A	getContext()	12	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\Context;

use Phplrt\Source\Exception\NotAccessibleException;
use Railt\SDL\Backend\Context;
use Railt\SDL\Backend\HashTableInterface;
use Railt\SDL\Backend\NameResolver\NameResolverInterface;
use Railt\SDL\Exception\TypeErrorException;
use Railt\SDL\Frontend\Ast\Definition\DirectiveDefinitionNode;
use Railt\SDL\Frontend\Ast\Definition\SchemaDefinitionNode;
use Railt\SDL\Frontend\Ast\Definition\Type\EnumTypeDefinitionNode;
use Railt\SDL\Frontend\Ast\Definition\Type\InputObjectTypeDefinitionNode;
use Railt\SDL\Frontend\Ast\Definition\Type\InterfaceTypeDefinitionNode;
use Railt\SDL\Frontend\Ast\Definition\Type\ObjectTypeDefinitionNode;
use Railt\SDL\Frontend\Ast\Definition\Type\ScalarTypeDefinitionNode;
use Railt\SDL\Frontend\Ast\Definition\Type\UnionTypeDefinitionNode;
use Railt\SDL\Frontend\Ast\DefinitionNode;
use Railt\SDL\Frontend\Ast\Node;
use Railt\TypeSystem\Reference\TypeReference;
use Railt\TypeSystem\Reference\TypeReferenceInterface;

/**
 * Class Factory
 */
class Factory
{
    /**
     * @var string
     */
    private const ERROR_NON_GENERIC_TYPE_USAGE = 'Type %s can not be used as generic type %1$s<%s>';

    /**
     * @var string
     */
    private const ERROR_GENERIC_ARGUMENTS = 'Generic type %s<%s> requires %d type arguments, but %d passed';

    /**
     * @var Context
     */
    private Context $ctx;

    /**
     * @var NameResolverInterface
     */
    private NameResolverInterface $resolver;

    /**
     * @var HashTableInterface
     */
    private HashTableInterface $vars;

    /**
     * Factory constructor.
     *
     * @param HashTableInterface $vars
     * @param NameResolverInterface $resolver
     * @param Context $context
     */
    public function __construct(HashTableInterface $vars, NameResolverInterface $resolver, Context $context)
    {
        $this->vars = $vars;
        $this->ctx = $context;
        $this->resolver = $resolver;
    }

    /**
     * @param Node $from
     * @param string $name
     * @param array|string[] $args
     * @return TypeReferenceInterface
     * @throws NotAccessibleException
     * @throws TypeErrorException
     * @throws \RuntimeException
     */
    public function ref(Node $from, string $name, array $args = []): TypeReferenceInterface
    {
        if ($args !== []) {
            $name = $this->compileGenericType($from, $name, $args);
        } else {
            $this->assertMissingTypeArguments($from, $name, $args);
        }

        return new TypeReference($this->ctx->getSchema(), $name);
    }

    /**
     * @param Node $from
     * @param string $name
     * @param array $args
     * @return void
     * @throws NotAccessibleException
     * @throws TypeErrorException
     * @throws \RuntimeException
     */
    private function assertMissingTypeArguments(Node $from, string $name, array $args = []): void
    {
        $context = $this->ctx->fetch($name);

        if ($context === null) {
            return;
        }

        $needle = $context->getGenericArguments();

        if ($needle !== []) {
            $message = \vsprintf(self::ERROR_GENERIC_ARGUMENTS, [
                $name,
                \implode(', ', $needle),
                \count($needle),
                \count($args),
            ]);

            throw new TypeErrorException($message, $from);
        }
    }

    /**
     * @param Node $from
     * @param string $name
     * @param array|string[] $args
     * @return string
     * @throws NotAccessibleException
     * @throws TypeErrorException
     * @throws \RuntimeException
     */
    private function compileGenericType(Node $from, string $name, array $args): string
    {
        $generic = $this->resolver->resolve($name, $args);

        if (! $this->ctx->hasType($generic)) {
            $context = $this->getContext($from, $name, $args);

            $schema = $this->ctx->getSchema();

            $this->assertGenericArguments($from, $name, $context->getGenericArguments(), $args);

            $schema->addType($context->resolve($args)->withName($generic));
            $schema->addType($context->resolve($args)->/** @scrutinizer ignore-call */ withName($generic));
        }

        return $generic;
    }

    /**
     * @param Node $from
     * @param string $name
     * @param array|string[] $args
     * @return NamedDefinitionContextInterface
     * @throws NotAccessibleException
     * @throws TypeErrorException
     * @throws \RuntimeException
     */
    private function getContext(Node $from, string $name, array $args): NamedDefinitionContextInterface
    {
        $context = $this->ctx->fetch($name);

        if ($context === null) {
            $message = self::ERROR_NON_GENERIC_TYPE_USAGE;
            $message = \sprintf($message, $name, \implode(',', $args));

            throw new TypeErrorException($message, $from);
        }

        return $context;
    }

    /**
     * @param Node $from
     * @param string $name
     * @param array $definition
     * @param array $passed
     * @return void
     * @throws NotAccessibleException
     * @throws TypeErrorException
     * @throws \RuntimeException
     */
    private function assertGenericArguments(Node $from, string $name, array $definition, array $passed): void
    {
        [$definitions, $arguments] = [\count($definition), \count($passed)];

        if ($definitions !== $arguments) {
            $message = \vsprintf(self::ERROR_GENERIC_ARGUMENTS, [
                $name,
                \implode(', ', $definition),
                \count($definition),
                \count($passed),
            ]);

            throw new TypeErrorException($message, $from);
        }
    }

    /**
     * @param DefinitionNode $node
     * @return DefinitionContextInterface|NamedDefinitionContextInterface
     * @throws \LogicException
     */
    public function make(DefinitionNode $node): DefinitionContextInterface
    {
        switch (true) {
            case $node instanceof ObjectTypeDefinitionNode:
                return new ObjectTypeDefinitionContext($this->vars, $this, $node);
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

            case $node instanceof InterfaceTypeDefinitionNode:
                return new InterfaceTypeDefinitionContext($this->vars, $this, $node);

            case $node instanceof ScalarTypeDefinitionNode:
                return new ScalarTypeDefinitionContext($this->vars, $this, $node);

            case $node instanceof EnumTypeDefinitionNode:
            case $node instanceof InputObjectTypeDefinitionNode:
            case $node instanceof UnionTypeDefinitionNode:
            case $node instanceof SchemaDefinitionNode:
                throw new \LogicException($node->name->value . ' context not implemented yet');

                break;

            case $node instanceof DirectiveDefinitionNode:
                return new DirectiveDefinitionContext($this->vars, $this, $node);
        }

        throw new \LogicException(\get_class($node) . ' is an unresolvable');
    }
}

railt / sdl

Push — master ( 1595cb...050b68 )

Factory A

Complexity

Size/Duplication

Importance

7 Methods

Duplication Side-by-Side

Filter issues like
