SchemaBuilder::buildPropertySchema() - Code Metrics - Inspection of "[OpenAPI] Extract the JSON Schema builder" - api-platform/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#2983)

by Kévin
created 2019-08-14 19:32 UTC
SchemaBuilder::buildPropertySchema() F

↳ Parent: SchemaBuilder
Complexity

Conditions	13
Paths	576
Size

Total Lines	56
Code Lines	36
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	13
eloc	36
c	0
b	0
f	0
nc	576
nop	6
dl	0
loc	56
rs	3.0388
How to fix Long Method Complexity

<?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.
 */

declare(strict_types=1);

namespace ApiPlatform\Core\JsonSchema;

use ApiPlatform\Core\Exception\ResourceClassNotFoundException;
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\ResourceMetadata;
use ApiPlatform\Core\Swagger\Serializer\DocumentationNormalizer;
use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;

/**
 * Builds an OpenAPI Schema, an extended subset of the JSON Schema Specification.
 *
 * @see https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#schema-object
 * @see https://tools.ietf.org/html/draft-wright-json-schema-01
 *
 * @author Kévin Dunglas <[email protected]>
 */
final class SchemaBuilder
{
    use TypeResolverTrait;

    private $resourceMetadataFactory;
    private $propertyNameCollectionFactory;
    private $propertyMetadataFactory;
    private $nameConverter;

    public function __construct(ResourceMetadataFactoryInterface $resourceMetadataFactory, PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, PropertyMetadataFactoryInterface $propertyMetadataFactory, NameConverterInterface $nameConverter = null)
    {
        $this->resourceMetadataFactory = $resourceMetadataFactory;
        $this->propertyNameCollectionFactory = $propertyNameCollectionFactory;
        $this->propertyMetadataFactory = $propertyMetadataFactory;
        $this->nameConverter = $nameConverter;
    }

    /**
     * @throws ResourceClassNotFoundException
     */
    public function buildSchema(string $resourceClass, string $format = 'json', bool $output = true, ?string $operationType = null, ?string $operationName = null, ?Schema $baseSchema = null, ?array $serializerContext = null): Schema
    {
        if (null === $metadata = $this->getMetadata($resourceClass, $output, $operationType, $operationName, $serializerContext)) {
            return $baseSchema ?? new Schema();
        }

        [$resourceMetadata, $serializerContext, $inputOrOutputClass] = $metadata;

        $definitionName = $this->buildDefinitionName($resourceClass, $format, $output, $operationType, $operationName, $serializerContext);
        if (null === $baseSchema || null === $rootDefinitionName = $baseSchema->getRootDefinitionId()) {
            $rootDefinitionName = $definitionName;
        }

        if ($baseSchema) {
            $version = $baseSchema->getVersion();
            $schema = new Schema($version, $baseSchema->getSchema(), $rootDefinitionName, $baseSchema->getDefinitions());
        } else {
            $version = Schema::VERSION_JSON_SCHEMA;
            $schema = new Schema($version, null, $rootDefinitionName);
        }

        $definitions = $schema->getDefinitions();
        if (isset($definitions[$definitionName])) {
            // Already computed
            return $schema;
        }

        $definition = new \ArrayObject(['type' => 'object']);
        $definitions[$definitionName] = $definition;
        if (null !== $description = $resourceMetadata->getDescription()) {
            $definition['description'] = $description;
        }
        // see https://github.com/json-schema-org/json-schema-spec/pull/737
        if (
            (null !== $operationType && null !== $operationName && null !== $resourceMetadata->getTypedOperationAttribute($operationType, $operationName, 'deprecation_reason', null, true)) ||
            null !== $resourceMetadata->getAttribute('deprecation_reason', null)
        ) {
            $definition['deprecated'] = true;
        }
        // externalDocs is an OpenAPI specific extension, but JSON Schema allows additional keys, so we always add it
        // See https://json-schema.org/latest/json-schema-core.html#rfc.section.6.4
        if (null !== $iri = $resourceMetadata->getIri()) {
            $definition['externalDocs'] = ['url' => $iri];
        }

        $options = isset($serializerContext[AbstractNormalizer::GROUPS]) ? ['serializer_groups' => $serializerContext[AbstractNormalizer::GROUPS]] : [];
        foreach ($this->propertyNameCollectionFactory->create($inputOrOutputClass, $options) as $propertyName) {
            $propertyMetadata = $this->propertyMetadataFactory->create($inputOrOutputClass, $propertyName);
            if (!$propertyMetadata->isReadable() && !$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;
            }

            $normalizedPropertyName = $this->nameConverter ? $this->nameConverter->normalize($propertyName, $inputOrOutputClass, $format, $serializerContext) : $propertyName;
            $normalizedPropertyName = $this->nameConverter ? $this->nameConverter->/** @scrutinizer ignore-call */ normalize($propertyName, $inputOrOutputClass, $format, $serializerContext) : $propertyName;
            if ($propertyMetadata->isRequired()) {
                $definition['required'][] = $normalizedPropertyName;
            }

            $this->buildPropertySchema($schema, $definitionName, $normalizedPropertyName, $propertyMetadata, $serializerContext, $format);
        }

        return $schema;
    }

    private function buildPropertySchema(Schema $schema, string $definitionName, string $normalizedPropertyName, PropertyMetadata $propertyMetadata, array $serializerContext, string $format): void
    {
        $version = $schema->getVersion();
        switch ($version) {
            case Schema::VERSION_SWAGGER:
                $basePropertySchemaAttribute = 'swagger_context';
                break;
            case Schema::VERSION_OPENAPI:
                $basePropertySchemaAttribute = 'openapi_context';
                break;
            default:
                $basePropertySchemaAttribute = 'json_schema_context';
        }

        $propertySchema = $propertyMetadata->getAttributes()[$basePropertySchemaAttribute] ?? [];
        if (false === $propertyMetadata->isWritable() && !$propertyMetadata->isInitializable()) {
$a = canBeFalseAndNull();

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

// Better use one of the explicit versions:
if ($a !== null) { }
if ($a !== false) { }
if ($a !== null && $a !== false) { }
            $propertySchema['readOnly'] = true;
        }
        if (false === $propertyMetadata->isReadable()) {
            $propertySchema['writeOnly'] = true;
        }
        if (null !== $description = $propertyMetadata->getDescription()) {
            $propertySchema['description'] = $description;
        }
        // see https://github.com/json-schema-org/json-schema-spec/pull/737
        if (null !== $propertyMetadata->getAttribute('deprecation_reason')) {
            $propertySchema['deprecated'] = true;
        }
        // externalDocs is an OpenAPI specific extension, but JSON Schema allows additional keys, so we always add it
        // See https://json-schema.org/latest/json-schema-core.html#rfc.section.6.4
        if (null !== $iri = $propertyMetadata->getIri()) {
            $propertySchema['externalDocs'] = ['url' => $iri];
        }

        $valueSchema = [];
        if (null !== $type = $propertyMetadata->getType()) {
            $isCollection = $type->isCollection();
            if (null === $valueType = $isCollection ? $type->getCollectionValueType() : $type) {
                $builtinType = 'string';
                $className = null;
            } else {
                $builtinType = $valueType->getBuiltinType();
                $className = $valueType->getClassName();
            }

            $valueSchema = $this->getType($builtinType, $isCollection, $className, $format, $propertyMetadata->isReadableLink(), $serializerContext, $schema);
        }

        $propertySchema = new \ArrayObject($propertySchema + $valueSchema);
        if (DocumentationNormalizer::OPENAPI_VERSION === $version) {
            $schema['components']['schemas'][$definitionName]['properties'][$normalizedPropertyName] = $propertySchema;

            return;
        }

        $schema->getDefinitions()[$definitionName]['properties'][$normalizedPropertyName] = $propertySchema;
    }

    private function buildDefinitionName(string $resourceClass, string $format = 'json', bool $output = true, ?string $operationType = null, ?string $operationName = null, ?array $serializerContext = null, string $version = DocumentationNormalizer::OPENAPI_VERSION): ?string
    private function buildDefinitionName(string $resourceClass, string $format = 'json', bool $output = true, ?string $operationType = null, ?string $operationName = null, ?array $serializerContext = null, /** @scrutinizer ignore-unused */ string $version = DocumentationNormalizer::OPENAPI_VERSION): ?string
    {
        if (null === $metadata = $this->getMetadata($resourceClass, $output, $operationType, $operationName, $serializerContext)) {
            return null;
        }
        [$resourceMetadata, $serializerContext, $inputOrOutputClass] = $metadata;

        $prefix = $resourceMetadata->getShortName();
        if (null !== $inputOrOutputClass && $resourceClass !== $inputOrOutputClass) {
            $prefix .= ':'.md5($inputOrOutputClass);
        }

        if ('json' !== $format) {
            // We don't include JSON in the definition name because:
            // * it necessary to preserve backward compatibility with Swagger\DocumentationNormalizer's generated names
            // * it's the default (so it's useless)
            $prefix .= ':'.$format;
        }

        if (isset($serializerContext[DocumentationNormalizer::SWAGGER_DEFINITION_NAME])) {
            $name = sprintf('%s-%s', $prefix, $serializerContext[DocumentationNormalizer::SWAGGER_DEFINITION_NAME]);
        } else {
            $groups = (array) ($serializerContext[AbstractNormalizer::GROUPS] ?? []);
            $name = $groups ? sprintf('%s-%s', $prefix, implode('_', $groups)) : $prefix;

        }

        return $name;
    }

    private function getMetadata(string $resourceClass, bool $output, ?string $operationType, ?string $operationName, ?array $serializerContext): ?array
    {
        $resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);
        $attribute = $output ? 'output' : 'input';
        if (null === $operationType || null === $operationName) {
            $inputOrOutput = $resourceMetadata->getAttribute($attribute, ['class' => $resourceClass]);
        } else {
            $inputOrOutput = $resourceMetadata->getTypedOperationAttribute($operationType, $operationName, $attribute, ['class' => $resourceClass], true);
        }

        if (null === ($inputOrOutput['class'] ?? null)) {
            // input or output disabled
            return null;
        }

        return [
            $resourceMetadata,
            $serializerContext ?? $this->getSerializerContext($resourceMetadata, $output, $operationType, $operationName),
            $inputOrOutput['class'],
        ];
    }

    private function getSerializerContext(ResourceMetadata $resourceMetadata, bool $output, ?string $operationType, ?string $operationName): array
    {
        $attribute = $output ? 'normalization_context' : 'denormalization_context';

        if (null === $operationType || null === $operationName) {
            return $resourceMetadata->getAttribute($attribute, []);
        }

        return $resourceMetadata->getTypedOperationAttribute($operationType, $operationName, $attribute, [], true);
    }
}

api-platform / core

Pull Request — master (#2983)

SchemaBuilder::buildPropertySchema() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
