EnumType::parseValue() - Code Metrics - Inspection of "Refactor type definitions" - digiaonline/graphql-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#132)

by Christoffer

created 2018-03-18 22:03 UTC

EnumType::parseValue() A

↳ Parent: EnumType

Complexity

Conditions	3
Paths	3

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	11
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	5
nc	3
nop	1

<?php

namespace Digia\GraphQL\Type\Definition;

use Digia\GraphQL\Config\ConfigObject;
use Digia\GraphQL\Error\InvariantException;
use Digia\GraphQL\Language\Node\EnumValueNode;
use Digia\GraphQL\Language\Node\NodeAwareInterface;
use Digia\GraphQL\Language\Node\NodeInterface;
use Digia\GraphQL\Language\Node\NodeTrait;
use Digia\GraphQL\Type\Coercer\CoercerInterface;
use function Digia\GraphQL\Type\isAssocArray;
use function Digia\GraphQL\Util\invariant;
use function Digia\GraphQL\Util\toString;

/**
 * Enum Type Definition
 *
 * Some leaf values of requests and input values are Enums. GraphQL serializes
 * Enum values as strings, however internally Enums can be represented by any
 * kind of type, often integers.
 *
 * Example:
 *
 *     $RGBType = new GraphQLEnumType([
 *       'name' => 'RGB',
 *       'values': [
 *         'RED'   => ['value' => 0],
 *         'GREEN' => ['value' => 1],
 *         'BLUE'  => ['value' => 2]
 *       ]
 *     ]);
 *
 * Note: If a value is not provided in a definition, the name of the enum value
 * will be used as its internal value.
 */
class EnumType extends ConfigObject implements TypeInterface, NamedTypeInterface, InputTypeInterface,
    LeafTypeInterface, OutputTypeInterface, NodeAwareInterface, CoercerInterface
{
    use NameTrait;
    use DescriptionTrait;
    use NodeTrait;

    /**
     * @var array
     */
    protected $valueMap;

    /**
     * @var EnumValue[]
     */
    protected $values;

    /**
     * @inheritdoc
     */
    protected function afterConfig(): void
    {
        invariant(null !== $this->getName(), 'Must provide name.');
    }

    /**
     * @param $value
     * @return null|string
     * @throws InvariantException
     */
    public function serialize($value)
    {
        $enumValue = $this->getValueByValue($value);

        if ($enumValue) {
            return $enumValue->getName();
        }

        return null;
    }

    /**
     * @param $value
     * @return mixed|null
     * @throws InvariantException
     */
    public function parseValue($value)
    {
        if (\is_string($value)) {
            $enumValue = $this->getValueByName($value);

            if ($enumValue !== null) {
                return $enumValue->getValue();
            }
        }

        return null;
    }

    /**
     * @param NodeInterface $node
     * @return mixed|null
     * @throws InvariantException
     */
    public function parseLiteral(NodeInterface $node)
    {
        if ($node instanceof EnumValueNode) {
            $enumValue = $this->getValueByName($node->getValue());

            if ($enumValue !== null) {
                return $enumValue->getValue();
            }
        }

        return null;
    }

    /**
     * @param string $name
     * @return EnumValue|null
     * @throws InvariantException
     */
    public function getValue(string $name): ?EnumValue
    {
        return $this->getValueByName($name);
    }

    /**
     * @return EnumValue[]
     * @throws InvariantException
     */
    public function getValues(): array
    {
        if (!isset($this->values)) {
            $this->values = $this->buildValues($this->valueMap ?? []);
        }
        return $this->values;
    }

    /**
     * @param array $valueMap
     * @return $this
     */
    protected function setValues(array $valueMap): EnumType
    {
        $this->valueMap = $valueMap;
        return $this;
    }

    /**
     * @param string $name
     * @return EnumValue|null
     * @throws InvariantException
     */
    protected function getValueByName(string $name): ?EnumValue
    {
        foreach ($this->getValues() as $enumValue) {
            if ($enumValue->getName() === $name) {
                return $enumValue;
            }
        }

        return null;
    }

    /**
     * @param mixed $value
     * @return EnumValue|null
     * @throws InvariantException
     */
    protected function getValueByValue($value): ?EnumValue
    {
        foreach ($this->getValues() as $enumValue) {
            if ($enumValue->getValue() === $value) {
                return $enumValue;
            }
        }

        return null;
    }

    /**
     * @param array $valueMap
     * @return array
     * @throws InvariantException
     */
    protected function buildValues(array $valueMap): array
    {
        invariant(
            isAssocArray($valueMap),
            \sprintf('%s values must be an associative array with value names as keys.', $this->getName())
        );

        $values = [];

        foreach ($valueMap as $valueName => $valueConfig) {
            invariant(
                isAssocArray($valueConfig),
                \sprintf(
                    '%s.%s must refer to an object with a "value" key representing an internal value but got: %s',
                    $this->getName(),
                    $valueName,
                    toString($valueConfig)
                )
            );

            invariant(
                !isset($valueConfig['isDeprecated']),
                \sprintf(
                    '%s.%s should provided "deprecationReason" instead of "isDeprecated".',
                    $this->getName(),
                    $valueName
                )
            );

            $values[] = new EnumValue(\array_merge($valueConfig, ['name' => $valueName]));
        }

        return $values;
    }
}


1			<?php
2
3			namespace Digia\GraphQL\Type\Definition;
4
5			use Digia\GraphQL\Config\ConfigObject;
6			use Digia\GraphQL\Error\InvariantException;
7			use Digia\GraphQL\Language\Node\EnumValueNode;
8			use Digia\GraphQL\Language\Node\NodeAwareInterface;
9			use Digia\GraphQL\Language\Node\NodeInterface;
10			use Digia\GraphQL\Language\Node\NodeTrait;
11			use Digia\GraphQL\Type\Coercer\CoercerInterface;
12			use function Digia\GraphQL\Type\isAssocArray;
13			use function Digia\GraphQL\Util\invariant;
14			use function Digia\GraphQL\Util\toString;
15
16			/**
17			* Enum Type Definition
18			*
19			* Some leaf values of requests and input values are Enums. GraphQL serializes
20			* Enum values as strings, however internally Enums can be represented by any
21			* kind of type, often integers.
22			*
23			* Example:
24			*
25			* $RGBType = new GraphQLEnumType([
26			* 'name' => 'RGB',
27			* 'values': [
28			* 'RED' => ['value' => 0],
29			* 'GREEN' => ['value' => 1],
30			* 'BLUE' => ['value' => 2]
31			* ]
32			* ]);
33			*
34			* Note: If a value is not provided in a definition, the name of the enum value
35			* will be used as its internal value.
36			*/
37			class EnumType extends ConfigObject implements TypeInterface, NamedTypeInterface, InputTypeInterface,
38			LeafTypeInterface, OutputTypeInterface, NodeAwareInterface, CoercerInterface
39			{
40			use NameTrait;
41			use DescriptionTrait;
42			use NodeTrait;
43
44			/**
45			* @var array
46			*/
47			protected $valueMap;
48
49			/**
50			* @var EnumValue[]
51			*/
52			protected $values;
53
54			/**
55			* @inheritdoc
56			*/
57			protected function afterConfig(): void
58			{
59			invariant(null !== $this->getName(), 'Must provide name.');
60			}
61
62			/**
63			* @param $value
64			* @return null\|string
65			* @throws InvariantException
66			*/
67			public function serialize($value)
68			{
69			$enumValue = $this->getValueByValue($value);
70
71			if ($enumValue) {
72			return $enumValue->getName();
73			}
74
75			return null;
76			}
77
78			/**
79			* @param $value
80			* @return mixed\|null
81			* @throws InvariantException
82			*/
83			public function parseValue($value)
84			{
85			if (\is_string($value)) {
86			$enumValue = $this->getValueByName($value);
87
88			if ($enumValue !== null) {
89			return $enumValue->getValue();
90			}
91			}
92
93			return null;
94			}
95
96			/**
97			* @param NodeInterface $node
98			* @return mixed\|null
99			* @throws InvariantException
100			*/
101			public function parseLiteral(NodeInterface $node)
102			{
103			if ($node instanceof EnumValueNode) {
104			$enumValue = $this->getValueByName($node->getValue());
105
106			if ($enumValue !== null) {
107			return $enumValue->getValue();
108			}
109			}
110
111			return null;
112			}
113
114			/**
115			* @param string $name
116			* @return EnumValue\|null
117			* @throws InvariantException
118			*/
119			public function getValue(string $name): ?EnumValue
120			{
121			return $this->getValueByName($name);
122			}
123
124			/**
125			* @return EnumValue[]
126			* @throws InvariantException
127			*/
128			public function getValues(): array
129			{
130			if (!isset($this->values)) {
131			$this->values = $this->buildValues($this->valueMap ?? []);
132			}
133			return $this->values;
134			}
135
136			/**
137			* @param array $valueMap
138			* @return $this
139			*/
140			protected function setValues(array $valueMap): EnumType
141			{
142			$this->valueMap = $valueMap;
143			return $this;
144			}
145
146			/**
147			* @param string $name
148			* @return EnumValue\|null
149			* @throws InvariantException
150			*/
151			protected function getValueByName(string $name): ?EnumValue
152			{
153			foreach ($this->getValues() as $enumValue) {
154			if ($enumValue->getName() === $name) {
155			return $enumValue;
156			}
157			}
158
159			return null;
160			}
161
162			/**
163			* @param mixed $value
164			* @return EnumValue\|null
165			* @throws InvariantException
166			*/
167			protected function getValueByValue($value): ?EnumValue
168			{
169			foreach ($this->getValues() as $enumValue) {
170			if ($enumValue->getValue() === $value) {
171			return $enumValue;
172			}
173			}
174
175			return null;
176			}
177
178			/**
179			* @param array $valueMap
180			* @return array
181			* @throws InvariantException
182			*/
183			protected function buildValues(array $valueMap): array
184			{
185			invariant(
186			isAssocArray($valueMap),
187			\sprintf('%s values must be an associative array with value names as keys.', $this->getName())
188			);
189
190			$values = [];
191
192			foreach ($valueMap as $valueName => $valueConfig) {
193			invariant(
194			isAssocArray($valueConfig),
195			\sprintf(
196			'%s.%s must refer to an object with a "value" key representing an internal value but got: %s',
197			$this->getName(),
198			$valueName,
199			toString($valueConfig)
200			)
201			);
202
203			invariant(
204			!isset($valueConfig['isDeprecated']),
205			\sprintf(
206			'%s.%s should provided "deprecationReason" instead of "isDeprecated".',
207			$this->getName(),
208			$valueName
209			)
210			);
211
212			$values[] = new EnumValue(\array_merge($valueConfig, ['name' => $valueName]));
213			}
214
215			return $values;
216			}
217			}
218

digiaonline / graphql-php

Pull Request — master (#132)

EnumType::parseValue() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like