CompositeTypeMapper::mapNameToType() - Code Metrics - Inspection of "Adding a type loader" - thecodingmachine/graphql-controllers - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#60)

by David

created 2018-12-11 18:02 UTC

CompositeTypeMapper::mapNameToType() A

↳ Parent: CompositeTypeMapper

Complexity

Conditions	1
Paths	1

Size

Total Lines	2
Code Lines	0

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php


namespace TheCodingMachine\GraphQL\Controllers\Mappers;


use function array_map;
use function array_merge;
use function array_unique;
use GraphQL\Type\Definition\InputType;
use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\OutputType;
use GraphQL\Type\Definition\Type;
use function is_array;
use function iterator_to_array;

class CompositeTypeMapper implements TypeMapperInterface
{
    /**
     * @var TypeMapperInterface[]
     */
    private $typeMappers;

    /**
     * The cache of supported classes.
     *
     * @var string[]
     */
    private $supportedClasses;

    /**
     * @param TypeMapperInterface[] $typeMappers
     */
    public function __construct(iterable $typeMappers)
    {
        $this->typeMappers = is_array($typeMappers) ? $typeMappers: iterator_to_array($typeMappers);
    }

    /**
     * Returns true if this type mapper can map the $className FQCN to a GraphQL type.
     *
     * @param string $className
     * @return bool
     */
    public function canMapClassToType(string $className): bool
    {
        foreach ($this->typeMappers as $typeMapper) {
            if ($typeMapper->canMapClassToType($className)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Maps a PHP fully qualified class name to a GraphQL type.
     *
     * @param string $className
     * @param RecursiveTypeMapperInterface $recursiveTypeMapper
     * @return ObjectType
     * @throws CannotMapTypeException
     */
    public function mapClassToType(string $className, RecursiveTypeMapperInterface $recursiveTypeMapper): ObjectType
    {
        foreach ($this->typeMappers as $typeMapper) {
            if ($typeMapper->canMapClassToType($className)) {
                return $typeMapper->mapClassToType($className, $recursiveTypeMapper);
            }
        }
        throw CannotMapTypeException::createForType($className);
    }

    /**
     * Returns the list of classes that have matching input GraphQL types.
     *
     * @return string[]
     */
    public function getSupportedClasses(): array
    {
        if ($this->supportedClasses === null) {
            $supportedClassesArrays = array_map(function(TypeMapperInterface $typeMapper) { return $typeMapper->getSupportedClasses(); }, $this->typeMappers);
            $this->supportedClasses = array_unique(array_merge(...$supportedClassesArrays));
        }
        return $this->supportedClasses;
    }

    /**
     * Returns true if this type mapper can map the $className FQCN to a GraphQL input type.
     *
     * @param string $className
     * @return bool
     */
    public function canMapClassToInputType(string $className): bool
    {
        foreach ($this->typeMappers as $typeMapper) {
            if ($typeMapper->canMapClassToInputType($className)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Maps a PHP fully qualified class name to a GraphQL input type.
     *
     * @param string $className
     * @return InputType
     * @throws CannotMapTypeException
     */
    public function mapClassToInputType(string $className): InputType
    {
        foreach ($this->typeMappers as $typeMapper) {
            if ($typeMapper->canMapClassToInputType($className)) {
                return $typeMapper->mapClassToInputType($className);
            }
        }
        throw CannotMapTypeException::createForInputType($className);
    }

    /**
     * Returns a GraphQL type by name (can be either an input or output type)
     *
     * @param string $typeName The name of the GraphQL type
     * @param RecursiveTypeMapperInterface $recursiveTypeMapper
     * @return Type&(InputType|OutputType)
     */
    public function mapNameToType(string $typeName, RecursiveTypeMapperInterface $recursiveTypeMapper): Type
    {
        // TODO: Implement mapNameToType() method.
    }
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
}


1			<?php
2
3
4			namespace TheCodingMachine\GraphQL\Controllers\Mappers;
5
6
7			use function array_map;
8			use function array_merge;
9			use function array_unique;
10			use GraphQL\Type\Definition\InputType;
11			use GraphQL\Type\Definition\ObjectType;
12			use GraphQL\Type\Definition\OutputType;
13			use GraphQL\Type\Definition\Type;
14			use function is_array;
15			use function iterator_to_array;
16
17			class CompositeTypeMapper implements TypeMapperInterface
18			{
19			/**
20			* @var TypeMapperInterface[]
21			*/
22			private $typeMappers;
23
24			/**
25			* The cache of supported classes.
26			*
27			* @var string[]
28			*/
29			private $supportedClasses;
30
31			/**
32			* @param TypeMapperInterface[] $typeMappers
33			*/
34			public function __construct(iterable $typeMappers)
35			{
36			$this->typeMappers = is_array($typeMappers) ? $typeMappers: iterator_to_array($typeMappers);
37			}
38
39			/**
40			* Returns true if this type mapper can map the $className FQCN to a GraphQL type.
41			*
42			* @param string $className
43			* @return bool
44			*/
45			public function canMapClassToType(string $className): bool
46			{
47			foreach ($this->typeMappers as $typeMapper) {
48			if ($typeMapper->canMapClassToType($className)) {
49			return true;
50			}
51			}
52			return false;
53			}
54
55			/**
56			* Maps a PHP fully qualified class name to a GraphQL type.
57			*
58			* @param string $className
59			* @param RecursiveTypeMapperInterface $recursiveTypeMapper
60			* @return ObjectType
61			* @throws CannotMapTypeException
62			*/
63			public function mapClassToType(string $className, RecursiveTypeMapperInterface $recursiveTypeMapper): ObjectType
64			{
65			foreach ($this->typeMappers as $typeMapper) {
66			if ($typeMapper->canMapClassToType($className)) {
67			return $typeMapper->mapClassToType($className, $recursiveTypeMapper);
68			}
69			}
70			throw CannotMapTypeException::createForType($className);
71			}
72
73			/**
74			* Returns the list of classes that have matching input GraphQL types.
75			*
76			* @return string[]
77			*/
78			public function getSupportedClasses(): array
79			{
80			if ($this->supportedClasses === null) {
81			$supportedClassesArrays = array_map(function(TypeMapperInterface $typeMapper) { return $typeMapper->getSupportedClasses(); }, $this->typeMappers);
82			$this->supportedClasses = array_unique(array_merge(...$supportedClassesArrays));
83			}
84			return $this->supportedClasses;
85			}
86
87			/**
88			* Returns true if this type mapper can map the $className FQCN to a GraphQL input type.
89			*
90			* @param string $className
91			* @return bool
92			*/
93			public function canMapClassToInputType(string $className): bool
94			{
95			foreach ($this->typeMappers as $typeMapper) {
96			if ($typeMapper->canMapClassToInputType($className)) {
97			return true;
98			}
99			}
100			return false;
101			}
102
103			/**
104			* Maps a PHP fully qualified class name to a GraphQL input type.
105			*
106			* @param string $className
107			* @return InputType
108			* @throws CannotMapTypeException
109			*/
110			public function mapClassToInputType(string $className): InputType
111			{
112			foreach ($this->typeMappers as $typeMapper) {
113			if ($typeMapper->canMapClassToInputType($className)) {
114			return $typeMapper->mapClassToInputType($className);
115			}
116			}
117			throw CannotMapTypeException::createForInputType($className);
118			}
119
120			/**
121			* Returns a GraphQL type by name (can be either an input or output type)
122			*
123			* @param string $typeName The name of the GraphQL type
124			* @param RecursiveTypeMapperInterface $recursiveTypeMapper
125			* @return Type&(InputType\|OutputType)
126			*/
127			public function mapNameToType(string $typeName, RecursiveTypeMapperInterface $recursiveTypeMapper): Type
128			{
129			// TODO: Implement mapNameToType() method.
130			}
			0 ignored issues – show Bug Best Practice introduced 2018-12-11 18:06 UTC by Report Bug Copy Issue Report In this branch, the function will implicitly return `null` which is incompatible with the type-hinted return `GraphQL\Type\Definition\Type`. Consider adding a return statement or allowing `null` as return value. For hinted functions/methods where all return statements with the correct type are only reachable via conditions, ?null? gets implicitly returned which may be incompatible with the hinted type. Let?s take a look at an example: interface ReturnsInt { public function returnsIntHinted(): int; } class MyClass implements ReturnsInt { public function returnsIntHinted(): int { if (foo()) { return 123; } // here: null is implicitly returned } } Loading history...
131			}
132

thecodingmachine / graphql-controllers

Pull Request — master (#60)

CompositeTypeMapper::mapNameToType() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like