SwaggerStrategy::resolveSchema() - Code Metrics - Inspection of "Merge branch 'release/0.41.0'" - libgraviton/graviton - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 798ee0...2329f6 )

by Lucas

created 2016-02-01 16:53 UTC

SwaggerStrategy::resolveSchema() C

↳ Parent: SwaggerStrategy

Complexity

Conditions	13
Paths	6

Size

Total Lines	29
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	20
CRAP Score	13.3747

Importance

Changes	2
Bugs	1	Features	0

Metric	Value
c	2
b	1
f	0
dl	0
loc	29
ccs	20
cts	23
cp	0.8696
rs	5.1234
cc	13
eloc	20
nc	6
nop	1
crap	13.3747

How to fix Complexity

<?php
/**
 * SwaggerStrategy
 */

namespace Graviton\ProxyBundle\Definition\Loader\DispersalStrategy;

use Graviton\ProxyBundle\Definition\ApiDefinition;
use Swagger\Document;
use Swagger\Exception\MissingDocumentPropertyException;
use Swagger\Object\AbstractObject;
use Swagger\Object\Parameter;
use Swagger\Object\Reference;
use Swagger\OperationReference;

/**
 * process a swagger.json file and return an APi definition
 *
 * @author  List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
 * @license http://opensource.org/licenses/gpl-license.php GNU Public License
 * @link    http://swisscom.ch
 */
class SwaggerStrategy implements DispersalStrategyInterface
{
    /**
     * @var array
     */
    private $fallbackData = [];

    /**
     *
     */
    private $document;

    /**
     * constructor
     *
     * @param Document $document Swagger document parser
     */
    public function __construct(Document $document)
    {
        $this->document = $document;
    }

    /**
     * process data
     *
     * @param string $input        JSON information about the swagger service.
     * @param array  $fallbackData Set of information to be registered in case the swagger info is not complete.
     *
     * @return ApiDefinition
     */
    public function process($input, array $fallbackData = [])
    {
        $this->registerFallbackData($fallbackData);
        $apiDef = new ApiDefinition();

        /**
         * @var \stdClass $swagger
         */
        $swagger = $this->decodeJson($input);
        if (is_object($swagger)) {
            $this->document->setDocument($swagger);
            $this->setBaseValues($apiDef);

            $operations = $this->document->getOperationsById();
            foreach ($operations as $service) {
                $path = $this->normalizePath($service->getPath());

                if (in_array(strtolower($service->getMethod()), ['delete', 'patch']) || $apiDef->hasEndpoint($path)) {
                    continue;
                }
                $apiDef->addEndpoint($path);
                $apiDef->addSchema(
                    $path,
                    $this->getServiceSchema($service)
                );
                $apiDef->setOrigin($this->document);
            }
        }

        return $apiDef;
    }

    /**
     * is input data valid json
     *
     * @param string $input json string
     *
     * @return boolean
     */
    public function supports($input)
    {
        /**
         * @var array $swagger
         */
        $swagger = $this->decodeJson($input, true);

        $mandatoryFields = ['swagger', 'info', 'paths', 'version', 'title', 'definitions'];
        $fields = array_merge(array_keys($swagger), array_keys($swagger['info']));
        $intersect = array_intersect($mandatoryFields, $fields);

        // every mandatory field was found in provided json definition.
        return empty(array_diff($mandatoryFields, $intersect));
    }

    /**
     * decode a json string
     *
     * @param string $input json string
     * @param bool   $assoc Force the encoded result to be a hash.
     *
     * @return array|\stdClass
     */
    private function decodeJson($input, $assoc = false)
    {
        $input = trim($input);

        return json_decode($input, $assoc);
    }

    /**
     * set base values
     *
     * @param ApiDefinition $apiDef API definition
     *
     * @return void
     */
    private function setBaseValues(ApiDefinition $apiDef)
    {
        $this->registerHost($apiDef);
        $basePath = $this->document->getBasePath();
        if (isset($basePath)) {
            $apiDef->setBasePath($basePath);
        }
    }

    /**
     * get the schema
     *
     * @param OperationReference $service service endpoint
     *
     * @return \stdClass
     */
    private function getServiceSchema($service)
    {
        $operation = $service->getOperation();
        $schema = new \stdClass();
        switch (strtolower($service->getMethod())) {
            case "post":
            case "put":
                try {
                    $parameters = $operation->getDocumentObjectProperty('parameters', Parameter\Body::class, true);
                } catch (MissingDocumentPropertyException $e) {
                    // request has no params
                    break;
                }
                foreach ($parameters as $parameter) {
                    /**
                     * there is no schema information available, if $action->parameters[0]->in != 'body'
                     *
                     * @link http://swagger.io/specification/#parameterObject
                     */
                    if ($parameter instanceof Parameter\Body && $parameter->getIn() === 'body') {
                        $ref = $parameter->getDocumentObjectProperty('schema', Reference::class)->getDocument();
                        $schema = $this->resolveSchema($ref);
                        break;
                    }
                }
                break;
            case "get":
                try {
                    $response = $operation->getResponses()->getHttpStatusCode(200);
                } catch (MissingDocumentPropertyException $e) {
                    // no response with status code 200 is defined
                    break;
                }
                $schema = $this->resolveSchema($response->getSchema()->getDocument());
                break;
        }

        return $schema;
    }

    /**
     * resolve schema
     *
     * @param \stdClass $reference reference
     *
     * @return \stdClass
     */
    private function resolveSchema($reference)
    {
        $schema = $reference;
        if (property_exists($reference, '$ref')) {
            $schemaResolver = $this->document->getSchemaResolver();
            $ref = new Reference($reference);
            $schema = $schemaResolver->resolveReference($ref)->getDocument();
        } elseif ($reference->type === 'array' && !empty($reference->items)) {
            $schema->items = $this->resolveSchema($reference->items);
        }

        // resolve properties
        if (!empty($schema->properties)) {
            $properties = (array) $schema->properties;
            foreach ($properties as $name => $property) {
                if (isset($property->type)
                    && $property->type === 'array'
                    && isset($property->items)
                    && property_exists($property->items, '$ref')
                    && !isset($schema->properties->$name->items)) {
                    $schema->properties->$name->items = $this->resolveSchema($property->items);
                } elseif (property_exists($property, '$ref') && !isset($schema->properties->$name)) {
                    $schema->properties->$name = $this->resolveSchema($property);
                }
            }
        }

        return $schema;
    }

    /**
     * Sets the destination host for the api definition.
     *
     * @param ApiDefinition $apiDef Configuration for the swagger api to be recognized.
     *
     * @return void
     */
    private function registerHost(ApiDefinition $apiDef)
    {
        try {
            $host = $this->document->getHost();
        } catch (MissingDocumentPropertyException $e) {
            $host = $this->fallbackData['host'];
        }
        $apiDef->setHost($host);
    }

    /**
     * Set of information to be used as default if not defined by the swagger configuration.
     *
     * @param array $fallbackData Set of default information (e.g. host)
     *
     * @return void
     */
    private function registerFallbackData(array $fallbackData)
    {
        if (!array_key_exists('host', $fallbackData)) {
            throw new \RuntimeException('Missing mandatory key (host) in fallback data set.');
        }

        $this->fallbackData = $fallbackData;
    }

    /**
     * Normalizes the provided path.
     *
     * The idea is to consolidate endpoints for GET requests.
     *
     * <code>
     *   /my/path/      » /my/path
     *   /my/path/{id}  » /my/path
     * </code>
     *
     * @param string $path path to be normalized
     *
     * @return string
     *
     * @todo: determine how to treat endpoints with a variable within the path: /my/path/{id}/special
     */
    private function normalizePath($path)
    {
        return preg_replace('@\/(\{[a-zA-Z]*\})?$@', '', $path);
    }
}


1		<?php
2		/**
3		* SwaggerStrategy
4		*/
5
6		namespace Graviton\ProxyBundle\Definition\Loader\DispersalStrategy;
7
8		use Graviton\ProxyBundle\Definition\ApiDefinition;
9		use Swagger\Document;
10		use Swagger\Exception\MissingDocumentPropertyException;
11		use Swagger\Object\AbstractObject;
12		use Swagger\Object\Parameter;
13		use Swagger\Object\Reference;
14		use Swagger\OperationReference;
15
16		/**
17		* process a swagger.json file and return an APi definition
18		*
19		* @author List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
20		* @license http://opensource.org/licenses/gpl-license.php GNU Public License
21		* @link http://swisscom.ch
22		*/
23		class SwaggerStrategy implements DispersalStrategyInterface
24		{
25		/**
26		* @var array
27		*/
28		private $fallbackData = [];
29
30		/**
31		*
32		*/
33		private $document;
34
35		/**
36		* constructor
37		*
38		* @param Document $document Swagger document parser
39		*/
40	4	public function __construct(Document $document)
41		{
42	4	$this->document = $document;
43	4	}
44
45		/**
46		* process data
47		*
48		* @param string $input JSON information about the swagger service.
49		* @param array $fallbackData Set of information to be registered in case the swagger info is not complete.
50		*
51		* @return ApiDefinition
52		*/
53	2	public function process($input, array $fallbackData = [])
54		{
55	2	$this->registerFallbackData($fallbackData);
56	1	$apiDef = new ApiDefinition();
57
58		/**
59		* @var \stdClass $swagger
60		*/
61	1	$swagger = $this->decodeJson($input);
62	1	if (is_object($swagger)) {
63	1	$this->document->setDocument($swagger);
64	1	$this->setBaseValues($apiDef);
65
66	1	$operations = $this->document->getOperationsById();
67	1	foreach ($operations as $service) {
68	1	$path = $this->normalizePath($service->getPath());
69
70	1	if (in_array(strtolower($service->getMethod()), ['delete', 'patch']) \|\| $apiDef->hasEndpoint($path)) {
71	1	continue;
72		}
73	1	$apiDef->addEndpoint($path);
74	1	$apiDef->addSchema(
75	1	$path,
76	1	$this->getServiceSchema($service)
77	1	);
78	1	$apiDef->setOrigin($this->document);
79	1	}
80	1	}
81
82	1	return $apiDef;
83		}
84
85		/**
86		* is input data valid json
87		*
88		* @param string $input json string
89		*
90		* @return boolean
91		*/
92	2	public function supports($input)
93		{
94		/**
95		* @var array $swagger
96		*/
97	2	$swagger = $this->decodeJson($input, true);
98
99	2	$mandatoryFields = ['swagger', 'info', 'paths', 'version', 'title', 'definitions'];
100	2	$fields = array_merge(array_keys($swagger), array_keys($swagger['info']));
101	2	$intersect = array_intersect($mandatoryFields, $fields);
102
103		// every mandatory field was found in provided json definition.
104	2	return empty(array_diff($mandatoryFields, $intersect));
105		}
106
107		/**
108		* decode a json string
109		*
110		* @param string $input json string
111		* @param bool $assoc Force the encoded result to be a hash.
112		*
113		* @return array\|\stdClass
114		*/
115	3	private function decodeJson($input, $assoc = false)
116		{
117	3	$input = trim($input);
118
119	3	return json_decode($input, $assoc);
120		}
121
122		/**
123		* set base values
124		*
125		* @param ApiDefinition $apiDef API definition
126		*
127		* @return void
128		*/
129	1	private function setBaseValues(ApiDefinition $apiDef)
130		{
131	1	$this->registerHost($apiDef);
132	1	$basePath = $this->document->getBasePath();
133	1	if (isset($basePath)) {
134		$apiDef->setBasePath($basePath);
135		}
136	1	}
137
138		/**
139		* get the schema
140		*
141		* @param OperationReference $service service endpoint
142		*
143		* @return \stdClass
144		*/
145	1	private function getServiceSchema($service)
146		{
147	1	$operation = $service->getOperation();
148	1	$schema = new \stdClass();
149	1	switch (strtolower($service->getMethod())) {
150	1	case "post":
151	1	case "put":
152		try {
153		$parameters = $operation->getDocumentObjectProperty('parameters', Parameter\Body::class, true);
154		} catch (MissingDocumentPropertyException $e) {
155		// request has no params
156		break;
157		}
158		foreach ($parameters as $parameter) {
159		/**
160		* there is no schema information available, if $action->parameters[0]->in != 'body'
161		*
162		* @link http://swagger.io/specification/#parameterObject
163		*/
164		if ($parameter instanceof Parameter\Body && $parameter->getIn() === 'body') {
165		$ref = $parameter->getDocumentObjectProperty('schema', Reference::class)->getDocument();
166		$schema = $this->resolveSchema($ref);
167		break;
168		}
169		}
170		break;
171	1	case "get":
172		try {
173	1	$response = $operation->getResponses()->getHttpStatusCode(200);
174	1	} catch (MissingDocumentPropertyException $e) {
175		// no response with status code 200 is defined
176		break;
177		}
178	1	$schema = $this->resolveSchema($response->getSchema()->getDocument());
179	1	break;
180	1	}
181
182	1	return $schema;
183		}
184
185		/**
186		* resolve schema
187		*
188		* @param \stdClass $reference reference
189		*
190		* @return \stdClass
191		*/
192	1	private function resolveSchema($reference)
193		{
194	1	$schema = $reference;
195	1	if (property_exists($reference, '$ref')) {
196	1	$schemaResolver = $this->document->getSchemaResolver();
197	1	$ref = new Reference($reference);
198	1	$schema = $schemaResolver->resolveReference($ref)->getDocument();
199	1	} elseif ($reference->type === 'array' && !empty($reference->items)) {
200		$schema->items = $this->resolveSchema($reference->items);
201		}
202
203		// resolve properties
204	1	if (!empty($schema->properties)) {
205	1	$properties = (array) $schema->properties;
206	1	foreach ($properties as $name => $property) {
207	1	if (isset($property->type)
208	1	&& $property->type === 'array'
209	1	&& isset($property->items)
210	1	&& property_exists($property->items, '$ref')
211		&& !isset($schema->properties->$name->items)) {
212	1	$schema->properties->$name->items = $this->resolveSchema($property->items);
213	1	} elseif (property_exists($property, '$ref') && !isset($schema->properties->$name)) {
214	1	$schema->properties->$name = $this->resolveSchema($property);
215	1	}
216	1	}
217		}
218	1
219		return $schema;
220		}
221
222		/**
223		* Sets the destination host for the api definition.
224		*
225		* @param ApiDefinition $apiDef Configuration for the swagger api to be recognized.
226		*
227		* @return void
228	1	*/
229		private function registerHost(ApiDefinition $apiDef)
230		{
231	1	try {
232	1	$host = $this->document->getHost();
233	1	} catch (MissingDocumentPropertyException $e) {
234		$host = $this->fallbackData['host'];
235	1	}
236	1	$apiDef->setHost($host);
237		}
238
239		/**
240		* Set of information to be used as default if not defined by the swagger configuration.
241		*
242		* @param array $fallbackData Set of default information (e.g. host)
243		*
244		* @return void
245	2	*/
246		private function registerFallbackData(array $fallbackData)
247	2	{
248	1	if (!array_key_exists('host', $fallbackData)) {
249		throw new \RuntimeException('Missing mandatory key (host) in fallback data set.');
250		}
251	1
252	1	$this->fallbackData = $fallbackData;
253		}
254
255		/**
256		* Normalizes the provided path.
257		*
258		* The idea is to consolidate endpoints for GET requests.
259		*
260		* <code>
261		* /my/path/ » /my/path
262		* /my/path/{id} » /my/path
263		* </code>
264		*
265		* @param string $path path to be normalized
266		*
267		* @return string
268		*
269		* @todo: determine how to treat endpoints with a variable within the path: /my/path/{id}/special
270	1	*/
271		private function normalizePath($path)
272	1	{
273		return preg_replace('@\/(\{[a-zA-Z]*\})?$@', '', $path);
274		}
275		}
276

libgraviton / graviton

Push — master ( 798ee0...2329f6 )

SwaggerStrategy::resolveSchema() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like