Invoker::getTypeAdapter() - Code Metrics - Inspection of "Added TypeCaster class" - vaderangry/PhpJsonRpc - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 0d4fd4...557d64 )

by Denis

created 2016-12-09 07:59 UTC

Invoker::getTypeAdapter() A

↳ Parent: Invoker

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	0

<?php

namespace PhpJsonRpc\Server;

use PhpJsonRpc\Common\TypeAdapter\TypeAdapter;
use PhpJsonRpc\Common\TypeAdapter\TypeCastException;
use PhpJsonRpc\Error\InvalidParamsException;
use PhpJsonRpc\Error\ServerErrorException;

/**
 * Invoker of methods
 */
class Invoker
{
    /**
     * @var TypeAdapter
     */
    private $typeAdapter;

    /**
     * Invoker constructor.
     */
    public function __construct()
    {
        $this->typeAdapter = new TypeAdapter();
    }

    /**
     * @param mixed  $object
     * @param string $method
     * @param array  $parameters
     *
     * @return mixed
     */
    public function invoke($object, string $method, array $parameters)
    {
        $handler    = $object;
        $reflection = new \ReflectionMethod($handler, $method);

        if ($reflection->getNumberOfRequiredParameters() > count($parameters)) {
            throw new InvalidParamsException('Expected ' . $reflection->getNumberOfRequiredParameters() . ' parameters');
        }

        $formalParameters = $reflection->getParameters();
        $actualParameters = $this->prepareActualParameters($formalParameters, $parameters);

        try {
            $result = $reflection->invokeArgs($handler, $actualParameters);
        } catch (\Exception $exception) {
            throw new ServerErrorException($exception->getMessage(), $exception->getCode());
        }

        return $this->castResult($result);
    }

    /**
     * @return TypeAdapter
     */
    public function getTypeAdapter(): TypeAdapter
    {
        return $this->typeAdapter;
    }

    /**
     * @param \ReflectionParameter[] $formalParameters Formal parameters
     * @param array                  $parameters       Parameters from request (raw)
     *
     * @return array
     */
    private function prepareActualParameters(array $formalParameters, array $parameters): array
    {
        $result = [];

        // Handle named parameters
        if ($this->isNamedArray($parameters)) {

            foreach ($formalParameters as $formalParameter) {
                /** @var \ReflectionParameter $formalParameter */

                $formalType = (string) $formalParameter->getType();
                $name       = $formalParameter->name;

                if ($formalParameter->isOptional()) {
                    if (!array_key_exists($name, $parameters)) {
                        continue;
                    }

                    $result[$name] = $formalParameter->getClass() !== null
                        ? $this->toObject($formalParameter->getClass()->name, $parameters[$name])
                        : $this->matchType($formalType, $parameters[$name]);
                }

                if (!array_key_exists($name, $parameters)) {
                    throw new InvalidParamsException('Named parameter error');
                }

                $result[$name] = $this->matchType($formalType, $parameters[$name]);
            }

            return $result;
        }

        // Handle positional parameters
        foreach ($formalParameters as $position => $formalParameter) {
            /** @var \ReflectionParameter $formalParameter */

            if ($formalParameter->isOptional() && !isset($parameters[$position])) {
                break;
            }

            if (!isset($parameters[$position])) {
                throw new InvalidParamsException('Positional parameter error');
            }

            $formalType = (string) $formalParameter->getType();
            $result[] = $formalParameter->getClass() !== null
                ? $this->toObject($formalParameter->getClass()->name, $parameters[$position])
                : $this->matchType($formalType, $parameters[$position]);
        }

        return $result;
    }

    /**
     * @param array $rawParameters
     *
     * @return bool
     */
    private function isNamedArray(array $rawParameters): bool
    {
        return array_keys($rawParameters) !== range(0, count($rawParameters) - 1);
    }

    /**
     * @param string $formalType
     * @param mixed  $value
     *
     * @return mixed
     */
    private function matchType(string $formalType, $value)
    {
        // Parameter without type-hinting returns as is
        if ($formalType === '') {
            return $value;
        }

        if ($this->isType($formalType, $value)) {
            return $value;
        }

        throw new InvalidParamsException('Type hint failed');
    }

    /**
     * @param string $formalClass
     * @param mixed  $value
     *
     * @return mixed
     */
    private function toObject(string $formalClass, $value)
    {
        if ($this->typeAdapter->isClassRegistered($formalClass)) {
            try {
                return $this->typeAdapter->toObject($value);
            } catch (TypeCastException $exception) {
                throw new InvalidParamsException('Class cast failed');
            }
        }

        throw new InvalidParamsException('Class hint failed');
    }

    /**
     * @param string $type
     * @param $value
     *
     * @return bool
     */
    private function isType(string $type, $value)
    {
        switch ($type) {
            case 'bool':
                return is_bool($value);

            case 'int':
                return is_int($value);

            case 'float':
                return is_float($value) || is_int($value);

            case 'string':
                return is_string($value);

            case 'array':
                return is_array($value);

            default:
                throw new InvalidParamsException('Type match error');
        }
    }

    /**
     * @param $result
     *
     * @return mixed
     */
    private function castResult($result)
    {
        try {
            $result = $this->typeAdapter->toArray($result);
        } catch (TypeCastException $exception) {
            return $result;
        }

        return $result;
    }
}


1			<?php
2
3			namespace PhpJsonRpc\Server;
4
5			use PhpJsonRpc\Common\TypeAdapter\TypeAdapter;
6			use PhpJsonRpc\Common\TypeAdapter\TypeCastException;
7			use PhpJsonRpc\Error\InvalidParamsException;
8			use PhpJsonRpc\Error\ServerErrorException;
9
10			/**
11			* Invoker of methods
12			*/
13			class Invoker
14			{
15			/**
16			* @var TypeAdapter
17			*/
18			private $typeAdapter;
19
20			/**
21			* Invoker constructor.
22			*/
23			public function __construct()
24			{
25			$this->typeAdapter = new TypeAdapter();
26			}
27
28			/**
29			* @param mixed $object
30			* @param string $method
31			* @param array $parameters
32			*
33			* @return mixed
34			*/
35			public function invoke($object, string $method, array $parameters)
36			{
37			$handler = $object;
38			$reflection = new \ReflectionMethod($handler, $method);
39
40			if ($reflection->getNumberOfRequiredParameters() > count($parameters)) {
41			throw new InvalidParamsException('Expected ' . $reflection->getNumberOfRequiredParameters() . ' parameters');
42			}
43
44			$formalParameters = $reflection->getParameters();
45			$actualParameters = $this->prepareActualParameters($formalParameters, $parameters);
46
47			try {
48			$result = $reflection->invokeArgs($handler, $actualParameters);
49			} catch (\Exception $exception) {
50			throw new ServerErrorException($exception->getMessage(), $exception->getCode());
51			}
52
53			return $this->castResult($result);
54			}
55
56			/**
57			* @return TypeAdapter
58			*/
59			public function getTypeAdapter(): TypeAdapter
60			{
61			return $this->typeAdapter;
62			}
63
64			/**
65			* @param \ReflectionParameter[] $formalParameters Formal parameters
66			* @param array $parameters Parameters from request (raw)
67			*
68			* @return array
69			*/
70			private function prepareActualParameters(array $formalParameters, array $parameters): array
71			{
72			$result = [];
73
74			// Handle named parameters
75			if ($this->isNamedArray($parameters)) {
76
77			foreach ($formalParameters as $formalParameter) {
78			/** @var \ReflectionParameter $formalParameter */
79
80			$formalType = (string) $formalParameter->getType();
81			$name = $formalParameter->name;
82
83			if ($formalParameter->isOptional()) {
84			if (!array_key_exists($name, $parameters)) {
85			continue;
86			}
87
88			$result[$name] = $formalParameter->getClass() !== null
89			? $this->toObject($formalParameter->getClass()->name, $parameters[$name])
90			: $this->matchType($formalType, $parameters[$name]);
91			}
92
93			if (!array_key_exists($name, $parameters)) {
94			throw new InvalidParamsException('Named parameter error');
95			}
96
97			$result[$name] = $this->matchType($formalType, $parameters[$name]);
98			}
99
100			return $result;
101			}
102
103			// Handle positional parameters
104			foreach ($formalParameters as $position => $formalParameter) {
105			/** @var \ReflectionParameter $formalParameter */
106
107			if ($formalParameter->isOptional() && !isset($parameters[$position])) {
108			break;
109			}
110
111			if (!isset($parameters[$position])) {
112			throw new InvalidParamsException('Positional parameter error');
113			}
114
115			$formalType = (string) $formalParameter->getType();
116			$result[] = $formalParameter->getClass() !== null
117			? $this->toObject($formalParameter->getClass()->name, $parameters[$position])
118			: $this->matchType($formalType, $parameters[$position]);
119			}
120
121			return $result;
122			}
123
124			/**
125			* @param array $rawParameters
126			*
127			* @return bool
128			*/
129			private function isNamedArray(array $rawParameters): bool
130			{
131			return array_keys($rawParameters) !== range(0, count($rawParameters) - 1);
132			}
133
134			/**
135			* @param string $formalType
136			* @param mixed $value
137			*
138			* @return mixed
139			*/
140			private function matchType(string $formalType, $value)
141			{
142			// Parameter without type-hinting returns as is
143			if ($formalType === '') {
144			return $value;
145			}
146
147			if ($this->isType($formalType, $value)) {
148			return $value;
149			}
150
151			throw new InvalidParamsException('Type hint failed');
152			}
153
154			/**
155			* @param string $formalClass
156			* @param mixed $value
157			*
158			* @return mixed
159			*/
160			private function toObject(string $formalClass, $value)
161			{
162			if ($this->typeAdapter->isClassRegistered($formalClass)) {
163			try {
164			return $this->typeAdapter->toObject($value);
165			} catch (TypeCastException $exception) {
166			throw new InvalidParamsException('Class cast failed');
167			}
168			}
169
170			throw new InvalidParamsException('Class hint failed');
171			}
172
173			/**
174			* @param string $type
175			* @param $value
176			*
177			* @return bool
178			*/
179			private function isType(string $type, $value)
180			{
181			switch ($type) {
182			case 'bool':
183			return is_bool($value);
184
185			case 'int':
186			return is_int($value);
187
188			case 'float':
189			return is_float($value) \|\| is_int($value);
190
191			case 'string':
192			return is_string($value);
193
194			case 'array':
195			return is_array($value);
196
197			default:
198			throw new InvalidParamsException('Type match error');
199			}
200			}
201
202			/**
203			* @param $result
204			*
205			* @return mixed
206			*/
207			private function castResult($result)
208			{
209			try {
210			$result = $this->typeAdapter->toArray($result);
211			} catch (TypeCastException $exception) {
212			return $result;
213			}
214
215			return $result;
216			}
217			}
218

vaderangry / PhpJsonRpc

Push — master ( 0d4fd4...557d64 )

Invoker::getTypeAdapter() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like