GraphQL::parseValue() - Code Metrics - Inspection of "Refactor public API (#155)" - digiaonline/graphql-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( a4db6d...341e25 )

by Christoffer

created 2018-03-29 10:19 UTC

GraphQL::parseValue() A

↳ Parent: GraphQL

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	2

<?php

namespace Digia\GraphQL;

use Digia\GraphQL\Cache\CacheProvider;
use Digia\GraphQL\Error\InvariantException;
use Digia\GraphQL\Execution\ExecutionInterface;
use Digia\GraphQL\Execution\ExecutionProvider;
use Digia\GraphQL\Execution\ExecutionResult;
use Digia\GraphQL\Language\LanguageProvider;
use Digia\GraphQL\Language\LexerInterface;
use Digia\GraphQL\Language\Node\DocumentNode;
use Digia\GraphQL\Language\Node\NodeInterface;
use Digia\GraphQL\Language\Node\TypeNodeInterface;
use Digia\GraphQL\Language\Node\ValueNodeInterface;
use Digia\GraphQL\Language\ParserInterface;
use Digia\GraphQL\Language\PrinterInterface;
use Digia\GraphQL\Language\Source;
use Digia\GraphQL\SchemaBuilder\SchemaBuilderInterface;
use Digia\GraphQL\SchemaBuilder\SchemaBuilderProvider;
use Digia\GraphQL\SchemaValidator\SchemaValidatorInterface;
use Digia\GraphQL\SchemaValidator\SchemaValidatorProvider;
use Digia\GraphQL\Type\CoercerProvider;
use Digia\GraphQL\Type\DirectivesProvider;
use Digia\GraphQL\Type\IntrospectionProvider;
use Digia\GraphQL\Type\ScalarTypesProvider;
use Digia\GraphQL\Type\SchemaInterface;
use Digia\GraphQL\Util\UtilityProvider;
use Digia\GraphQL\Validation\RulesProvider;
use Digia\GraphQL\Validation\ValidationProvider;
use Digia\GraphQL\Validation\ValidatorInterface;
use League\Container\Container;
use League\Container\ContainerInterface;

class GraphQL
{

    public const BOOLEAN = 'GraphQLBoolean';
    public const FLOAT   = 'GraphQLFloat';
    public const INT     = 'GraphQLInt';
    public const ID      = 'GraphQLID';
    public const STRING  = 'GraphQLString';

    public const DEPRECATED_DIRECTIVE = 'GraphQLDeprecatedDirective';
    public const INCLUDE_DIRECTIVE    = 'GraphQLIncludeDirective';
    public const SKIP_DIRECTIVE       = 'GraphQLSkipDirective';

    public const SCHEMA_INTROSPECTION             = '__Schema';
    public const DIRECTIVE_INTROSPECTION          = '__Directive';
    public const DIRECTIVE_LOCATION_INTROSPECTION = '__DirectiveLocation';
    public const TYPE_INTROSPECTION               = '__Type';
    public const FIELD_INTROSPECTION              = '__Field';
    public const INPUT_VALUE_INTROSPECTION        = '__InputValue';
    public const ENUM_VALUE_INTROSPECTION         = '__EnumValue';
    public const TYPE_KIND_INTROSPECTION          = '__TypeKind';

    public const SCHEMA_META_FIELD_DEFINITION    = 'SchemaMetaFieldDefinition';
    public const TYPE_META_FIELD_DEFINITION      = 'TypeMetaFieldDefinition';
    public const TYPE_NAME_META_FIELD_DEFINITION = 'TypeNameMetaFieldDefinition';

    /**
     * @var array
     */
    private static $providers = [
        CacheProvider::class,
        LanguageProvider::class,
        SchemaBuilderProvider::class,
        SchemaValidatorProvider::class,
        CoercerProvider::class,
        IntrospectionProvider::class,
        ScalarTypesProvider::class,
        DirectivesProvider::class,
        RulesProvider::class,
        ValidationProvider::class,
        ExecutionProvider::class,
        UtilityProvider::class,
    ];

    /**
     * @var GraphQL
     */
    private static $instance;

    /**
     * @var Container
     */
    protected $container;

    /**
     * GraphQL constructor.
     */
    private function __construct()
    {
        $container = new Container();

        $this->registerProviders($container);

        $this->container = $container;
    }

    /**
     * @return GraphQL
     */
    public static function getInstance(): self
    {
        if (null === static::$instance) {

            static::$instance = new static();
        }

        return static::$instance;
    }

    /**
     * @param string $id
     * @param array  $args
     * @return mixed
     */
    public static function make(string $id, array $args = [])
    {
        return static::getInstance()
            ->getContainer()
            ->get($id, $args);
    }

    /**
     * @param string|Source $source
     * @param array         $resolverMaps
     * @param array         $options
     * @return SchemaInterface
     * @throws InvariantException
     */
    public static function buildSchema($source, array $resolverMaps = [], array $options = []): SchemaInterface
    {
        return static::make(SchemaBuilderInterface::class)
            ->build(
                static::parse($source, $options),
                $resolverMaps,
                $options
            );
    }

    /**
     * @param SchemaInterface $schema
     * @return array
     */
    public static function validateSchema(SchemaInterface $schema): array
    {
        return static::make(SchemaValidatorInterface::class)
            ->validate($schema);
    }

    /**
     * @param string|Source $source
     * @param array         $options
     * @return DocumentNode
     * @throws InvariantException
     */
    public static function parse($source, array $options = []): DocumentNode
    {
        return static::make(ParserInterface::class)
            ->parse(static::lex($source, $options));
    }

    /**
     * @param string|Source $source
     * @param array         $options
     * @return ValueNodeInterface
     * @throws InvariantException
     */
    public static function parseValue($source, array $options = []): ValueNodeInterface
    {
        return static::make(ParserInterface::class)
            ->parseValue(static::lex($source, $options));
    }

    /**
     * @param string|Source $source
     * @param array         $options
     * @return TypeNodeInterface
     * @throws InvariantException
     */
    public static function parseType($source, array $options = []): TypeNodeInterface
    {
        return static::make(ParserInterface::class)
            ->parseType(static::lex($source, $options));
    }

    /**
     * @param SchemaInterface $schema
     * @param DocumentNode    $document
     * @return array
     */
    public static function validate(SchemaInterface $schema, DocumentNode $document): array
    {
        return static::make(ValidatorInterface::class)
            ->validate($schema, $document);
    }

    /**
     * @param SchemaInterface $schema
     * @param DocumentNode    $document
     * @param null            $rootValue

     * @param null            $contextValue
     * @param array           $variableValues
     * @param null            $operationName
     * @param callable|null   $fieldResolver
     * @return ExecutionResult
     */
    public static function execute(
        SchemaInterface $schema,
        DocumentNode $document,
        $rootValue = null,
        $contextValue = null,
        array $variableValues = [],
        $operationName = null,
        callable $fieldResolver = null
    ): ExecutionResult {
        return static::make(ExecutionInterface::class)
            ->execute(
                $schema,
                $document,
                $rootValue,
                $contextValue,
                $variableValues,
                $operationName,
                $fieldResolver
            );
    }

    /**
     * @param NodeInterface $node
     * @return string
     */
    public static function print(NodeInterface $node): string
    {
        return static::make(PrinterInterface::class)->print($node);
    }

    /**
     * @param string|Source $source
     * @param array         $options
     * @return LexerInterface
     * @throws InvariantException
     */
    public static function lex($source, array $options = []): LexerInterface
    {
        return static::make(LexerInterface::class)
            ->setSource($source instanceof Source ? $source : new Source($source))
            ->setOptions($options);
    }

    /**
     * @return Container
     */
    public function getContainer(): Container
    {
        return $this->container;
    }

    /**
     * Registers the service provides with the container.
     */
    protected function registerProviders(ContainerInterface $container): void
    {
        foreach (static::$providers as $className) {

            $container->addServiceProvider($className);
        }
    }
}


1			<?php
2
3			namespace Digia\GraphQL;
4
5			use Digia\GraphQL\Cache\CacheProvider;
6			use Digia\GraphQL\Error\InvariantException;
7			use Digia\GraphQL\Execution\ExecutionInterface;
8			use Digia\GraphQL\Execution\ExecutionProvider;
9			use Digia\GraphQL\Execution\ExecutionResult;
10			use Digia\GraphQL\Language\LanguageProvider;
11			use Digia\GraphQL\Language\LexerInterface;
12			use Digia\GraphQL\Language\Node\DocumentNode;
13			use Digia\GraphQL\Language\Node\NodeInterface;
14			use Digia\GraphQL\Language\Node\TypeNodeInterface;
15			use Digia\GraphQL\Language\Node\ValueNodeInterface;
16			use Digia\GraphQL\Language\ParserInterface;
17			use Digia\GraphQL\Language\PrinterInterface;
18			use Digia\GraphQL\Language\Source;
19			use Digia\GraphQL\SchemaBuilder\SchemaBuilderInterface;
20			use Digia\GraphQL\SchemaBuilder\SchemaBuilderProvider;
21			use Digia\GraphQL\SchemaValidator\SchemaValidatorInterface;
22			use Digia\GraphQL\SchemaValidator\SchemaValidatorProvider;
23			use Digia\GraphQL\Type\CoercerProvider;
24			use Digia\GraphQL\Type\DirectivesProvider;
25			use Digia\GraphQL\Type\IntrospectionProvider;
26			use Digia\GraphQL\Type\ScalarTypesProvider;
27			use Digia\GraphQL\Type\SchemaInterface;
28			use Digia\GraphQL\Util\UtilityProvider;
29			use Digia\GraphQL\Validation\RulesProvider;
30			use Digia\GraphQL\Validation\ValidationProvider;
31			use Digia\GraphQL\Validation\ValidatorInterface;
32			use League\Container\Container;
33			use League\Container\ContainerInterface;
34
35			class GraphQL
36			{
37
38			public const BOOLEAN = 'GraphQLBoolean';
39			public const FLOAT = 'GraphQLFloat';
40			public const INT = 'GraphQLInt';
41			public const ID = 'GraphQLID';
42			public const STRING = 'GraphQLString';
43
44			public const DEPRECATED_DIRECTIVE = 'GraphQLDeprecatedDirective';
45			public const INCLUDE_DIRECTIVE = 'GraphQLIncludeDirective';
46			public const SKIP_DIRECTIVE = 'GraphQLSkipDirective';
47
48			public const SCHEMA_INTROSPECTION = '__Schema';
49			public const DIRECTIVE_INTROSPECTION = '__Directive';
50			public const DIRECTIVE_LOCATION_INTROSPECTION = '__DirectiveLocation';
51			public const TYPE_INTROSPECTION = '__Type';
52			public const FIELD_INTROSPECTION = '__Field';
53			public const INPUT_VALUE_INTROSPECTION = '__InputValue';
54			public const ENUM_VALUE_INTROSPECTION = '__EnumValue';
55			public const TYPE_KIND_INTROSPECTION = '__TypeKind';
56
57			public const SCHEMA_META_FIELD_DEFINITION = 'SchemaMetaFieldDefinition';
58			public const TYPE_META_FIELD_DEFINITION = 'TypeMetaFieldDefinition';
59			public const TYPE_NAME_META_FIELD_DEFINITION = 'TypeNameMetaFieldDefinition';
60
61			/**
62			* @var array
63			*/
64			private static $providers = [
65			CacheProvider::class,
66			LanguageProvider::class,
67			SchemaBuilderProvider::class,
68			SchemaValidatorProvider::class,
69			CoercerProvider::class,
70			IntrospectionProvider::class,
71			ScalarTypesProvider::class,
72			DirectivesProvider::class,
73			RulesProvider::class,
74			ValidationProvider::class,
75			ExecutionProvider::class,
76			UtilityProvider::class,
77			];
78
79			/**
80			* @var GraphQL
81			*/
82			private static $instance;
83
84			/**
85			* @var Container
86			*/
87			protected $container;
88
89			/**
90			* GraphQL constructor.
91			*/
92			private function __construct()
93			{
94			$container = new Container();
95
96			$this->registerProviders($container);
97
98			$this->container = $container;
99			}
100
101			/**
102			* @return GraphQL
103			*/
104			public static function getInstance(): self
105			{
106			if (null === static::$instance) {
			0 ignored issues – show Bug introduced 2018-03-25 09:11 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; you can either use `self`, or increase the visibility of `$instance` to at least protected. Loading history...
107			static::$instance = new static();
108			}
109
110			return static::$instance;
111			}
112
113			/**
114			* @param string $id
115			* @param array $args
116			* @return mixed
117			*/
118			public static function make(string $id, array $args = [])
119			{
120			return static::getInstance()
121			->getContainer()
122			->get($id, $args);
123			}
124
125			/**
126			* @param string\|Source $source
127			* @param array $resolverMaps
128			* @param array $options
129			* @return SchemaInterface
130			* @throws InvariantException
131			*/
132			public static function buildSchema($source, array $resolverMaps = [], array $options = []): SchemaInterface
133			{
134			return static::make(SchemaBuilderInterface::class)
135			->build(
136			static::parse($source, $options),
137			$resolverMaps,
138			$options
139			);
140			}
141
142			/**
143			* @param SchemaInterface $schema
144			* @return array
145			*/
146			public static function validateSchema(SchemaInterface $schema): array
147			{
148			return static::make(SchemaValidatorInterface::class)
149			->validate($schema);
150			}
151
152			/**
153			* @param string\|Source $source
154			* @param array $options
155			* @return DocumentNode
156			* @throws InvariantException
157			*/
158			public static function parse($source, array $options = []): DocumentNode
159			{
160			return static::make(ParserInterface::class)
161			->parse(static::lex($source, $options));
162			}
163
164			/**
165			* @param string\|Source $source
166			* @param array $options
167			* @return ValueNodeInterface
168			* @throws InvariantException
169			*/
170			public static function parseValue($source, array $options = []): ValueNodeInterface
171			{
172			return static::make(ParserInterface::class)
173			->parseValue(static::lex($source, $options));
174			}
175
176			/**
177			* @param string\|Source $source
178			* @param array $options
179			* @return TypeNodeInterface
180			* @throws InvariantException
181			*/
182			public static function parseType($source, array $options = []): TypeNodeInterface
183			{
184			return static::make(ParserInterface::class)
185			->parseType(static::lex($source, $options));
186			}
187
188			/**
189			* @param SchemaInterface $schema
190			* @param DocumentNode $document
191			* @return array
192			*/
193			public static function validate(SchemaInterface $schema, DocumentNode $document): array
194			{
195			return static::make(ValidatorInterface::class)
196			->validate($schema, $document);
197			}
198
199			/**
200			* @param SchemaInterface $schema
201			* @param DocumentNode $document
202			* @param null $rootValue
			0 ignored issues – show Documentation Bug introduced 2018-02-26 13:59 UTC by Report Bug Copy Issue Report Are you sure the doc-type for parameter `$operationName` is correct as it would always require `null` to be passed? Loading history... Documentation Bug introduced 2018-02-26 13:59 UTC by Report Bug Copy Issue Report Are you sure the doc-type for parameter `$rootValue` is correct as it would always require `null` to be passed? Loading history... Documentation Bug introduced 2018-02-26 13:59 UTC by Report Bug Copy Issue Report Are you sure the doc-type for parameter `$contextValue` is correct as it would always require `null` to be passed? Loading history...
203			* @param null $contextValue
204			* @param array $variableValues
205			* @param null $operationName
206			* @param callable\|null $fieldResolver
207			* @return ExecutionResult
208			*/
209			public static function execute(
210			SchemaInterface $schema,
211			DocumentNode $document,
212			$rootValue = null,
213			$contextValue = null,
214			array $variableValues = [],
215			$operationName = null,
216			callable $fieldResolver = null
217			): ExecutionResult {
218			return static::make(ExecutionInterface::class)
219			->execute(
220			$schema,
221			$document,
222			$rootValue,
223			$contextValue,
224			$variableValues,
225			$operationName,
226			$fieldResolver
227			);
228			}
229
230			/**
231			* @param NodeInterface $node
232			* @return string
233			*/
234			public static function print(NodeInterface $node): string
235			{
236			return static::make(PrinterInterface::class)->print($node);
237			}
238
239			/**
240			* @param string\|Source $source
241			* @param array $options
242			* @return LexerInterface
243			* @throws InvariantException
244			*/
245			public static function lex($source, array $options = []): LexerInterface
246			{
247			return static::make(LexerInterface::class)
248			->setSource($source instanceof Source ? $source : new Source($source))
249			->setOptions($options);
250			}
251
252			/**
253			* @return Container
254			*/
255			public function getContainer(): Container
256			{
257			return $this->container;
258			}
259
260			/**
261			* Registers the service provides with the container.
262			*/
263			protected function registerProviders(ContainerInterface $container): void
264			{
265			foreach (static::$providers as $className) {
			0 ignored issues – show Bug introduced 2018-03-25 09:11 UTC by Report Bug Copy Issue Report Since `$providers` is declared private, accessing it with `static` will lead to errors in possible sub-classes; you can either use `self`, or increase the visibility of `$providers` to at least protected. Loading history...
266			$container->addServiceProvider($className);
267			}
268			}
269			}
270

digiaonline / graphql-php

Push — master ( a4db6d...341e25 )

GraphQL::parseValue() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like