AnnotationProcessor::process() - Code Metrics - Inspection of "Merge pull request #72 from tebru/v3" - tebru/retrofit-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (203e41)

by Nate

created 2017-09-12 22:59 UTC

AnnotationProcessor::process() B

↳ Parent: AnnotationProcessor

Complexity

Conditions	3
Paths	3

Size

Total Lines	24
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	13
CRAP Score	3

Importance

Changes

Metric	Value
dl	0
loc	24
ccs	13
cts	13
cp	1
rs	8.9713
c	0
b	0
f	0
cc	3
eloc	17
nc	3
nop	4
crap	3

<?php
/*
 * Copyright (c) Nate Brunette.
 * Distributed under the MIT License (http://opensource.org/licenses/MIT)
 */

declare(strict_types=1);

namespace Tebru\Retrofit\Internal;

use LogicException;
use ReflectionMethod;
use Tebru\AnnotationReader\AbstractAnnotation;
use Tebru\PhpType\TypeToken;
use Tebru\Retrofit\AnnotationHandler;
use Tebru\Retrofit\Converter;
use Tebru\Retrofit\Internal\Converter\ConverterProvider;
use Tebru\Retrofit\Annotation\ParameterAwareAnnotation;
use Tebru\Retrofit\RequestBodyConverter;
use Tebru\Retrofit\ServiceMethodBuilder;
use Tebru\Retrofit\StringConverter;

/**
 * Class AnnotationProcessor
 *
 * Given an array of handlers, process an [@see AbstractAnnotation]
 *
 * @author Nate Brunette <[email protected]>
 */
final class AnnotationProcessor
{
    /**
     * An array of annotation handlers
     *
     * @var AnnotationHandler[]
     */
    private $handlers;

    /**
     * Constructor
     *
     * @param AnnotationHandler[] $handlers
     */
    public function __construct(array $handlers)
    {
        $this->handlers = $handlers;
    }

    /**
     * Accepts an annotation and delegates to an [@see AnnotationHandler]
     *
     * @param AbstractAnnotation $annotation
     * @param ServiceMethodBuilder $serviceMethodBuilder
     * @param ConverterProvider $converterProvider
     * @param ReflectionMethod $reflectionMethod
     * @throws \LogicException
     */
    public function process(
        AbstractAnnotation $annotation,
        ServiceMethodBuilder $serviceMethodBuilder,
        ConverterProvider $converterProvider,
        ReflectionMethod $reflectionMethod
    ): void {
        $name = $annotation->getName();

        if (!isset($this->handlers[$name])) {
            return;
        }

        $handler = $this->handlers[$name];
        $converter = null;
        $index = null;

        if ($annotation instanceof ParameterAwareAnnotation) {
            $index = $this->findMethodParameterIndex($reflectionMethod, $annotation->getVariableName());
            $type = $this->getParameterType($reflectionMethod, $index);
            $converter = $this->getConverter($annotation, $converterProvider, $type);
        }

        $handler->handle($annotation, $serviceMethodBuilder, $converter, $index);
    }

    /**
     * Find the position of the method parameter
     *
     * @param ReflectionMethod $reflectionMethod
     * @param string $name
     * @return int
     * @throws \LogicException
     */
    private function findMethodParameterIndex(ReflectionMethod $reflectionMethod, string $name): int
    {
        $reflectionParameters = $reflectionMethod->getParameters();
        foreach ($reflectionParameters as $index => $reflectionParameter) {
            if ($reflectionParameter->getName() === $name) {

                return $index;
            }
        }

        throw new LogicException(sprintf(
            'Retrofit: Could not find parameter named %s in %s::%s. Please double check that annotations are properly ' .
            'referencing method parameters.',
            $name,
            $reflectionMethod->getDeclaringClass()->getName(),

            $reflectionMethod->getName()

        ));
    }

    /**
     * Get the parameter type
     *
     * @param ReflectionMethod $reflectionMethod
     * @param int $index
     * @return TypeToken
     * @throws \LogicException
     */
    private function getParameterType(ReflectionMethod $reflectionMethod, int $index): TypeToken
    {
        $reflectionParameter = $reflectionMethod->getParameters()[$index];
        $reflectionType = $reflectionParameter->getType();

        if ($reflectionType === null) {
            throw new LogicException(sprintf(
                'Retrofit: Parameter type was not found for method %s::%s',
                $reflectionMethod->getDeclaringClass()->getName(),

                $reflectionMethod->getName()

            ));
        }

        /** @noinspection ExceptionsAnnotatingAndHandlingInspection */
        return new TypeToken($reflectionType->getName());
    }

    /**
     * Get the converter from annotation converter class
     *
     * @param ParameterAwareAnnotation $annotation
     * @param ConverterProvider $converterProvider
     * @param TypeToken $type
     * @return Converter
     * @throws \LogicException
     */
    private function getConverter(
        ParameterAwareAnnotation $annotation,
        ConverterProvider $converterProvider,
        TypeToken $type
    ): Converter {
        switch ($annotation->converterType()) {
            case RequestBodyConverter::class:
                return $converterProvider->getRequestBodyConverter($type);
            case StringConverter::class:
                return $converterProvider->getStringConverter($type);
        }

        throw new LogicException(sprintf(
            'Retrofit: Unable to handle converter of type %s. Please use RequestBodyConverter or StringConverter',
            $annotation->converterType()
        ));
    }
}


1		<?php
2		/*
3		* Copyright (c) Nate Brunette.
4		* Distributed under the MIT License (http://opensource.org/licenses/MIT)
5		*/
6
7		declare(strict_types=1);
8
9		namespace Tebru\Retrofit\Internal;
10
11		use LogicException;
12		use ReflectionMethod;
13		use Tebru\AnnotationReader\AbstractAnnotation;
14		use Tebru\PhpType\TypeToken;
15		use Tebru\Retrofit\AnnotationHandler;
16		use Tebru\Retrofit\Converter;
17		use Tebru\Retrofit\Internal\Converter\ConverterProvider;
18		use Tebru\Retrofit\Annotation\ParameterAwareAnnotation;
19		use Tebru\Retrofit\RequestBodyConverter;
20		use Tebru\Retrofit\ServiceMethodBuilder;
21		use Tebru\Retrofit\StringConverter;
22
23		/**
24		* Class AnnotationProcessor
25		*
26		* Given an array of handlers, process an [@see AbstractAnnotation]
27		*
28		* @author Nate Brunette <[email protected]>
29		*/
30		final class AnnotationProcessor
31		{
32		/**
33		* An array of annotation handlers
34		*
35		* @var AnnotationHandler[]
36		*/
37		private $handlers;
38
39		/**
40		* Constructor
41		*
42		* @param AnnotationHandler[] $handlers
43		*/
44	33	public function __construct(array $handlers)
45		{
46	33	$this->handlers = $handlers;
47	33	}
48
49		/**
50		* Accepts an annotation and delegates to an [@see AnnotationHandler]
51		*
52		* @param AbstractAnnotation $annotation
53		* @param ServiceMethodBuilder $serviceMethodBuilder
54		* @param ConverterProvider $converterProvider
55		* @param ReflectionMethod $reflectionMethod
56		* @throws \LogicException
57		*/
58	21	public function process(
59		AbstractAnnotation $annotation,
60		ServiceMethodBuilder $serviceMethodBuilder,
61		ConverterProvider $converterProvider,
62		ReflectionMethod $reflectionMethod
63		): void {
64	21	$name = $annotation->getName();
65
66	21	if (!isset($this->handlers[$name])) {
67	3	return;
68		}
69
70	20	$handler = $this->handlers[$name];
71	20	$converter = null;
72	20	$index = null;
73
74	20	if ($annotation instanceof ParameterAwareAnnotation) {
75	11	$index = $this->findMethodParameterIndex($reflectionMethod, $annotation->getVariableName());
76	10	$type = $this->getParameterType($reflectionMethod, $index);
77	9	$converter = $this->getConverter($annotation, $converterProvider, $type);
78		}
79
80	17	$handler->handle($annotation, $serviceMethodBuilder, $converter, $index);
81	17	}
82
83		/**
84		* Find the position of the method parameter
85		*
86		* @param ReflectionMethod $reflectionMethod
87		* @param string $name
88		* @return int
89		* @throws \LogicException
90		*/
91	11	private function findMethodParameterIndex(ReflectionMethod $reflectionMethod, string $name): int
92		{
93	11	$reflectionParameters = $reflectionMethod->getParameters();
94	11	foreach ($reflectionParameters as $index => $reflectionParameter) {
95	11	if ($reflectionParameter->getName() === $name) {
		0 ignored issues – show Bug introduced 2017-09-12 22:35 UTC by Report Bug Copy Issue Report Consider using `$reflectionParameter->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
96	10	return $index;
97		}
98		}
99
100	1	throw new LogicException(sprintf(
101		'Retrofit: Could not find parameter named %s in %s::%s. Please double check that annotations are properly ' .
102	1	'referencing method parameters.',
103	1	$name,
104	1	$reflectionMethod->getDeclaringClass()->getName(),
		0 ignored issues – show introduced 2017-09-12 22:35 UTC by Report Bug Copy Issue Report Consider using `$reflectionMethod->class`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
105	1	$reflectionMethod->getName()
		0 ignored issues – show Bug introduced 2017-09-12 22:35 UTC by Report Bug Copy Issue Report Consider using `$reflectionMethod->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
106		));
107		}
108
109		/**
110		* Get the parameter type
111		*
112		* @param ReflectionMethod $reflectionMethod
113		* @param int $index
114		* @return TypeToken
115		* @throws \LogicException
116		*/
117	10	private function getParameterType(ReflectionMethod $reflectionMethod, int $index): TypeToken
118		{
119	10	$reflectionParameter = $reflectionMethod->getParameters()[$index];
120	10	$reflectionType = $reflectionParameter->getType();
121
122	10	if ($reflectionType === null) {
123	1	throw new LogicException(sprintf(
124	1	'Retrofit: Parameter type was not found for method %s::%s',
125	1	$reflectionMethod->getDeclaringClass()->getName(),
		0 ignored issues – show introduced 2017-09-12 22:35 UTC by Report Bug Copy Issue Report Consider using `$reflectionMethod->class`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
126	1	$reflectionMethod->getName()
		0 ignored issues – show Bug introduced 2017-09-12 22:35 UTC by Report Bug Copy Issue Report Consider using `$reflectionMethod->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
127		));
128		}
129
130		/** @noinspection ExceptionsAnnotatingAndHandlingInspection */
131	9	return new TypeToken($reflectionType->getName());
132		}
133
134		/**
135		* Get the converter from annotation converter class
136		*
137		* @param ParameterAwareAnnotation $annotation
138		* @param ConverterProvider $converterProvider
139		* @param TypeToken $type
140		* @return Converter
141		* @throws \LogicException
142		*/
143	9	private function getConverter(
144		ParameterAwareAnnotation $annotation,
145		ConverterProvider $converterProvider,
146		TypeToken $type
147		): Converter {
148	9	switch ($annotation->converterType()) {
149	9	case RequestBodyConverter::class:
150	4	return $converterProvider->getRequestBodyConverter($type);
151	5	case StringConverter::class:
152	4	return $converterProvider->getStringConverter($type);
153		}
154
155	1	throw new LogicException(sprintf(
156	1	'Retrofit: Unable to handle converter of type %s. Please use RequestBodyConverter or StringConverter',
157	1	$annotation->converterType()
158		));
159		}
160		}
161

tebru / retrofit-php

Branch — master (203e41)

AnnotationProcessor::process() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like