Endpoint::add() - Code Metrics - Inspection of "update changelog and upgrade guide" - ynloultratech/graphql-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 319fcb...7a107a )

by Rafael

created 2018-06-02 00:45 UTC

Endpoint::add() A

↳ Parent: Endpoint

Complexity

Conditions	3
Paths	3

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	3.3332

Importance

Changes

Metric	Value
cc	3
eloc	5
nc	3
nop	1
dl	0
loc	11
ccs	4
cts	6
cp	0.6667
crap	3.3332
rs	9.4285
c	0
b	0
f	0

<?php
/*******************************************************************************
 *  This file is part of the GraphQL Bundle package.
 *
 *  (c) YnloUltratech <[email protected]>
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 ******************************************************************************/

namespace Ynlo\GraphQLBundle\Definition\Registry;

use Ynlo\GraphQLBundle\Definition\ClassAwareDefinitionInterface;
use Ynlo\GraphQLBundle\Definition\DefinitionInterface;
use Ynlo\GraphQLBundle\Definition\InterfaceDefinition;
use Ynlo\GraphQLBundle\Definition\MutationDefinition;
use Ynlo\GraphQLBundle\Definition\QueryDefinition;

/**
 * Class Endpoint
 */
class Endpoint
{
    /**
     * @var string
     */
    protected $name;

    /**
     * @var DefinitionInterface[]
     */
    protected $types = [];

    /**
     * @var string[]
     */
    protected $typeMap = [];

    /**
     * @var InterfaceDefinition[]
     */
    protected $interfaces = [];

    /**
     * @var MutationDefinition[]
     */
    protected $mutations = [];

    /**
     * @var QueryDefinition[]
     */
    protected $queries = [];

    /**
     * Endpoint constructor.
     *
     * @param string $name
     */
    public function __construct(string $name)
    {
        $this->name = $name;
    }

    /**
     * @return string
     */
    public function getName(): string
    {
        return $this->name;
    }

    /**
     * @return DefinitionInterface[]
     */
    public function allTypes(): array
    {
        return $this->types;
    }

    /**
     * @param string $type
     *
     * @return null|string
     */
    public function getClassForType(string $type):?string
    {
        if (isset($this->typeMap[$type])) {
            return $this->typeMap[$type];
        }

        return null;
    }

    /**
     * @param string $class
     *
     * @return bool
     */
    public function hasTypeForClass(string $class): bool
    {
        return in_array($class, $this->typeMap);
    }

    /**
     * @param string $class
     *
     * @return string
     *
     * @throws \UnexpectedValueException if the class does not have any valid type
     */
    public function getTypeForClass(string $class): string
    {
        $typeMap = array_flip($this->typeMap);
        if (isset($typeMap[$class])) {
            return $typeMap[$class];
        }

        $error = sprintf('Does not exist any valid type for class "%s"', $class);
        throw new \UnexpectedValueException($error);
    }

    /**
     * Helper method to avoid in runtime
     * recurring all types to get only interfaces
     *
     * @return InterfaceDefinition[]
     */
    public function allInterfaces(): array
    {
        return $this->interfaces;
    }

    /**
     * @return array|MutationDefinition[]
     */
    public function allMutations(): array
    {
        return $this->mutations;
    }

    /**
     * @return array|QueryDefinition[]
     */
    public function allQueries(): array
    {
        return $this->queries;
    }

    /**
     * @param DefinitionInterface[] $types
     */
    public function setTypes(array $types)
    {
        $this->types = [];
        $this->interfaces = [];
        foreach ($types as $type) {
            $this->addType($type);
        }
    }

    /**
     * @param MutationDefinition[] $mutations
     */
    public function setMutations(array $mutations)
    {
        $this->mutations = [];
        foreach ($mutations as $mutation) {
            $this->addMutation($mutation);
        }
    }

    /**
     * @param QueryDefinition[] $queries
     */
    public function setQueries(array $queries)
    {
        $this->queries = [];
        foreach ($queries as $query) {
            $this->addQuery($query);
        }
    }

    /**
     * @param string $name
     *
     * @return bool
     */
    public function hasType($name): bool
    {
        if (class_exists($name) || interface_exists($name)) {
            if ($this->hasTypeForClass($name)) {
                $name = $this->getTypeForClass($name);
            }
        }

        return array_key_exists($name, $this->types);
    }

    /**
     * @param string $name
     *
     * @return bool
     */
    public function hasMutation($name): bool
    {
        return array_key_exists($name, $this->mutations);
    }

    /**
     * @param string $name
     *
     * @return bool
     */
    public function hasQuery($name): bool
    {
        return array_key_exists($name, $this->queries);
    }

    /**
     * @param string $name
     *
     * @return Endpoint
     */
    public function removeType($name): Endpoint
    {
        if ($this->hasType($name)) {
            $type = $this->getType($name);
            if ($type instanceof InterfaceDefinition) {
                unset($this->interfaces[$type->getName()]);
            }
        }

        unset($this->types[$name]);
        if (isset($this->typeMap[$name])) {
            unset($this->typeMap[$name]);
        }

        return $this;
    }

    /**
     * @param string $name
     *
     * @return Endpoint
     */
    public function removeQuery($name): Endpoint
    {
        unset($this->queries[$name]);

        return $this;
    }

    /**
     * @param string $name
     *
     * @return Endpoint
     */
    public function removeMutation($name): Endpoint
    {
        unset($this->mutations[$name]);

        return $this;
    }

    /**
     * @param string $name
     *
     * @return DefinitionInterface
     *
     * @throws \UnexpectedValueException
     */
    public function getType($name)
    {
        if (class_exists($name) || interface_exists($name)) {
            if ($this->hasTypeForClass($name)) {
                $name = $this->getTypeForClass($name);
            }
        }

        if (!$this->hasType($name)) {
            throw new \UnexpectedValueException(sprintf('Does not exist a valid definition for "%s" type', $name));
        }

        return $this->types[$name];
    }

    /**
     * @param string $name
     *
     * @return MutationDefinition
     */
    public function getMutation($name): MutationDefinition
    {
        return $this->mutations[$name];
    }

    /**
     * @param string $name
     *
     * @return QueryDefinition
     */
    public function getQuery($name): QueryDefinition
    {
        return $this->queries[$name];
    }

    /**
     * @param DefinitionInterface $definition
     *
     * @return Endpoint
     */
    public function add(DefinitionInterface $definition): Endpoint
    {
        if ($definition instanceof MutationDefinition) {
            return $this->addMutation($definition);
        }

        if ($definition instanceof QueryDefinition) {
            return $this->addQuery($definition);
        }

        return $this->addType($definition);
    }

    /**
     * @param DefinitionInterface $type
     *
     * @return Endpoint
     */
    public function addType(DefinitionInterface $type): Endpoint
    {
        if ($this->hasType($type->getName())) {
            throw new \RuntimeException(sprintf('Duplicate definition for type with name "%s"', $type->getName()));
        }
        $this->types[$type->getName()] = $type;

        if ($type instanceof InterfaceDefinition) {
            $this->interfaces[$type->getName()] = $type;
        }

        if ($type instanceof ClassAwareDefinitionInterface) {
            if ($type->getClass()) {
                $class = $type->getClass();
                //all classes are saved without \ at the beginning
                $class = preg_replace('/^\\\\/', null, $class);
                $this->typeMap[$type->getName()] = $class;
            }
        }

        return $this;
    }

    /**
     * @param MutationDefinition $mutation
     *
     * @return Endpoint
     */
    public function addMutation(MutationDefinition $mutation): Endpoint
    {
        if ($this->hasMutation($mutation->getName())) {
            throw new \RuntimeException(sprintf('Duplicate definition for query with name "%s"', $mutation->getName()));
        }
        $this->mutations[$mutation->getName()] = $mutation;

        return $this;
    }

    /**
     * @param QueryDefinition $query
     *
     * @return Endpoint
     */
    public function addQuery(QueryDefinition $query): Endpoint
    {
        if ($this->hasQuery($query->getName())) {
            throw new \RuntimeException(sprintf('Duplicate definition for query with name "%s"', $query->getName()));
        }
        $this->queries[$query->getName()] = $query;

        return $this;
    }
}


1		<?php
2		/*******************************************************************************
3		* This file is part of the GraphQL Bundle package.
4		*
5		* (c) YnloUltratech <[email protected]>
6		*
7		* For the full copyright and license information, please view the LICENSE
8		* file that was distributed with this source code.
9		******************************************************************************/
10
11		namespace Ynlo\GraphQLBundle\Definition\Registry;
12
13		use Ynlo\GraphQLBundle\Definition\ClassAwareDefinitionInterface;
14		use Ynlo\GraphQLBundle\Definition\DefinitionInterface;
15		use Ynlo\GraphQLBundle\Definition\InterfaceDefinition;
16		use Ynlo\GraphQLBundle\Definition\MutationDefinition;
17		use Ynlo\GraphQLBundle\Definition\QueryDefinition;
18
19		/**
20		* Class Endpoint
21		*/
22		class Endpoint
23		{
24		/**
25		* @var string
26		*/
27		protected $name;
28
29		/**
30		* @var DefinitionInterface[]
31		*/
32		protected $types = [];
33
34		/**
35		* @var string[]
36		*/
37		protected $typeMap = [];
38
39		/**
40		* @var InterfaceDefinition[]
41		*/
42		protected $interfaces = [];
43
44		/**
45		* @var MutationDefinition[]
46		*/
47		protected $mutations = [];
48
49		/**
50		* @var QueryDefinition[]
51		*/
52		protected $queries = [];
53
54		/**
55		* Endpoint constructor.
56		*
57		* @param string $name
58		*/
59	1	public function __construct(string $name)
60		{
61	1	$this->name = $name;
62	1	}
63
64		/**
65		* @return string
66		*/
67	1	public function getName(): string
68		{
69	1	return $this->name;
70		}
71
72		/**
73		* @return DefinitionInterface[]
74		*/
75	1	public function allTypes(): array
76		{
77	1	return $this->types;
78		}
79
80		/**
81		* @param string $type
82		*
83		* @return null\|string
84		*/
85	15	public function getClassForType(string $type):?string
86		{
87	15	if (isset($this->typeMap[$type])) {
88	15	return $this->typeMap[$type];
89		}
90
91		return null;
92		}
93
94		/**
95		* @param string $class
96		*
97		* @return bool
98		*/
99	22	public function hasTypeForClass(string $class): bool
100		{
101	22	return in_array($class, $this->typeMap);
102		}
103
104		/**
105		* @param string $class
106		*
107		* @return string
108		*
109		* @throws \UnexpectedValueException if the class does not have any valid type
110		*/
111	22	public function getTypeForClass(string $class): string
112		{
113	22	$typeMap = array_flip($this->typeMap);
114	22	if (isset($typeMap[$class])) {
115	22	return $typeMap[$class];
116		}
117
118		$error = sprintf('Does not exist any valid type for class "%s"', $class);
119		throw new \UnexpectedValueException($error);
120		}
121
122		/**
123		* Helper method to avoid in runtime
124		* recurring all types to get only interfaces
125		*
126		* @return InterfaceDefinition[]
127		*/
128	22	public function allInterfaces(): array
129		{
130	22	return $this->interfaces;
131		}
132
133		/**
134		* @return array\|MutationDefinition[]
135		*/
136	22	public function allMutations(): array
137		{
138	22	return $this->mutations;
139		}
140
141		/**
142		* @return array\|QueryDefinition[]
143		*/
144	22	public function allQueries(): array
145		{
146	22	return $this->queries;
147		}
148
149		/**
150		* @param DefinitionInterface[] $types
151		*/
152	1	public function setTypes(array $types)
153		{
154	1	$this->types = [];
155	1	$this->interfaces = [];
156	1	foreach ($types as $type) {
157	1	$this->addType($type);
158		}
159	1	}
160
161		/**
162		* @param MutationDefinition[] $mutations
163		*/
164	1	public function setMutations(array $mutations)
165		{
166	1	$this->mutations = [];
167	1	foreach ($mutations as $mutation) {
168	1	$this->addMutation($mutation);
169		}
170	1	}
171
172		/**
173		* @param QueryDefinition[] $queries
174		*/
175	1	public function setQueries(array $queries)
176		{
177	1	$this->queries = [];
178	1	foreach ($queries as $query) {
179	1	$this->addQuery($query);
180		}
181	1	}
182
183		/**
184		* @param string $name
185		*
186		* @return bool
187		*/
188	22	public function hasType($name): bool
189		{
190	22	if (class_exists($name) \|\| interface_exists($name)) {
191	22	if ($this->hasTypeForClass($name)) {
192	7	$name = $this->getTypeForClass($name);
193		}
194		}
195
196	22	return array_key_exists($name, $this->types);
197		}
198
199		/**
200		* @param string $name
201		*
202		* @return bool
203		*/
204	1	public function hasMutation($name): bool
205		{
206	1	return array_key_exists($name, $this->mutations);
207		}
208
209		/**
210		* @param string $name
211		*
212		* @return bool
213		*/
214	1	public function hasQuery($name): bool
215		{
216	1	return array_key_exists($name, $this->queries);
217		}
218
219		/**
220		* @param string $name
221		*
222		* @return Endpoint
223		*/
224		public function removeType($name): Endpoint
225		{
226		if ($this->hasType($name)) {
227		$type = $this->getType($name);
228		if ($type instanceof InterfaceDefinition) {
229		unset($this->interfaces[$type->getName()]);
230		}
231		}
232
233		unset($this->types[$name]);
234		if (isset($this->typeMap[$name])) {
235		unset($this->typeMap[$name]);
236		}
237
238		return $this;
239		}
240
241		/**
242		* @param string $name
243		*
244		* @return Endpoint
245		*/
246	1	public function removeQuery($name): Endpoint
247		{
248	1	unset($this->queries[$name]);
249
250	1	return $this;
251		}
252
253		/**
254		* @param string $name
255		*
256		* @return Endpoint
257		*/
258		public function removeMutation($name): Endpoint
259		{
260		unset($this->mutations[$name]);
261
262		return $this;
263		}
264
265		/**
266		* @param string $name
267		*
268		* @return DefinitionInterface
269		*
270		* @throws \UnexpectedValueException
271		*/
272	22	public function getType($name)
273		{
274	22	if (class_exists($name) \|\| interface_exists($name)) {
275	7	if ($this->hasTypeForClass($name)) {
276	7	$name = $this->getTypeForClass($name);
277		}
278		}
279
280	22	if (!$this->hasType($name)) {
281		throw new \UnexpectedValueException(sprintf('Does not exist a valid definition for "%s" type', $name));
282		}
283
284	22	return $this->types[$name];
285		}
286
287		/**
288		* @param string $name
289		*
290		* @return MutationDefinition
291		*/
292		public function getMutation($name): MutationDefinition
293		{
294		return $this->mutations[$name];
295		}
296
297		/**
298		* @param string $name
299		*
300		* @return QueryDefinition
301		*/
302		public function getQuery($name): QueryDefinition
303		{
304		return $this->queries[$name];
305		}
306
307		/**
308		* @param DefinitionInterface $definition
309		*
310		* @return Endpoint
311		*/
312	1	public function add(DefinitionInterface $definition): Endpoint
313		{
314	1	if ($definition instanceof MutationDefinition) {
315		return $this->addMutation($definition);
316		}
317
318	1	if ($definition instanceof QueryDefinition) {
319		return $this->addQuery($definition);
320		}
321
322	1	return $this->addType($definition);
323		}
324
325		/**
326		* @param DefinitionInterface $type
327		*
328		* @return Endpoint
329		*/
330	1	public function addType(DefinitionInterface $type): Endpoint
331		{
332	1	if ($this->hasType($type->getName())) {
333		throw new \RuntimeException(sprintf('Duplicate definition for type with name "%s"', $type->getName()));
334		}
335	1	$this->types[$type->getName()] = $type;
336
337	1	if ($type instanceof InterfaceDefinition) {
338	1	$this->interfaces[$type->getName()] = $type;
339		}
340
341	1	if ($type instanceof ClassAwareDefinitionInterface) {
342	1	if ($type->getClass()) {
343	1	$class = $type->getClass();
344		//all classes are saved without \ at the beginning
345	1	$class = preg_replace('/^\\\\/', null, $class);
346	1	$this->typeMap[$type->getName()] = $class;
347		}
348		}
349
350	1	return $this;
351		}
352
353		/**
354		* @param MutationDefinition $mutation
355		*
356		* @return Endpoint
357		*/
358	1	public function addMutation(MutationDefinition $mutation): Endpoint
359		{
360	1	if ($this->hasMutation($mutation->getName())) {
361		throw new \RuntimeException(sprintf('Duplicate definition for query with name "%s"', $mutation->getName()));
362		}
363	1	$this->mutations[$mutation->getName()] = $mutation;
364
365	1	return $this;
366		}
367
368		/**
369		* @param QueryDefinition $query
370		*
371		* @return Endpoint
372		*/
373	1	public function addQuery(QueryDefinition $query): Endpoint
374		{
375	1	if ($this->hasQuery($query->getName())) {
376		throw new \RuntimeException(sprintf('Duplicate definition for query with name "%s"', $query->getName()));
377		}
378	1	$this->queries[$query->getName()] = $query;
379
380	1	return $this;
381		}
382		}
383

ynloultratech / graphql-bundle

Push — master ( 319fcb...7a107a )

Endpoint::add() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like