SwaggerSchema - Code Metrics - Inspection of "Use $ref as parameters in Path OpenAPI 3.0" - byjg/php-swagger-test - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#29)

by Joao

created 2019-03-18 04:02 UTC

SwaggerSchema C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	260
Duplicated Lines	8.46 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

Metric	Value
wmc	55
lcom	1
cbo	8
dl	22
loc	260
rs	6
c	0
b	0
f	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
A	getSpecificationVersion()	0	4	1
A	getServerUrl()	0	4	2
A	getHttpSchema()	0	4	2
A	getHost()	0	4	2
A	getBasePath()	0	9	5
B	getPathDefinition()	0	50	9
C	validateArguments()	10	35	16
B	getDefintion()	12	26	8
A	getRequestParameters()	0	16	4
A	getResponseParameters()	0	10	2
A	isAllowNullValues()	0	4	1
A	setAllowNullValues()	0	4	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like SwaggerSchema often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use SwaggerSchema, and based on these observations, apply Extract Interface, too.

<?php
/**
 * User: jg
 * Date: 22/05/17
 * Time: 09:29
 */

namespace ByJG\Swagger;

use ByJG\Swagger\Exception\DefinitionNotFoundException;
use ByJG\Swagger\Exception\HttpMethodNotFoundException;
use ByJG\Swagger\Exception\InvalidDefinitionException;
use ByJG\Swagger\Exception\NotMatchedException;
use ByJG\Swagger\Exception\PathNotFoundException;
use ByJG\Util\Uri;

class SwaggerSchema
{
    protected $jsonFile;
    protected $allowNullValues;
    protected $specificationVersion;

    const SWAGGER_PATHS="paths";
    const SWAGGER_PARAMETERS="parameters";
    const SWAGGER_COMPONENTS="components";

    public function __construct($jsonFile, $allowNullValues = false)
    {
        $this->jsonFile = json_decode($jsonFile, true);
        $this->allowNullValues = (bool) $allowNullValues;
        $this->specificationVersion = isset($this->jsonFile['swagger']) ? '2' : '3';
    }

    /**
     * Returns the major specification version
     * @return string
     */
    public function getSpecificationVersion()
    {
        return $this->specificationVersion;
    }

    public function getServerUrl()
    {
        return isset($this->jsonFile['servers']) ? $this->jsonFile['servers'][0]['url'] : '';
    }

    public function getHttpSchema()
    {
        return isset($this->jsonFile['schemes']) ? $this->jsonFile['schemes'][0] : '';
    }

    public function getHost()
    {
        return isset($this->jsonFile['host']) ? $this->jsonFile['host'] : '';
    }

    public function getBasePath()
    {
        if ($this->getSpecificationVersion() === '3') {
            $basePath =isset($this->jsonFile['servers']) ? explode('/', $this->jsonFile['servers'][0]['url']) : '';
            return is_array($basePath) ? '/' . end($basePath) : $basePath;
        }

        return isset($this->jsonFile['basePath']) ? $this->jsonFile['basePath'] : '';
    }

    /**
     * @param $path
     * @param $method
     * @return mixed
     * @throws DefinitionNotFoundException
     * @throws HttpMethodNotFoundException
     * @throws InvalidDefinitionException
     * @throws NotMatchedException
     * @throws PathNotFoundException
     */
    public function getPathDefinition($path, $method)
    {
        $method = strtolower($method);

        $path = preg_replace('~^' . $this->getBasePath() . '~', '', $path);

        $uri = new Uri($path);

        // Try direct match
        if (isset($this->jsonFile[self::SWAGGER_PATHS][$uri->getPath()])) {
            if (isset($this->jsonFile[self::SWAGGER_PATHS][$uri->getPath()][$method])) {
                return $this->jsonFile[self::SWAGGER_PATHS][$uri->getPath()][$method];
            }
            throw new HttpMethodNotFoundException("The http method '$method' not found in '$path'");
        }

        // Try inline parameter
        foreach (array_keys($this->jsonFile[self::SWAGGER_PATHS]) as $pathItem) {
            if (strpos($pathItem, '{') === false) {
                continue;
            }

            $pathItemPattern = '~^' . preg_replace('~\{(.*?)\}~', '(?<\1>[^/]+)', $pathItem) . '$~';

            $matches = [];
            if (preg_match($pathItemPattern, $uri->getPath(), $matches)) {
                $pathDef = $this->jsonFile[self::SWAGGER_PATHS][$pathItem];
                if (!isset($pathDef[$method])) {
                    throw new HttpMethodNotFoundException("The http method '$method' not found in '$path'");
                }

                $parametersPathMethod = [];
                $parametersPath = [];

                if (isset($pathDef[$method][self::SWAGGER_PARAMETERS])) {
                    $parametersPathMethod = $pathDef[$method][self::SWAGGER_PARAMETERS];
                }

                if (isset($pathDef[self::SWAGGER_PARAMETERS])) {
                    $parametersPath = $pathDef[self::SWAGGER_PARAMETERS];
                }

                $this->validateArguments('path', array_merge($parametersPathMethod, $parametersPath), $matches);

                return $pathDef[$method];
            }
        }

        throw new PathNotFoundException('Path "' . $path . '" not found');
    }

    /**
     * @param $parameterIn
     * @param $parameters
     * @param $arguments
     * @throws DefinitionNotFoundException
     * @throws InvalidDefinitionException
     * @throws NotMatchedException
     */
    private function validateArguments($parameterIn, $parameters, $arguments)
    {
        if ($this->getSpecificationVersion() === '3') {
            foreach ($parameters as $parameter) {
                if (isset($parameter['$ref'])) {
                    $paramParts = explode("/", $parameter['$ref']);
                    if (count($paramParts) != 4 || $paramParts[0] != "#" || $paramParts[1] != self::SWAGGER_COMPONENTS || $paramParts[2] != self::SWAGGER_PARAMETERS) {
                        throw new InvalidDefinitionException(
                            "Not get the reference in the expected format #/components/parameters/<NAME>"
                        );
                    }
                    if (!isset($this->jsonFile[self::SWAGGER_COMPONENTS][self::SWAGGER_PARAMETERS][$paramParts[3]])) {
                        throw new DefinitionNotFoundException(
                            "Not find reference #/components/parameters/${paramParts[3]}"
                        );
                    }
                    $parameter = $this->jsonFile[self::SWAGGER_COMPONENTS][self::SWAGGER_PARAMETERS][$paramParts[3]];
                }
                if ($parameter['in'] === $parameterIn &&

                    $parameter['schema']['type'] === "integer"
                    && filter_var($arguments[$parameter['name']], FILTER_VALIDATE_INT) === false) {
                    throw new NotMatchedException('Path expected an integer value');
                }
            }
            return;
        }

        foreach ($parameters as $parameter) {
            if ($parameter['in'] === $parameterIn

                && $parameter['type'] === "integer"
                && filter_var($arguments[$parameter['name']], FILTER_VALIDATE_INT) === false) {
                throw new NotMatchedException('Path expected an integer value');
            }
        }
    }

    /**
     * @param $name
     * @return mixed
     * @throws DefinitionNotFoundException
     * @throws InvalidDefinitionException
     */
    public function getDefintion($name)
    {
        $nameParts = explode('/', $name);

        if ($this->getSpecificationVersion() === '3') {
            if (count($nameParts) < 4 || $nameParts[0] !== '#') {

                throw new InvalidDefinitionException('Invalid Component');
            }

            if (!isset($this->jsonFile[$nameParts[1]][$nameParts[2]][$nameParts[3]])) {

                throw new DefinitionNotFoundException("Component'$name' not found");
            }

            return $this->jsonFile[$nameParts[1]][$nameParts[2]][$nameParts[3]];
        }

        if (count($nameParts) < 3 || $nameParts[0] !== '#') {

            throw new InvalidDefinitionException('Invalid Definition');
        }

        if (!isset($this->jsonFile[$nameParts[1]][$nameParts[2]])) {

            throw new DefinitionNotFoundException("Definition '$name' not found");
        }

        return $this->jsonFile[$nameParts[1]][$nameParts[2]];
    }

    /**
     * @param $path
     * @param $method
     * @return \ByJG\Swagger\SwaggerRequestBody
     * @throws DefinitionNotFoundException
     * @throws HttpMethodNotFoundException
     * @throws InvalidDefinitionException
     * @throws NotMatchedException
     * @throws PathNotFoundException
     */
    public function getRequestParameters($path, $method)
    {
        $structure = $this->getPathDefinition($path, $method);

        if($this->getSpecificationVersion() === '3') {
            if (!isset($structure['requestBody'])) {
                return new SwaggerRequestBody($this, "$method $path", []);
            }
            return new SwaggerRequestBody($this, "$method $path", $structure['requestBody']);
        }

        if (!isset($structure[self::SWAGGER_PARAMETERS])) {
            return new SwaggerRequestBody($this, "$method $path", []);
        }
        return new SwaggerRequestBody($this, "$method $path", $structure[self::SWAGGER_PARAMETERS]);
    }

    /**
     * @param $path
     * @param $method
     * @param $status
     * @return \ByJG\Swagger\SwaggerResponseBody
     * @throws \ByJG\Swagger\Exception\HttpMethodNotFoundException
     * @throws \ByJG\Swagger\Exception\InvalidDefinitionException
     * @throws \ByJG\Swagger\Exception\NotMatchedException
     * @throws \ByJG\Swagger\Exception\PathNotFoundException
     * @throws DefinitionNotFoundException
     */
    public function getResponseParameters($path, $method, $status)
    {
        $structure = $this->getPathDefinition($path, $method);

        if (!isset($structure['responses'][$status])) {
            throw new InvalidDefinitionException("Could not found status code '$status' in '$path' and '$method'");
        }

        return new SwaggerResponseBody($this, "$method $status $path", $structure['responses'][$status]);
    }

    /**
     * OpenApi 2.0 doesn't describe null values, so this flag defines,
     * if match is ok when one of property
     *
     * @return bool
     */
    public function isAllowNullValues()
    {
        return $this->allowNullValues;
    }

    /**
     * OpenApi 2.0 doesn't describe null values, so this flag defines,
     * if match is ok when one of property
     *
     * @param $value
     */
    public function setAllowNullValues($value)
    {
        $this->allowNullValues = (bool) $value;
    }
}


1		<?php
2		/**
3		* User: jg
4		* Date: 22/05/17
5		* Time: 09:29
6		*/
7
8		namespace ByJG\Swagger;
9
10		use ByJG\Swagger\Exception\DefinitionNotFoundException;
11		use ByJG\Swagger\Exception\HttpMethodNotFoundException;
12		use ByJG\Swagger\Exception\InvalidDefinitionException;
13		use ByJG\Swagger\Exception\NotMatchedException;
14		use ByJG\Swagger\Exception\PathNotFoundException;
15		use ByJG\Util\Uri;
16
17		class SwaggerSchema
18		{
19		protected $jsonFile;
20		protected $allowNullValues;
21		protected $specificationVersion;
22
23		const SWAGGER_PATHS="paths";
24		const SWAGGER_PARAMETERS="parameters";
25		const SWAGGER_COMPONENTS="components";
26
27		public function __construct($jsonFile, $allowNullValues = false)
28		{
29		$this->jsonFile = json_decode($jsonFile, true);
30		$this->allowNullValues = (bool) $allowNullValues;
31		$this->specificationVersion = isset($this->jsonFile['swagger']) ? '2' : '3';
32		}
33
34		/**
35		* Returns the major specification version
36		* @return string
37		*/
38		public function getSpecificationVersion()
39		{
40		return $this->specificationVersion;
41		}
42
43		public function getServerUrl()
44		{
45		return isset($this->jsonFile['servers']) ? $this->jsonFile['servers'][0]['url'] : '';
46		}
47
48		public function getHttpSchema()
49		{
50		return isset($this->jsonFile['schemes']) ? $this->jsonFile['schemes'][0] : '';
51		}
52
53		public function getHost()
54		{
55		return isset($this->jsonFile['host']) ? $this->jsonFile['host'] : '';
56		}
57
58		public function getBasePath()
59		{
60		if ($this->getSpecificationVersion() === '3') {
61		$basePath =isset($this->jsonFile['servers']) ? explode('/', $this->jsonFile['servers'][0]['url']) : '';
62		return is_array($basePath) ? '/' . end($basePath) : $basePath;
63		}
64
65		return isset($this->jsonFile['basePath']) ? $this->jsonFile['basePath'] : '';
66		}
67
68		/**
69		* @param $path
70		* @param $method
71		* @return mixed
72		* @throws DefinitionNotFoundException
73		* @throws HttpMethodNotFoundException
74		* @throws InvalidDefinitionException
75		* @throws NotMatchedException
76		* @throws PathNotFoundException
77		*/
78		public function getPathDefinition($path, $method)
79		{
80		$method = strtolower($method);
81
82		$path = preg_replace('~^' . $this->getBasePath() . '~', '', $path);
83
84		$uri = new Uri($path);
85
86		// Try direct match
87		if (isset($this->jsonFile[self::SWAGGER_PATHS][$uri->getPath()])) {
88		if (isset($this->jsonFile[self::SWAGGER_PATHS][$uri->getPath()][$method])) {
89		return $this->jsonFile[self::SWAGGER_PATHS][$uri->getPath()][$method];
90		}
91		throw new HttpMethodNotFoundException("The http method '$method' not found in '$path'");
92		}
93
94		// Try inline parameter
95		foreach (array_keys($this->jsonFile[self::SWAGGER_PATHS]) as $pathItem) {
96		if (strpos($pathItem, '{') === false) {
97		continue;
98		}
99
100		$pathItemPattern = '~^' . preg_replace('~\{(.*?)\}~', '(?<\1>[^/]+)', $pathItem) . '$~';
101
102		$matches = [];
103		if (preg_match($pathItemPattern, $uri->getPath(), $matches)) {
104		$pathDef = $this->jsonFile[self::SWAGGER_PATHS][$pathItem];
105		if (!isset($pathDef[$method])) {
106		throw new HttpMethodNotFoundException("The http method '$method' not found in '$path'");
107		}
108
109		$parametersPathMethod = [];
110		$parametersPath = [];
111
112		if (isset($pathDef[$method][self::SWAGGER_PARAMETERS])) {
113		$parametersPathMethod = $pathDef[$method][self::SWAGGER_PARAMETERS];
114		}
115
116		if (isset($pathDef[self::SWAGGER_PARAMETERS])) {
117		$parametersPath = $pathDef[self::SWAGGER_PARAMETERS];
118		}
119
120		$this->validateArguments('path', array_merge($parametersPathMethod, $parametersPath), $matches);
121
122		return $pathDef[$method];
123		}
124		}
125
126		throw new PathNotFoundException('Path "' . $path . '" not found');
127		}
128
129		/**
130		* @param $parameterIn
131		* @param $parameters
132		* @param $arguments
133		* @throws DefinitionNotFoundException
134		* @throws InvalidDefinitionException
135		* @throws NotMatchedException
136		*/
137		private function validateArguments($parameterIn, $parameters, $arguments)
138		{
139		if ($this->getSpecificationVersion() === '3') {
140		foreach ($parameters as $parameter) {
141		if (isset($parameter['$ref'])) {
142		$paramParts = explode("/", $parameter['$ref']);
143		if (count($paramParts) != 4 \|\| $paramParts[0] != "#" \|\| $paramParts[1] != self::SWAGGER_COMPONENTS \|\| $paramParts[2] != self::SWAGGER_PARAMETERS) {
144		throw new InvalidDefinitionException(
145		"Not get the reference in the expected format #/components/parameters/<NAME>"
146		);
147		}
148		if (!isset($this->jsonFile[self::SWAGGER_COMPONENTS][self::SWAGGER_PARAMETERS][$paramParts[3]])) {
149		throw new DefinitionNotFoundException(
150		"Not find reference #/components/parameters/${paramParts[3]}"
151		);
152		}
153		$parameter = $this->jsonFile[self::SWAGGER_COMPONENTS][self::SWAGGER_PARAMETERS][$paramParts[3]];
154		}
155	View Code Duplication	if ($parameter['in'] === $parameterIn &&
		0 ignored issues – show Duplication introduced 2019-03-18 04:09 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
156		$parameter['schema']['type'] === "integer"
157		&& filter_var($arguments[$parameter['name']], FILTER_VALIDATE_INT) === false) {
158		throw new NotMatchedException('Path expected an integer value');
159		}
160		}
161		return;
162		}
163
164		foreach ($parameters as $parameter) {
165	View Code Duplication	if ($parameter['in'] === $parameterIn
		0 ignored issues – show Duplication introduced 2019-03-18 04:09 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
166		&& $parameter['type'] === "integer"
167		&& filter_var($arguments[$parameter['name']], FILTER_VALIDATE_INT) === false) {
168		throw new NotMatchedException('Path expected an integer value');
169		}
170		}
171		}
172
173		/**
174		* @param $name
175		* @return mixed
176		* @throws DefinitionNotFoundException
177		* @throws InvalidDefinitionException
178		*/
179		public function getDefintion($name)
180		{
181		$nameParts = explode('/', $name);
182
183		if ($this->getSpecificationVersion() === '3') {
184	View Code Duplication	if (count($nameParts) < 4 \|\| $nameParts[0] !== '#') {
		0 ignored issues – show Duplication introduced 2019-03-06 08:04 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
185		throw new InvalidDefinitionException('Invalid Component');
186		}
187
188	View Code Duplication	if (!isset($this->jsonFile[$nameParts[1]][$nameParts[2]][$nameParts[3]])) {
		0 ignored issues – show Duplication introduced 2019-03-06 08:04 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
189		throw new DefinitionNotFoundException("Component'$name' not found");
190		}
191
192		return $this->jsonFile[$nameParts[1]][$nameParts[2]][$nameParts[3]];
193		}
194
195	View Code Duplication	if (count($nameParts) < 3 \|\| $nameParts[0] !== '#') {
		0 ignored issues – show Duplication introduced 2019-03-06 08:04 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
196		throw new InvalidDefinitionException('Invalid Definition');
197		}
198
199	View Code Duplication	if (!isset($this->jsonFile[$nameParts[1]][$nameParts[2]])) {
		0 ignored issues – show Duplication introduced 2019-03-06 08:04 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
200		throw new DefinitionNotFoundException("Definition '$name' not found");
201		}
202
203		return $this->jsonFile[$nameParts[1]][$nameParts[2]];
204		}
205
206		/**
207		* @param $path
208		* @param $method
209		* @return \ByJG\Swagger\SwaggerRequestBody
210		* @throws DefinitionNotFoundException
211		* @throws HttpMethodNotFoundException
212		* @throws InvalidDefinitionException
213		* @throws NotMatchedException
214		* @throws PathNotFoundException
215		*/
216		public function getRequestParameters($path, $method)
217		{
218		$structure = $this->getPathDefinition($path, $method);
219
220		if($this->getSpecificationVersion() === '3') {
221		if (!isset($structure['requestBody'])) {
222		return new SwaggerRequestBody($this, "$method $path", []);
223		}
224		return new SwaggerRequestBody($this, "$method $path", $structure['requestBody']);
225		}
226
227		if (!isset($structure[self::SWAGGER_PARAMETERS])) {
228		return new SwaggerRequestBody($this, "$method $path", []);
229		}
230		return new SwaggerRequestBody($this, "$method $path", $structure[self::SWAGGER_PARAMETERS]);
231		}
232
233		/**
234		* @param $path
235		* @param $method
236		* @param $status
237		* @return \ByJG\Swagger\SwaggerResponseBody
238		* @throws \ByJG\Swagger\Exception\HttpMethodNotFoundException
239		* @throws \ByJG\Swagger\Exception\InvalidDefinitionException
240		* @throws \ByJG\Swagger\Exception\NotMatchedException
241		* @throws \ByJG\Swagger\Exception\PathNotFoundException
242		* @throws DefinitionNotFoundException
243		*/
244		public function getResponseParameters($path, $method, $status)
245		{
246		$structure = $this->getPathDefinition($path, $method);
247
248		if (!isset($structure['responses'][$status])) {
249		throw new InvalidDefinitionException("Could not found status code '$status' in '$path' and '$method'");
250		}
251
252		return new SwaggerResponseBody($this, "$method $status $path", $structure['responses'][$status]);
253		}
254
255		/**
256		* OpenApi 2.0 doesn't describe null values, so this flag defines,
257		* if match is ok when one of property
258		*
259		* @return bool
260		*/
261		public function isAllowNullValues()
262		{
263		return $this->allowNullValues;
264		}
265
266		/**
267		* OpenApi 2.0 doesn't describe null values, so this flag defines,
268		* if match is ok when one of property
269		*
270		* @param $value
271		*/
272		public function setAllowNullValues($value)
273		{
274		$this->allowNullValues = (bool) $value;
275		}
276		}
277

byjg / php-swagger-test