ApiDocumentationBuilder - Code Metrics - Inspection of "[WIP] feat: swagger v2" - api-platform/core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#591)

by Amrouche

created 2016-07-04 12:37 UTC

ApiDocumentationBuilder B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	266
Duplicated Lines	34.21 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes

Metric	Value
wmc	48
lcom	1
cbo	11
dl	91
loc	266
rs	8.4864
c	0
b	0
f	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	14	14	1
F	getApiDocumentation()	8	100	17
C	getSwaggerOperation()	26	78	18
C	getRange()	43	43	12

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 ApiDocumentationBuilder 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 ApiDocumentationBuilder, and based on these observations, apply Extract Interface, too.

<?php

/*
 * This file is part of the API Platform project.
 *
 * (c) Kévin Dunglas <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ApiPlatform\Core\Swagger;

use ApiPlatform\Core\Api\IriConverterInterface;
use ApiPlatform\Core\Api\OperationMethodResolverInterface;
use ApiPlatform\Core\Api\ResourceClassResolverInterface;
use ApiPlatform\Core\Api\UrlGeneratorInterface;
use ApiPlatform\Core\Exception\InvalidArgumentException;
use ApiPlatform\Core\JsonLd\ContextBuilderInterface;
use ApiPlatform\Core\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
use ApiPlatform\Core\Metadata\Property\Factory\PropertyNameCollectionFactoryInterface;
use ApiPlatform\Core\Metadata\Property\PropertyMetadata;
use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
use ApiPlatform\Core\Metadata\Resource\Factory\ResourceNameCollectionFactoryInterface;
use ApiPlatform\Core\Metadata\Resource\ResourceMetadata;
use ApiPlatform\Core\Documentation\ApiDocumentationBuilderInterface;
use Symfony\Component\PropertyInfo\Type;

/**
 * Creates a machine readable Swagger API documentation.
 *
 * @author Kévin Dunglas <[email protected]>
 */
final class ApiDocumentationBuilder implements ApiDocumentationBuilderInterface
{
    private $resourceNameCollectionFactory;
    private $resourceMetadataFactory;
    private $propertyNameCollectionFactory;
    private $propertyMetadataFactory;
    private $contextBuilder;
    private $resourceClassResolver;
    private $operationMethodResolver;
    private $urlGenerator;
    private $title;
    private $description;
    private $iriConverter;

    public function __construct(ResourceNameCollectionFactoryInterface $resourceNameCollectionFactory, ResourceMetadataFactoryInterface $resourceMetadataFactory, PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, PropertyMetadataFactoryInterface $propertyMetadataFactory, ContextBuilderInterface $contextBuilder, ResourceClassResolverInterface $resourceClassResolver, OperationMethodResolverInterface $operationMethodResolver, UrlGeneratorInterface $urlGenerator, IriConverterInterface $iriConverter, string $title = '', string $description = '')

    {
        $this->resourceNameCollectionFactory = $resourceNameCollectionFactory;
        $this->resourceMetadataFactory = $resourceMetadataFactory;
        $this->propertyNameCollectionFactory = $propertyNameCollectionFactory;
        $this->propertyMetadataFactory = $propertyMetadataFactory;
        $this->contextBuilder = $contextBuilder;
        $this->resourceClassResolver = $resourceClassResolver;
        $this->operationMethodResolver = $operationMethodResolver;
        $this->urlGenerator = $urlGenerator;
        $this->title = $title;
        $this->description = $description;
        $this->iriConverter = $iriConverter;
    }

    /**
     * {@inheritdoc}
     */
    public function getApiDocumentation()
    {
        $classes = [];
        $itemOperations = [];
        $itemOperationsDocs = [];
        $properties = [];

        foreach ($this->resourceNameCollectionFactory->create() as $resourceClass) {
            $resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);

            $shortName = $resourceMetadata->getShortName();
            $prefixedShortName = ($iri = $resourceMetadata->getIri()) ? $iri : '#'.$shortName;

            $class = [
                'name' => $shortName,
                'externalDocs' => [
                    'url' => $prefixedShortName,
                ],
            ];

            if ($description = $resourceMetadata->getDescription()) {
                $class = [
                    'name' => $shortName,
                    'description' => $description,
                    'externalDocs' => [
                        'url' => $prefixedShortName,
                    ],
                ];
            }

            $attributes = $resourceMetadata->getAttributes();
            $context = [];

            if (isset($attributes['normalization_context']['groups'])) {
                $context['serializer_groups'] = $attributes['normalization_context']['groups'];
            }

            if (isset($attributes['denormalization_context']['groups'])) {

                $context['serializer_groups'] = isset($context['serializer_groups']) ? array_merge($context['serializer_groups'], $attributes['denormalization_context']['groups']) : $context['serializer_groups'];
            }

            foreach ($this->propertyNameCollectionFactory->create($resourceClass, $context) as $propertyName) {
                $propertyMetadata = $this->propertyMetadataFactory->create($resourceClass, $propertyName);

                if ($propertyMetadata->isIdentifier() && !$propertyMetadata->isWritable()) {
$a = canBeFalseAndNull();

// Instead of
if ( ! $a) { }

// Better use one of the explicit versions:
if ($a !== null) { }
if ($a !== false) { }
if ($a !== null && $a !== false) { }
                    continue;
                }

                $property[$propertyName] = [
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
                    'type' => $this->getRange($propertyMetadata),
                ];

                $required = [];

                if ($propertyMetadata->isRequired()) {
                    $required = array_merge($required, [$propertyName]);
                }

                if (0 !== count($required)) {
                    $properties[$shortName]['required'] = $required;
                }

                $properties[$shortName]['type'] = 'object';
                $properties[$shortName]['properties'] = $property;
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            }

            if ($operations = $resourceMetadata->getItemOperations()) {

                foreach ($operations as $operationName => $itemOperation) {
                    $itemOperations = array_merge($itemOperations, $this->getSwaggerOperation($resourceClass, $resourceMetadata, $operationName, $itemOperation, $prefixedShortName, false));
                }
            }
            
            try {
                $resourceClassIri = $this->iriConverter->getIriFromResourceClass($resourceClass);
            } catch (InvalidArgumentException $e) {
                $resourceClassIri = strtolower($resourceClass);
            }
            
            $itemOperationsDocs[$resourceClassIri] = $itemOperations;
            $classes[] = $class;
        }

        $doc['swagger'] = '2.0';
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
        if ('' !== $this->title) {
            $doc['info']['title'] = $this->title;
        }

        if ('' !== $this->description) {
            $doc['info']['description'] = $this->description;
        }
        $doc['host'] = $this->urlGenerator->generate('api_jsonld_entrypoint');
        $doc['basePath'] = $this->urlGenerator->generate('api_jsonld_entrypoint');
        $doc['definitions'] = $properties;
        $doc['externalDocs'] = ['description' => 'Find more about api-platform', 'url' => 'docs'];
        $doc['tags'] = $classes;
        $doc['schemes'] = ['http']; // more schema ?
        $doc['paths'] = $itemOperationsDocs;

        return $doc;
    }

    /**
     * Gets and populates if applicable a Swagger operation.
     */
    private function getSwaggerOperation(string $resourceClass, ResourceMetadata $resourceMetadata, string $operationName, array $operation, string $prefixedShortName, bool $collection) : array
    {
        if ($collection) {

            $method = $this->operationMethodResolver->getCollectionOperationMethod($resourceClass, $operationName);
        } else {
            $method = $this->operationMethodResolver->getItemOperationMethod($resourceClass, $operationName);
        }

        $methodSwagger = strtolower($method);
        $swaggerOperation = $operation['swagger_context'] ?? [];
        $shortName = $resourceMetadata->getShortName();
        $swaggerOperation[$methodSwagger] = [];
        $swaggerOperation[$methodSwagger]['tags'] = [$shortName];
        $swaggerOperation[$methodSwagger]['produces'] = ['application/json'];
        $swaggerOperation[$methodSwagger]['consumes'] = $swaggerOperation[$methodSwagger]['produces'];
        switch ($method) {
            case 'GET':
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B": //right
        doSomething();
        break;
}
                if ($collection) {
                    if (!isset($swaggerOperation[$methodSwagger]['title'])) {

                        $swaggerOperation[$methodSwagger]['summary'] = sprintf('Retrieves the collection of %s resources.', $shortName);
                    }
                } else {
                    if (!isset($swaggerOperation[$methodSwagger]['title'])) {

                        $swaggerOperation[$methodSwagger]['summary'] = sprintf('Retrieves %s resource.', $shortName);
                    }
                    $swaggerOperation[$methodSwagger]['parameters'] = [
                        'name' => 'id',
                        'in' => 'path',
                        'required' => true,
                        'type' => 'integer',
                    ];
                }
            break;

            case 'POST':
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B": //right
        doSomething();
        break;
}
                if (!isset($swaggerOperation[$methodSwagger]['title'])) {

                    $swaggerOperation[$methodSwagger]['summary'] = sprintf('Creates a %s resource.', $shortName);
                }
                $swaggerOperation[$methodSwagger]['parameters'] = [
                    'in' => 'body',
                    'name' => 'body',
                    'description' => sprintf('%s resource to be added', $shortName),
                    'schema' => [
                        '$ref' => sprintf('%/definitions/%s', $shortName),
                    ],
                ];
                    $swaggerOperation[$methodSwagger]['responses'] = [
                        '400' => 'Valid ID',
                    ];

            break;

            case 'PUT':
                if (!isset($swaggerOperation[$methodSwagger]['title'])) {

                    $swaggerOperation[$methodSwagger]['summary'] = sprintf('Replaces the %s resource.', $shortName);
                }
                break;
        }

        if (!isset($swaggerOperation[$methodSwagger]['returns']) &&

            (
                ('GET' === $method && !$collection) ||
                'POST' === $method ||
                'PUT' === $method
            )
        ) {
            $swaggerOperation[$methodSwagger]['returns'] = $prefixedShortName;
        }

        if (!isset($swaggerOperation[$methodSwagger]['expects']) &&
            ('POST' === $method || 'PUT' === $method)) {
            $swaggerOperation[$methodSwagger]['expects'] = $prefixedShortName;
        }

        ksort($swaggerOperation);

        return $swaggerOperation;
    }

    /**
     * Gets the range of the property.
     *
     * @param PropertyMetadata $propertyMetadata
     *
     * @return string|null
     */
    private function getRange(PropertyMetadata $propertyMetadata)

    {
        $type = $propertyMetadata->getType();
        if (!$type) {
            return;
        }

        if ($type->isCollection() && $collectionType = $type->getCollectionValueType()) {
            $type = $collectionType;
        }

        switch ($type->getBuiltinType()) {
            case Type::BUILTIN_TYPE_STRING:
                return 'string';

            case Type::BUILTIN_TYPE_INT:
                return 'integer';

            case Type::BUILTIN_TYPE_FLOAT:
                return 'number';

            case Type::BUILTIN_TYPE_BOOL:
                return 'boolean';

            case Type::BUILTIN_TYPE_OBJECT:
                $className = $type->getClassName();

                if ($className) {
                    if (is_subclass_of($className, \DateTimeInterface::class)) {

                        return 'string';
                    }

                    $className = $type->getClassName();
                    if ($this->resourceClassResolver->isResourceClass($className)) {
                        return ['$ref' => sprintf('#/definitions/%s', $this->resourceMetadataFactory->create($className)->getShortName())];
                    }
                }
            break;
            default:
                return 'null';
            break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
        }
    }
}


api-platform / core