ItemNormalizer::getComponents() - Code Metrics - Inspection of "Add JSON API basic support" - api-platform/core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1036)

by Hector

created 2017-04-19 00:35 UTC

ItemNormalizer::getComponents() C

↳ Parent: ItemNormalizer

Complexity

Conditions	13
Paths	35

Size

Total Lines	68
Code Lines	42

Duplication

Lines	7
Ratio	10.29 %

Importance

Changes

Metric	Value
dl	7
loc	68
rs	5.761
c	0
b	0
f	0
cc	13
eloc	42
nc	35
nop	3

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\JsonApi\Serializer;

use ApiPlatform\Core\Api\IriConverterInterface;
use ApiPlatform\Core\Api\ResourceClassResolverInterface;
use ApiPlatform\Core\DataProvider\ItemDataProviderInterface;
use ApiPlatform\Core\Exception\InvalidArgumentException;
use ApiPlatform\Core\Exception\RuntimeException;
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\Serializer\AbstractItemNormalizer;
use ApiPlatform\Core\Serializer\ContextTrait;
use ApiPlatform\Core\Util\ClassInfoTrait;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
use Symfony\Component\Serializer\NameConverter\NameConverterInterface;

/**
 * Converts between objects and array.
 *
 * @author Kévin Dunglas <[email protected]>
 * @author Amrouche Hamza <[email protected]>
 */
final class ItemNormalizer extends AbstractItemNormalizer
{
    use ContextTrait;
    use ClassInfoTrait;

    const FORMAT = 'jsonapi';

    private $componentsCache = [];

    private $resourceMetadataFactory;

    private $itemDataProvider;

    public function __construct(

        PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory,
        PropertyMetadataFactoryInterface $propertyMetadataFactory,
        IriConverterInterface $iriConverter,
        ResourceClassResolverInterface $resourceClassResolver,
        PropertyAccessorInterface $propertyAccessor = null,
        NameConverterInterface $nameConverter = null,
        ResourceMetadataFactoryInterface $resourceMetadataFactory,
        ItemDataProviderInterface $itemDataProvider
    ) {
        parent::__construct(
            $propertyNameCollectionFactory,
            $propertyMetadataFactory,
            $iriConverter,
            $resourceClassResolver,
            $propertyAccessor,
            $nameConverter
        );

        $this->resourceMetadataFactory = $resourceMetadataFactory;
        $this->itemDataProvider = $itemDataProvider;
    }

    /**
     * {@inheritdoc}
     */
    public function supportsNormalization($data, $format = null)
    {
        return self::FORMAT === $format && parent::supportsNormalization($data, $format);
    }

    /**
     * {@inheritdoc}
     */
    public function normalize($object, $format = null, array $context = [])
    {
        $context['cache_key'] = $this->getCacheKey($format, $context);

        // Get and populate attributes data
        $objectAttributesData = parent::normalize($object, $format, $context);

        if (!is_array($objectAttributesData)) {
            return $objectAttributesData;
        }

        // Get and populate identifier if existent
        $identifier = $this->getIdentifierFromItem($object);

        // Get and populate item type
        $resourceClass = $this->resourceClassResolver->getResourceClass(
            $object,
            $context['resource_class'] ?? null,
            true
        );
        $resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);

        // Get and populate relations
        $components = $this->getComponents($object, $format, $context);
        $objectRelationshipsData = $this->getPopulatedRelations(
            $object,
            $format,
            $context,
            $components
        );

        $item = [
            // The id attribute must be a string
            // See: http://jsonapi.org/format/#document-resource-object-identification
            'id' => (string) $identifier,
            'type' => $resourceMetadata->getShortName(),
        ];

        if ($objectAttributesData) {

            $item['attributes'] = $objectAttributesData;
        }

        if ($objectRelationshipsData) {

            $item['relationships'] = $objectRelationshipsData;
        }

        return ['data' => $item];
    }

    /**
     * {@inheritdoc}
     */
    public function supportsDenormalization($data, $type, $format = null)
    {
        return self::FORMAT === $format && parent::supportsDenormalization($data, $type, $format);
    }

    /**
     * {@inheritdoc}
     */
    public function denormalize($data, $class, $format = null, array $context = [])
    {
        // Avoid issues with proxies if we populated the object
        if (isset($data['data']['id']) && !isset($context['object_to_populate'])) {

            if (isset($context['api_allow_update']) && true !== $context['api_allow_update']) {
                throw new InvalidArgumentException('Update is not allowed for this operation.');
            }

            $context['object_to_populate'] = $this->iriConverter->getItemFromIri(
                $data['data']['id'],
                $context + ['fetch_data' => false]
            );
        }

        // Merge attributes and relations previous to apply parents denormalizing
        $dataToDenormalize = array_merge(
            $data['data']['attributes'] ?? [],
            $data['data']['relationships'] ?? []
        );

        return parent::denormalize(
            $dataToDenormalize,
            $class,
            $format,
            $context
        );
    }

    /**
     * {@inheritdoc}
     */
    protected function getAttributes($object, $format, array $context)
    {
        return $this->getComponents($object, $format, $context)['attributes'];
    }

    /**
     * Gets JSON API components of the resource: attributes, relationships, meta and links.
     *
     * @param object      $object
     * @param string|null $format
     * @param array       $context
     *
     * @return array
     */
    private function getComponents($object, string $format = null, array $context)
    {
        if (isset($this->componentsCache[$context['cache_key']])) {
            return $this->componentsCache[$context['cache_key']];
        }

        $attributes = parent::getAttributes($object, $format, $context);
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}

        $options = $this->getFactoryOptions($context);

        $typeShortName = $className = '';

        $components = [
            'links' => [],
            'relationships' => [],
            'attributes' => [],
            'meta' => [],
        ];

        foreach ($attributes as $attribute) {
            $propertyMetadata = $this
                ->propertyMetadataFactory
                ->create($context['resource_class'], $attribute, $options);

            $type = $propertyMetadata->getType();
            $isOne = $isMany = false;

            if (null !== $type) {
                if ($type->isCollection()) {

                    $valueType = $type->getCollectionValueType();

                    $isMany = null !== $valueType
                        && ($className = $valueType->getClassName())
                        && $this->resourceClassResolver->isResourceClass($className);
                } else {
                    $className = $type->getClassName();

                    $isOne = null !== $className
                        && $this->resourceClassResolver->isResourceClass($className);
                }

                $typeShortName = '';

                if ($className && $this->resourceClassResolver->isResourceClass($className)) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                    $typeShortName = $this
                        ->resourceMetadataFactory
                        ->create($className)
                        ->getShortName();
                }
            }

            if (!$isOne && !$isMany) {
                $components['attributes'][] = $attribute;

                continue;
            }

            $relation = [
                'name' => $attribute,
                'type' => $typeShortName,
                'cardinality' => $isOne ? 'one' : 'many',
            ];

            $components['relationships'][] = $relation;
        }

        return $this->componentsCache[$context['cache_key']] = $components;
    }

    /**
     * Populates links and relationships keys.
     *
     * @param array       $data
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param object      $object
     * @param string|null $format
     * @param array       $context
     * @param array       $components
     * @param string      $type
     *
     * @return array
     */
    private function getPopulatedRelations(
        $object,
        string $format = null,
        array $context,
        array $components,
        string $type = 'relationships'
    ): array {
        $data = [];

        $identifier = '';
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        foreach ($components[$type] as $relationshipDataArray) {
            $relationshipName = $relationshipDataArray['name'];

            $attributeValue = $this->getAttributeValue(
                $object,
                $relationshipName,
                $format,
                $context
            );

            if ($this->nameConverter) {
                $relationshipName = $this->nameConverter->normalize($relationshipName);
            }

            if (!$attributeValue) {
                continue;
            }

            $data[$relationshipName] = [
                'data' => [],
            ];

            // Many to one relationship
            if ('one' === $relationshipDataArray['cardinality']) {
                $data[$relationshipName] = $attributeValue;

                continue;
            }

            // Many to many relationship
            foreach ($attributeValue as $attributeValueElement) {
                if (!isset($attributeValueElement['data'])) {
                    throw new RuntimeException(sprintf(
                        'Expected \'data\' attribute in collection for attribute \'%s\'',
                        $relationshipName
                    ));
                }

                $data[$relationshipName]['data'][] = $attributeValueElement['data'];
            }
        }

        return $data;
    }

    /**
     * Gets the IRI of the given relation.
     *
     * @param array|string $rel
     *
     * @return string
     */
    private function getRelationIri($rel): string
    {
        return $rel['links']['self'] ?? $rel;
    }

    /**
     * Gets the cache key to use.
     *
     * @param string|null $format
     * @param array       $context
     *
     * @return bool|string
     */
    private function getCacheKey(string $format = null, array $context)

    {
        try {
            return md5($format.serialize($context));
        } catch (\Exception $exception) {
            // The context cannot be serialized, skip the cache
            return false;
        }
    }

    /**
     * Denormalizes a resource linkage relation.
     *
     * See: http://jsonapi.org/format/#document-resource-object-linkage
     *
     * @param string           $attributeName    [description]
     * @param PropertyMetadata $propertyMetadata [description]
     * @param string           $className        [description]
     * @param [type]           $data             [description]

     * @param string|null      $format           [description]
     * @param array            $context          [description]
     *
     * @return [type] [description]

     */
    protected function denormalizeRelation(
        string $attributeName,
        PropertyMetadata $propertyMetadata,
        string $className,
        $data,
        string $format = null,
        array $context
    ) {
        // Null is allowed for empty to-one relationships, see
        // http://jsonapi.org/format/#document-resource-object-linkage
        if (null === $data['data']) {
            return;
        }

        // An empty array is allowed for empty to-many relationships, see
        // http://jsonapi.org/format/#document-resource-object-linkage
        if ([] === $data['data']) {
            return;
        }

        if (!isset($data['data'])) {
            throw new InvalidArgumentException(
                'Key \'data\' expected. Only resource linkage currently supported, see: http://jsonapi.org/format/#document-resource-object-linkage'
            );
        }

        $data = $data['data'];

        if (!is_array($data) || 2 !== count($data)) {
            throw new InvalidArgumentException(
                'Only resource linkage supported currently supported, see: http://jsonapi.org/format/#document-resource-object-linkage'
            );
        }

        if (!isset($data['id'])) {
            throw new InvalidArgumentException(
                'Only resource linkage supported currently supported, see: http://jsonapi.org/format/#document-resource-object-linkage'
            );
        }

        return $this->itemDataProvider->getItem(
            $this->resourceClassResolver->getResourceClass(null, $className),
            $data['id']
        );
    }

    /**
     * Normalizes a relation as resource linkage relation.
     *
     * See: http://jsonapi.org/format/#document-resource-object-linkage
     *
     * For example, it may return the following array:
     *
     * [
     *     'data' => [
     *         'type' => 'dummy',
     *         'id' => '1'
     *     ]
     * ]
     *
     * @param PropertyMetadata $propertyMetadata
     * @param mixed            $relatedObject
     * @param string           $resourceClass
     * @param string|null      $format
     * @param array            $context
     *
     * @return string|array
     */
    protected function normalizeRelation(
        PropertyMetadata $propertyMetadata,
        $relatedObject,
        string $resourceClass,
        string $format = null,
        array $context
    ) {
        $resourceClass = $this->resourceClassResolver->getResourceClass(
            $relatedObject,
            null,
            true
        );

        $resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);

        $identifier = $this->getIdentifierFromItem($relatedObject);

        return ['data' => [
            'type' => $resourceMetadata->getShortName(),
            'id' => (string) $identifier,
        ]];
    }

    private function getIdentifierFromItem($item)
    {
        $identifiers = $this->getIdentifiersFromItem($item);

        if (count($identifiers) > 1) {
            throw new RuntimeException(sprintf(
                'Multiple identifiers are not supported during serialization of relationships (Entity: \'%s\')',
                $resourceClass
            ));
        }

        return reset($identifiers);
    }

    /**
     * Find identifiers from an Item (Object).
     *
     * Taken from ApiPlatform\Core\Bridge\Symfony\Routing\IriConverter
     *
     * @param object $item
     *
     * @throws RuntimeException
     *
     * @return array
     */
    private function getIdentifiersFromItem($item): array

    {
        $identifiers = [];
        $resourceClass = $this->getObjectClass($item);

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

            $identifier = $propertyMetadata->isIdentifier();
            if (null === $identifier || false === $identifier) {
                continue;
            }

            $identifiers[$propertyName] = $this
                ->propertyAccessor
                ->getValue($item, $propertyName);

            if (!is_object($identifiers[$propertyName])) {
                continue;
            }

            $relatedResourceClass = $this->getObjectClass($identifiers[$propertyName]);
            $relatedItem = $identifiers[$propertyName];

            unset($identifiers[$propertyName]);

            foreach (
                $this
                    ->propertyNameCollectionFactory
                    ->create($relatedResourceClass)
                    as $relatedPropertyName
            ) {
                $propertyMetadata = $this
                    ->propertyMetadataFactory
                    ->create($relatedResourceClass, $relatedPropertyName);

                if ($propertyMetadata->isIdentifier()) {
                    if (isset($identifiers[$propertyName])) {
                        throw new RuntimeException(sprintf(
                            'Composite identifiers not supported in "%s" through relation "%s" of "%s" used as identifier',
                            $relatedResourceClass,
                            $propertyName,
                            $resourceClass
                        ));
                    }

                    $identifiers[$propertyName] = $this
                        ->propertyAccessor
                        ->getValue(
                            $relatedItem,
                            $relatedPropertyName
                        );
                }
            }

            if (!isset($identifiers[$propertyName])) {
                throw new RuntimeException(sprintf(
                    'No identifier found in "%s" through relation "%s" of "%s" used as identifier',
                    $relatedResourceClass,
                    $propertyName,
                    $resourceClass
                ));
            }
        }

        return $identifiers;
    }
}


1			<?php
2
3			/*
4			* This file is part of the API Platform project.
5			*
6			* (c) Kévin Dunglas <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			declare(strict_types=1);
13
14			namespace ApiPlatform\Core\JsonApi\Serializer;
15
16			use ApiPlatform\Core\Api\IriConverterInterface;
17			use ApiPlatform\Core\Api\ResourceClassResolverInterface;
18			use ApiPlatform\Core\DataProvider\ItemDataProviderInterface;
19			use ApiPlatform\Core\Exception\InvalidArgumentException;
20			use ApiPlatform\Core\Exception\RuntimeException;
21			use ApiPlatform\Core\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
22			use ApiPlatform\Core\Metadata\Property\Factory\PropertyNameCollectionFactoryInterface;
23			use ApiPlatform\Core\Metadata\Property\PropertyMetadata;
24			use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
25			use ApiPlatform\Core\Serializer\AbstractItemNormalizer;
26			use ApiPlatform\Core\Serializer\ContextTrait;
27			use ApiPlatform\Core\Util\ClassInfoTrait;
28			use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
29			use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
30
31			/**
32			* Converts between objects and array.
33			*
34			* @author Kévin Dunglas <[email protected]>
35			* @author Amrouche Hamza <[email protected]>
36			*/
37			final class ItemNormalizer extends AbstractItemNormalizer
38			{
39			use ContextTrait;
40			use ClassInfoTrait;

api-platform / core

Pull Request — master (#1036)

ItemNormalizer::getComponents() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like