Flying\Struct\Metadata\AnnotationParser

Complexity

Total Complexity

19

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	13

Test Coverage

Coverage

94.74%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	loadClass()	0	14	4
A	parseMetadata()	0	8	2
A	getReader()	0	13	3
A	setReader()	0	5	1
D	convertToMetadata()	0	37	9

<?php

namespace Flying\Struct\Metadata;

use Doctrine\Common\Annotations\AnnotationRegistry;
use Doctrine\Common\Annotations\Reader;
use Doctrine\Common\Annotations\SimpleAnnotationReader;
use Flying\Struct\Annotation\Struct\Annotation;
use Flying\Struct\Annotation\Struct\Property;
use Flying\Struct\Annotation\Struct\Struct;
use Flying\Struct\ConfigurationManager;
use Flying\Struct\Exception;

/**
 * Structures metadata parser implementation for parsing structure annotations
 */
class AnnotationParser extends AbstractMetadataParser
{
    /**
     * Annotations reader
     *
     * @var Reader
     */
    private $reader;
    /**
     * Namespaces for annotations autoloading
     *
     * @var array
     */
    private $namespaces = [];

    /**
     * Load annotation class
     *
     * @param string $class
     *
     * @return boolean
     */
    public function loadClass($class)
    {
        if (class_exists($class)) {
            return true;
        }
        $class = ucfirst(trim($class, '\\'));
        foreach ($this->namespaces as $ns) {
            $fqcn = $ns . '\\' . $class;
            if (class_exists($fqcn)) {
                return true;
            }
        }
        return false;
    }

    /**
     * {@inheritdoc}
     * @throws \Flying\Struct\Exception
     * @throws \InvalidArgumentException
     */
    protected function parseMetadata(\ReflectionClass $reflection, StructMetadata $metadata)
    {
        $reader = $this->getReader();
        $annotations = $reader->getClassAnnotations($reflection);
        foreach ($annotations as $annotation) {
            $metadata->addProperty($this->convertToMetadata($annotation));
        }
    }

    /**
     * Get annotations reader
     *
     * @return Reader
     * @throws \InvalidArgumentException
     */
    public function getReader()
    {
        if (!$this->reader) {
            $this->reader = new SimpleAnnotationReader();
            $namespaces = ConfigurationManager::getConfiguration()->getAnnotationNamespacesMap()->getAll();
            foreach ($namespaces as $ns) {
                $this->reader->addNamespace($ns);
            }
            $this->namespaces = array_reverse($namespaces, true);
            AnnotationRegistry::registerLoader([$this, 'loadClass']);

The method Doctrine\Common\Annotations\AnnotationRegistry::registerLoader() has been deprecated with message: this method is deprecated and will be removed in doctrine/annotations 2.0 autoloading should be deferred to the globally registered autoloader by then. For now, use @example AnnotationRegistry::registerLoader('class_exists')

        }
        return $this->reader;
    }

    /**
     * Set annotations reader to use for parsing structure annotations
     *
     * @param Reader $reader
     *
     * @return $this
     */
    public function setReader(Reader $reader)
    {
        $this->reader = $reader;
        return $this;
    }

    /**
     * Convert given structure annotation into structure metadata
     *
     * @param Annotation $annotation Structure annotation to convert
     *
     * @return PropertyMetadata
     * @throws \InvalidArgumentException
     * @throws Exception
     */
    protected function convertToMetadata(Annotation $annotation)
    {
        if ($annotation instanceof Property) {
            $class = $this->resolvePropertyClass($annotation->getType());
            if (!$class) {

The expression $class of type string|null is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

                throw new Exception('Unable to resolve structure property class for type: ' . $annotation->getType());
            }
            $property = new PropertyMetadata($annotation->getName(), $class, $annotation->getConfig());
            return $property;
        }

        if (!($annotation instanceof Struct)) {
            throw new Exception('Unknown structure annotation type');
        }

        if ($annotation->getClass()) {
            $class = $this->resolveStructClass($annotation->getClass());
            if (!$class) {

The expression $class of type string|null is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

                throw new Exception('Unable to resolve structure class: ' . $annotation->getClass());
            }
            $struct = ConfigurationManager::getConfiguration()->getMetadataManager()->getMetadata($class);
            if (!$struct instanceof StructMetadata) {
                throw new Exception('Failed to get structure metadata for class: ' . $class);
            }
            $struct->setName($annotation->getName());
            $struct->setConfig($annotation->getConfig());
        } else {
            if (!count($annotation->getProperties())) {
                throw new Exception('Structure metadata should have either class name or explicitly defined list of structure properties');
            }
            $struct = new StructMetadata($annotation->getName(), null, $annotation->getConfig());
            foreach ($annotation->getProperties() as $p) {
                $struct->addProperty($this->convertToMetadata($p));
            }
        }
        return $struct;
    }
}