ApiResourceMetadataParser::resolveActualType() - Code Metrics - Elao/ApiResourcesMetadata - Measure and Improve Code Quality continuously with Scrutinizer

ApiResourceMetadataParser::resolveActualType() C
last analyzed 2017-10-19 13:31 UTC

↳ Parent: ApiResourceMetadataParser

Complexity

Conditions	13
Paths	55

Size

Total Lines	51
Code Lines	36

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	51
rs	5.6547
c	0
b	0
f	0
cc	13
eloc	36
nc	55
nop	1

How to fix Long Method Complexity

<?php

/*
 * This file is part of the "elao/api-resources-metadata" package.
 *
 * Copyright (C) 2016 Elao
 *
 * @author Elao <[email protected]>
 */

namespace Elao\ApiResourcesMetadata\Bridge\Nelmio\ApiDoc\Parser;

use Elao\ApiResourcesMetadata\Attribute\ResourceAttributeMetadata;
use Elao\ApiResourcesMetadata\Resource\Factory\ResourceMetadataFactory;
use Elao\ApiResourcesMetadata\Resource\ResourceIndex;
use Nelmio\ApiDocBundle\DataTypes;
use Nelmio\ApiDocBundle\Parser\ParserInterface;

class ApiResourceMetadataParser implements ParserInterface
{
    /** @var ResourceMetadataFactory */
    private $metadataFactory;

    /** @var ResourceIndex */
    private $resourceIndex;

    public function __construct(ResourceIndex $resourceIndex, ResourceMetadataFactory $metadataFactory)
    {
        $this->metadataFactory = $metadataFactory;
        $this->resourceIndex = $resourceIndex;
    }

    /**
     * {@inheritdoc}
     */
    public function supports(array $item)
    {
        return $this->resourceIndex->has($item['class']);
    }

    /**
     * {@inheritdoc}
     */
    public function parse(array $item)
    {
        $class = $item['class'];

        return $this->doParse($class);
    }

    private function doParse($class)
    {
        $data = [];

        $resourceMetadata = $this->metadataFactory->getMetadataFor($class);

        foreach ($resourceMetadata->getAttributes() as $attributeMetadata) {
            list($actualType, $subType) = $this->resolveActualType($attributeMetadata);

            $attributeData = [
                'dataType' => $attributeMetadata->getType(),
                'actualType' => $actualType,
                'required' => $attributeMetadata->isRequired(),
                'description' => $attributeMetadata->getDescription() ?: '',
                'readonly' => null,
            ];

            if ($subType) {
                $attributeData['subType'] = $subType;
                $attributeData['dataType'] = null; // ApiDocExtractor will generate it

                if ($this->supports(['class' => $subType])) {
                    $attributeData['subType'] = $this->resourceIndex->getShortName($subType);
                    $attributeData['children'] = $this->doParse($subType);
                }
            }

            $data[$attributeMetadata->getName()] = $attributeData;
        }

        return $data;
    }

    private function resolveActualType(ResourceAttributeMetadata $attributeMetadata)
    {
        $originalTypeClass = ltrim($attributeMetadata->getOriginalType(), '\\');

        if (in_array($originalTypeClass, [\DateTime::class, \DateTimeImmutable::class, \DateTimeInterface::class], true)) {
            return [DataTypes::DATETIME, null];
        }

        $type = $attributeMetadata->getType();

        $actualType = null;
        $subType = null;

        // If it's a collection of models
        if (false !== strpos($type, '[]')) {
            $actualType = DataTypes::COLLECTION;
        } elseif (class_exists($type)) {
            $actualType = DataTypes::MODEL;
        }

        $type = str_replace('[]', '', $type, $count);

        switch ($type) {
            case 'bool':
            case 'boolean':
                $type = DataTypes::BOOLEAN;
                break;
            case 'int':
            case 'integer':
                $type = DataTypes::INTEGER;
                break;
            case 'double':
            case 'float':
                $type = DataTypes::FLOAT;
                break;
            case 'file':
                $type = DataTypes::FILE;
                break;
            case 'string':
                $type = DataTypes::STRING;
                break;
        }

        if (in_array($actualType, [DataTypes::COLLECTION, DataTypes::MODEL])) {
            $subType = $type;
        } else {
            $actualType = $type;
        }

        return [$actualType, $subType];
    }
}


1			<?php
2
3			/*
4			* This file is part of the "elao/api-resources-metadata" package.
5			*
6			* Copyright (C) 2016 Elao
7			*
8			* @author Elao <[email protected]>
9			*/
10
11			namespace Elao\ApiResourcesMetadata\Bridge\Nelmio\ApiDoc\Parser;
12
13			use Elao\ApiResourcesMetadata\Attribute\ResourceAttributeMetadata;
14			use Elao\ApiResourcesMetadata\Resource\Factory\ResourceMetadataFactory;
15			use Elao\ApiResourcesMetadata\Resource\ResourceIndex;
16			use Nelmio\ApiDocBundle\DataTypes;
17			use Nelmio\ApiDocBundle\Parser\ParserInterface;
18
19			class ApiResourceMetadataParser implements ParserInterface
20			{
21			/** @var ResourceMetadataFactory */
22			private $metadataFactory;
23
24			/** @var ResourceIndex */
25			private $resourceIndex;
26
27			public function __construct(ResourceIndex $resourceIndex, ResourceMetadataFactory $metadataFactory)
28			{
29			$this->metadataFactory = $metadataFactory;
30			$this->resourceIndex = $resourceIndex;
31			}
32
33			/**
34			* {@inheritdoc}
35			*/
36			public function supports(array $item)
37			{
38			return $this->resourceIndex->has($item['class']);
39			}
40
41			/**
42			* {@inheritdoc}
43			*/
44			public function parse(array $item)
45			{
46			$class = $item['class'];
47
48			return $this->doParse($class);
49			}
50
51			private function doParse($class)
52			{
53			$data = [];
54
55			$resourceMetadata = $this->metadataFactory->getMetadataFor($class);
56
57			foreach ($resourceMetadata->getAttributes() as $attributeMetadata) {
58			list($actualType, $subType) = $this->resolveActualType($attributeMetadata);
59
60			$attributeData = [
61			'dataType' => $attributeMetadata->getType(),
62			'actualType' => $actualType,
63			'required' => $attributeMetadata->isRequired(),
64			'description' => $attributeMetadata->getDescription() ?: '',
65			'readonly' => null,
66			];
67
68			if ($subType) {
69			$attributeData['subType'] = $subType;
70			$attributeData['dataType'] = null; // ApiDocExtractor will generate it
71
72			if ($this->supports(['class' => $subType])) {
73			$attributeData['subType'] = $this->resourceIndex->getShortName($subType);
74			$attributeData['children'] = $this->doParse($subType);
75			}
76			}
77
78			$data[$attributeMetadata->getName()] = $attributeData;
79			}
80
81			return $data;
82			}
83
84			private function resolveActualType(ResourceAttributeMetadata $attributeMetadata)
85			{
86			$originalTypeClass = ltrim($attributeMetadata->getOriginalType(), '\\');
87
88			if (in_array($originalTypeClass, [\DateTime::class, \DateTimeImmutable::class, \DateTimeInterface::class], true)) {
89			return [DataTypes::DATETIME, null];
90			}
91
92			$type = $attributeMetadata->getType();
93
94			$actualType = null;
95			$subType = null;
96
97			// If it's a collection of models
98			if (false !== strpos($type, '[]')) {
99			$actualType = DataTypes::COLLECTION;
100			} elseif (class_exists($type)) {
101			$actualType = DataTypes::MODEL;
102			}
103
104			$type = str_replace('[]', '', $type, $count);
105
106			switch ($type) {
107			case 'bool':
108			case 'boolean':
109			$type = DataTypes::BOOLEAN;
110			break;
111			case 'int':
112			case 'integer':
113			$type = DataTypes::INTEGER;
114			break;
115			case 'double':
116			case 'float':
117			$type = DataTypes::FLOAT;
118			break;
119			case 'file':
120			$type = DataTypes::FILE;
121			break;
122			case 'string':
123			$type = DataTypes::STRING;
124			break;
125			}
126
127			if (in_array($actualType, [DataTypes::COLLECTION, DataTypes::MODEL])) {
128			$subType = $type;
129			} else {
130			$actualType = $type;
131			}
132
133			return [$actualType, $subType];
134			}
135			}
136

Elao / ApiResourcesMetadata

ApiResourceMetadataParser::resolveActualType() C last analyzed 2017-10-19 13:31 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

ApiResourceMetadataParser::resolveActualType() C
last analyzed 2017-10-19 13:31 UTC