Dontdrinkandroot\RestBundle\Metadata\Driver\YamlDriver

Complexity

Total Complexity

36

Size/Duplication

Total Lines	197
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

86.87%

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
C	loadMetadataFromFile()	0	59	10
D	parseFieldConfig()	0	34	9
A	getBool()	0	13	3
A	getArrayValue()	0	12	3
A	getExtension()	0	4	1
A	getOrCreatePropertymetadata()	0	11	2
B	parseMethods()	0	24	6
A	parseRight()	0	8	1

<?php

namespace Dontdrinkandroot\RestBundle\Metadata\Driver;

use Dontdrinkandroot\RestBundle\Metadata\Annotation\Method;
use Dontdrinkandroot\RestBundle\Metadata\Annotation\Right;
use Dontdrinkandroot\RestBundle\Metadata\ClassMetadata;
use Dontdrinkandroot\RestBundle\Metadata\PropertyMetadata;
use Metadata\Driver\AbstractFileDriver;
use Metadata\Driver\DriverInterface;
use Metadata\Driver\FileLocatorInterface;
use Symfony\Component\Yaml\Yaml;

class YamlDriver extends AbstractFileDriver
{
    /**
     * @var DriverInterface
     */
    private $doctrineDriver;

    public function __construct(FileLocatorInterface $locator, DriverInterface $doctrineDriver)
    {
        parent::__construct($locator);
        $this->doctrineDriver = $doctrineDriver;
    }

    /**
     * {@inheritdoc}
     */
    protected function loadMetadataFromFile(\ReflectionClass $class, $file)
    {
        /** @var ClassMetadata $ddrRestClassMetadata */
        $classMetadata = $this->doctrineDriver->loadMetadataForClass($class);
        if (null === $classMetadata) {
            $classMetadata = new ClassMetadata($class->getName());
        }

        $config = Yaml::parse(file_get_contents($file));
        $className = key($config);

        if ($className !== $class->name) {
            throw new \RuntimeException(
                sprintf('Class definition mismatch for "%s" in "%s": %s', $class->getName(), $file, key($config))
            );
        }

        $config = $config[$className];
        if (!is_array($config)) {
            $config = [];
        }

        if (array_key_exists('rootResource', $config) && true === $config['rootResource']) {
            $classMetadata->setRestResource(true);
        }

        $classMetadata->service = $config['service'] ?? null;

The property service does not seem to exist in Metadata\ClassMetadata.

        $classMetadata->idField = $config['idField'] ?? null;

The property idField does not seem to exist in Metadata\ClassMetadata.

        $classMetadata->setMethods($this->parseMethods($config));

        $fieldConfigs = [];
        if (array_key_exists('fields', $config)) {
            $fieldConfigs = $config['fields'];
        }

        foreach ($class->getProperties() as $reflectionProperty) {

            $propertyName = $reflectionProperty->getName();
            $propertyMetadata = $this->getOrCreatePropertymetadata($classMetadata, $propertyName);

$classMetadata of type object<Metadata\ClassMetadata> is not a sub-type of object<Dontdrinkandroot\RestBundle\Metadata\ClassMetadata>. It seems like you assume a child class of the class Metadata\ClassMetadata to be always present.

            if (array_key_exists($propertyName, $fieldConfigs)) {
                $fieldConfig = $fieldConfigs[$propertyName];
                $this->parseFieldConfig($propertyName, $fieldConfig, $propertyMetadata);
                unset($fieldConfigs[$propertyName]);
            }

            $classMetadata->addPropertyMetadata($propertyMetadata);
        }

        /* Parse unbacked field definitions */
        foreach ($fieldConfigs as $name => $fieldConfig) {
            $propertyMetadata = $this->getOrCreatePropertymetadata($classMetadata, $name);

$classMetadata of type object<Metadata\ClassMetadata> is not a sub-type of object<Dontdrinkandroot\RestBundle\Metadata\ClassMetadata>. It seems like you assume a child class of the class Metadata\ClassMetadata to be always present.

            $this->parseFieldConfig($name, $fieldConfig, $propertyMetadata);
            $classMetadata->addPropertyMetadata($propertyMetadata);
        }

        return $classMetadata;
    }

    protected function parseFieldConfig(string $name, array $fieldConfig, PropertyMetadata $propertyMetadata): void
    {
        if (null !== $value = $this->getBool('postable', $fieldConfig)) {
            $propertyMetadata->setPostable($value);
        }

        if (null !== $value = $this->getBool('puttable', $fieldConfig)) {
            $propertyMetadata->setPuttable($value);
        }

        if (null !== $value = $this->getBool('excluded', $fieldConfig)) {
            $propertyMetadata->setExcluded($value);
        }

        if (null !== $value = $this->getBool('virtual', $fieldConfig)) {
            $propertyMetadata->setVirtual($value);
        }

        if (null !== $subResourceConfig = $fieldConfig['subResource'] ?? null) {
            $propertyMetadata->setSubResource(true);
            $propertyMetadata->setMethods($this->parseMethods($subResourceConfig));

$this->parseMethods($subResourceConfig) is of type null|array, but the function expects a array<integer,object<Dontdrinkandroot\RestBundle\Metadata\Annotation\Method>>.

        }

        if (array_key_exists('includable', $fieldConfig)) {
            $value = $fieldConfig['includable'];
            if (is_array($value)) {
                $propertyMetadata->setIncludable(true);
                $propertyMetadata->setIncludablePaths($value);
            } elseif (true === $value) {
                $propertyMetadata->setIncludable(true);
                $propertyMetadata->setIncludablePaths([$name]);

array($name) is of type array<integer,string,{"0":"string"}>, but the function expects a null|array<integer,object<string>>.

            }
        }
    }

    private function getBool(string $key, array $haystack, bool $required = false)
    {
        $value = $this->getArrayValue($key, $haystack, $required);
        if (null === $value) {
            return null;
        }

        if (!is_bool($value)) {
            throw new \RuntimeException(sprintf('Value %s must be of type bool', $key));
        }

        return $value;
    }

    private function getArrayValue(string $key, array $haystack, bool $required = false)
    {
        if (!array_key_exists($key, $haystack)) {
            if ($required) {
                throw new \RuntimeException(sprintf('Value %s is required', $key));
            }

            return null;
        }

        return $haystack[$key];
    }

    /**
     * {@inheritdoc}
     */
    protected function getExtension()
    {
        return 'rest.yml';
    }

    protected function getOrCreatePropertymetadata(ClassMetadata $classMetadata, $propertyName): PropertyMetadata
    {
        $propertyMetadata = $classMetadata->getPropertyMetadata($propertyName);
        if (null === $propertyMetadata) {
            $propertyMetadata = new PropertyMetadata($classMetadata->name, $propertyName);

            return $propertyMetadata;
        }

        return $propertyMetadata;
    }

    /**
     * @param array $config
     *
     * @return Method[]
     */
    private function parseMethods(array $config)
    {
        if (!array_key_exists('methods', $config)) {
            return null;
        }

        $methods = [];
        $methodsConfig = $config['methods'];
        foreach ($methodsConfig as $name => $config) {
            $method = new Method();
            $method->name = $name;

It seems like $name can also be of type integer. However, the property $name is declared as type string. Maybe add an additional type check?

            if (null !== $config) {
                if (array_key_exists('right', $config)) {
                    $method->right = $this->parseRight($config['right']);
                }
                if (array_key_exists('defaultIncludes', $config)) {
                    $method->defaultIncludes = $config['defaultIncludes'];
                }
            }
            $methods[$method->name] = $method;
        }

        return $methods;
    }

    private function parseRight(array $config): Right
    {
        $right = new Right();
        $right->attributes = $this->getArrayValue('attributes', $config);
        $right->propertyPath = $this->getArrayValue('propertyPath', $config);

        return $right;
    }
}