AnnotationDriver::__construct() - Code Metrics - Inspection of "Merge pull request #74 from mapado/jd-feat-prettie..." - mapado/rest-client-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 685595...680e76 )

by Julien
created 2018-04-10 14:58 UTC
AnnotationDriver::__construct() A

↳ Parent: AnnotationDriver
Complexity

Conditions	1
Paths	1
Size

Total Lines	7
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	4
CRAP Score	1
Importance

Changes
Metric	Value
cc	1
eloc	4
nc	1
nop	2
dl	0
loc	7
ccs	4
cts	4
cp	1
crap	1
rs	9.4285
c	0
b	0
f	0
<?php

namespace Mapado\RestClientSdk\Mapping\Driver;

use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\Common\Annotations\AnnotationRegistry;
use Doctrine\Common\Annotations\FileCacheReader;
use Doctrine\Common\Annotations\Reader;
use Mapado\RestClientSdk\Exception\MappingException;
use Mapado\RestClientSdk\Mapping\Annotations;
use Mapado\RestClientSdk\Mapping\Attribute;
use Mapado\RestClientSdk\Mapping\ClassMetadata;
use Mapado\RestClientSdk\Mapping\Relation;

/**
 * Class AnnotationDriver
 *
 * @author Julien Deniau <[email protected]>
 */
class AnnotationDriver
{
    /**
     * cachePath
     *
     * @var string
     */
    private $cachePath;

    /**
     * debug
     *
     * @var bool
     */
    private $debug;

    /**
     * Constructor.
     *
     * @param string $cachePath
     * @param bool   $debug
     */
    public function __construct($cachePath, $debug = false)
    {
        $this->cachePath = $cachePath;
        $this->debug = $debug;

        AnnotationRegistry::registerFile(
        /** @scrutinizer ignore-deprecated */ AnnotationRegistry::registerFile(
            __DIR__ . '/../Annotations/AllAnnotations.php'
        );
    }

    /**
     * loadDirectory
     *
     * @param string $path
     *
     * @return ClassMetadata[]
     *
     * @throws MappingException
     */
    public function loadDirectory($path)
    {
        if (!is_dir($path)) {
            throw new MappingException($path . ' is not a valid directory');
        }

        $iterator = new \RegexIterator(
            new \RecursiveIteratorIterator(
                new \RecursiveDirectoryIterator(
                    $path,
                    \FilesystemIterator::SKIP_DOTS
                ),
                \RecursiveIteratorIterator::LEAVES_ONLY
            ),
            '/^.+\.php$/i',
            \RecursiveRegexIterator::GET_MATCH
        );

        $classes = [];
        $includedFiles = [];

        foreach ($iterator as $file) {
            $sourceFile = $file[0];
            if (!preg_match('(^phar:)i', $sourceFile)) {
                $sourceFile = realpath($sourceFile);
            }

            require_once $sourceFile;
            $includedFiles[] = $sourceFile;
        }

        $declared = get_declared_classes();
        foreach ($declared as $className) {
            $rc = new \ReflectionClass($className);
            $sourceFile = $rc->getFileName();
            if (in_array($sourceFile, $includedFiles)) {
                $classes[] = $className;
            }
        }

        $mapping = [];
        foreach ($classes as $class) {
            if ($metadata = $this->getClassMetadataForClassname($class)) {
                $mapping[] = $metadata;
            }
        }

        return $mapping;
    }

    /**
     * loadClassname
     *
     * @param string $classname
     *
     * @return ClassMetadata[]
     */
    public function loadClassname($classname)
    {
        $metadata = $this->getClassMetadataForClassname($classname);

        return $metadata ? [$metadata] : [];
    }

    /**
     * getClassMetadataForClassname
     *
     * @param string $classname
     *
     * @return ClassMetadata|null
     */
    private function getClassMetadataForClassname($classname)
    {
        $reader = new FileCacheReader(
        $reader = /** @scrutinizer ignore-deprecated */ new FileCacheReader(
            new AnnotationReader(),
            $this->cachePath,
            $this->debug
        );

        $reflClass = new \ReflectionClass($classname);
        /** @var Annotations\Entity */
        $classAnnotation = $reader->getClassAnnotation(
            $reflClass,
            Annotations\Entity::class
        );

        if (!$classAnnotation) {
            return null;
        }

        $attributeList = [];
        $relationList = [];
        foreach ($reflClass->getProperties() as $property) {
            // manage attributes
            /** @var Annotations\Attribute */
            $propertyAnnotation = $this->getPropertyAnnotation(
                $reader,
                $property,
                'Attribute'
            );

            if ($propertyAnnotation) {
                $isId = $this->getPropertyAnnotation($reader, $property, 'Id');

                $attributeList[] = new Attribute(
                    $propertyAnnotation->name,
                    $property->getName(),
                    $propertyAnnotation->type,
                    (bool) $isId
                );
            } else {
                // manage relations
                /** @var Annotations\OneToMany */
                $relation = $this->getPropertyAnnotation(
                    $reader,
                    $property,
                    'OneToMany'
                );
                if (!$relation) {
                    /** @var Annotations\ManyToOne */
                    $relation = $this->getPropertyAnnotation(
                        $reader,
                        $property,
                        'ManyToOne'
                    );
                }

                if ($relation) {
                    $attributeList[] = new Attribute(
                        $relation->name,
                        $property->getName()
                    );

                    $targetEntity = $relation->targetEntity;
                    if (false === strpos($targetEntity, '/')) {
                        $targetEntity =
                            substr(
                                $classname,
                                0,
                                strrpos($classname, '\\') + 1
                            ) .
                            $targetEntity;
                    }

                    $relationList[] = new Relation(
                        $relation->name,
                        $relation->type,
                        $targetEntity
                    );
                }
            }
        }

        $classMetadata = new ClassMetadata(
            $classAnnotation->key,
            $classname,
            $classAnnotation->repository
        );
        $classMetadata->setAttributeList($attributeList);
        $classMetadata->setRelationList($relationList);

        return $classMetadata;
    }

    /**
     * getPropertyAnnotation
     *
     * @param Reader              $reader
     * @param \ReflectionProperty $property
     * @param string              $classname
     *
     * @return null|object
     */
    private function getPropertyAnnotation(
        Reader $reader,
        \ReflectionProperty $property,
        $classname
    ) {
        return $reader->getPropertyAnnotation(
            $property,
            'Mapado\\RestClientSdk\\Mapping\\Annotations\\' . $classname
        );
    }
}

mapado / rest-client-sdk

Push — master ( 685595...680e76 )

AnnotationDriver::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
