ValueASTConverter::convertEnumType() - Code Metrics - Inspection of "WIP: Definition printer" - digiaonline/graphql-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#209)

by Christoffer
created 2018-04-17 06:53 UTC
ValueASTConverter::convertEnumType() A

↳ Parent: ValueASTConverter
Complexity

Conditions	3
Paths	3
Size

Total Lines	15
Code Lines	7
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	3
eloc	7
nc	3
nop	2
dl	0
loc	15
rs	9.4285
c	0
b	0
f	0
<?php

namespace Digia\GraphQL\Util;

use Digia\GraphQL\Error\InvalidTypeException;
use Digia\GraphQL\Error\InvariantException;
use Digia\GraphQL\Error\ConversionException;
use Digia\GraphQL\Language\Node\EnumValueNode;
use Digia\GraphQL\Language\Node\ListValueNode;
use Digia\GraphQL\Language\Node\NodeInterface;
use Digia\GraphQL\Language\Node\NullValueNode;
use Digia\GraphQL\Language\Node\ObjectFieldNode;
use Digia\GraphQL\Language\Node\ObjectValueNode;
use Digia\GraphQL\Language\Node\ValueNodeInterface;
use Digia\GraphQL\Language\Node\VariableNode;
use Digia\GraphQL\Type\Definition\EnumType;
use Digia\GraphQL\Type\Definition\InputObjectType;
use Digia\GraphQL\Type\Definition\ListType;
use Digia\GraphQL\Type\Definition\NonNullType;
use Digia\GraphQL\Type\Definition\ScalarType;
use Digia\GraphQL\Type\Definition\TypeInterface;

class ValueASTConverter
{
    /**
     * Produces a PHP value given a GraphQL Value AST.
     *
     * A GraphQL type must be provided, which will be used to interpret different
     * GraphQL Value literals.
     *
     * Throws a `ConversionException` when the value could not be validly converted according to
     * the provided type.
     *
     * | GraphQL Value        | JSON Value    |
     * | -------------------- | ------------- |
     * | Input Object         | Object        |
     * | List                 | Array         |
     * | Boolean              | Boolean       |
     * | String               | String        |
     * | Int / Float          | Number        |
     * | Enum Value           | Mixed         |
     * | NullValue            | null          |
     *
     * @param NodeInterface|ValueNodeInterface|null $node
     * @param TypeInterface                         $type
     * @param array                                 $variables
     * @return mixed|null
     * @throws InvalidTypeException
     * @throws InvariantException
     * @throws ConversionException
     */
    public function convert(?NodeInterface $node, TypeInterface $type, array $variables = [])
    {
        if (null === $node) {
            throw new ConversionException('Node is not defined.');
        }

        if ($type instanceof NonNullType) {
            return $this->convertNonNullType($node, $type, $variables);
        }

        if ($node instanceof NullValueNode) {
            return null;
        }

        if ($node instanceof VariableNode) {
            return $this->convertVariable($node, $variables);
        }

        if ($type instanceof ListType) {
            return $this->convertListType($node, $type, $variables);
        }

        if ($type instanceof InputObjectType) {
            return $this->convertInputObjectType($node, $type, $variables);
        }

        if ($type instanceof EnumType) {
            return $this->convertEnumType($node, $type);
        }

        if ($type instanceof ScalarType) {
            return $this->convertScalarType($node, $type, $variables);
        }

        throw new InvalidTypeException(\sprintf('Unknown type: %s', $type));
        throw new InvalidTypeException(\sprintf('Unknown type: %s', /** @scrutinizer ignore-type */ $type));
    }

    /**
     * @param NodeInterface|ValueNodeInterface $node
     * @param NonNullType                      $type
     * @param array                            $variables
     * @return mixed|null
     * @throws InvalidTypeException
     * @throws InvariantException
     * @throws ConversionException
     */
    protected function convertNonNullType(NodeInterface $node, NonNullType $type, array $variables)
    {
        if ($node instanceof NullValueNode) {
            throw new ConversionException('Cannot convert non-null values from null value node.');
        }

        return $this->convert($node, $type->getOfType(), $variables);
    }

    /**
     * @param VariableNode $node
     * @param array        $variables
     * @return mixed
     * @throws ConversionException
     */
    protected function convertVariable(VariableNode $node, array $variables)
    {
        $variableName = $node->getNameValue();

        if (!isset($variables[$variableName])) {
            throw new ConversionException(
                \sprintf('Cannot convert value for missing variable "%s".', $variableName)
            );
        }

        // Note: we're not doing any checking that this variable is correct. We're
        // assuming that this query has been validated and the variable usage here
        // is of the correct type.
        return $variables[$variableName];
    }

    /**
     * @param NodeInterface|ValueNodeInterface $node
     * @param ListType                         $type
     * @return array|null
     * @throws InvalidTypeException
     * @throws InvariantException
     * @throws ConversionException
     */
    protected function convertListType(NodeInterface $node, ListType $type, array $variables): ?array
    {
        $itemType = $type->getOfType();

        if ($node instanceof ListValueNode) {
            $values = [];

            foreach ($node->getValues() as $value) {
                if ($this->isMissingVariable($value, $variables)) {
                    if ($itemType instanceof NonNullType) {
                        // If an array contains a missing variable, it is either converted to
                        // null or if the item type is non-null, it considered invalid.
                        throw new ConversionException('Cannot convert value for missing non-null list item.');
                    }

                    $values[] = null;
                } else {
                    $values[] = $this->convert($value, $itemType, $variables);
                }
            }

            return $values;
        }

        return [$this->convert($node, $itemType, $variables)];
    }

    /**
     * @param NodeInterface|ValueNodeInterface $node
     * @param InputObjectType                  $type
     * @param array                            $variables
     * @return array|null
     * @throws InvalidTypeException
     * @throws InvariantException
     * @throws ConversionException
     */
    protected function convertInputObjectType(NodeInterface $node, InputObjectType $type, array $variables): ?array
    {
        if (!$node instanceof ObjectValueNode) {
            throw new ConversionException('Input object values can only be converted form object value nodes.');
        }

        $values = [];

        /** @var ObjectFieldNode[] $fieldNodes */
        $fieldNodes = keyMap($node->getFields(), function (ObjectFieldNode $value) {
            return $value->getNameValue();
        });

        foreach ($type->getFields() as $field) {
            $name      = $field->getName();
            $fieldNode = $fieldNodes[$name] ?? null;

            if (null === $fieldNode || $this->isMissingVariable($fieldNode->getValue(), $variables)) {
                if (null !== $field->getDefaultValue()) {
                    $values[$name] = $field->getDefaultValue();
                } elseif ($field->getType() instanceof NonNullType) {
                    throw new ConversionException('Cannot convert input object value for missing non-null field.');
                }
                continue;
            }

            $fieldValue = $this->convert($fieldNode->getValue(), $field->getType(), $variables);

            $values[$name] = $fieldValue;
        }

        return $values;
    }

    /**
     * @param NodeInterface|ValueNodeInterface $node
     * @param EnumType                         $type
     * @return mixed|null
     * @throws InvariantException
     * @throws ConversionException
     */
    protected function convertEnumType(NodeInterface $node, EnumType $type)
    {
        if (!$node instanceof EnumValueNode) {
            throw new ConversionException('Enum values can only be converted from enum value nodes.');
        }

        $name = $node->getValue();

        $enumValue = $type->getValue($name);

        if (null === $enumValue) {
            throw new ConversionException(\sprintf('Cannot convert enum value for missing value "%s".', $name));
        }

        return $enumValue->getValue();
    }

    /**
     * @param NodeInterface|ValueNodeInterface $node
     * @param ScalarType                       $type
     * @param array                            $variables
     * @return mixed|null
     * @throws ConversionException
     */
    protected function convertScalarType(NodeInterface $node, ScalarType $type, array $variables)
    {
        // Scalars fulfill parsing a literal value via parseLiteral().
        // Invalid values represent a failure to parse correctly, in which case
        // no value is returned.
        $result = null;


        try {
            $result = $type->parseLiteral($node, $variables);
        } catch (\Exception $e) {


        }

        if (null === $result) {
            throw new ConversionException(\sprintf('Failed to parse literal for scalar type "%s".', (string)$type));
        }

        return $result;
    }

    /**
     * @param ValueNodeInterface $node
     * @param array              $variables
     * @return bool
     */
    protected function isMissingVariable(ValueNodeInterface $node, array $variables): bool
    {
        return $node instanceof VariableNode && !isset($variables[$node->getNameValue()]);
    }
}

digiaonline / graphql-php

Pull Request — master (#209)

ValueASTConverter::convertEnumType() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
