Tarantool\Mapper\Plugin\Annotation

Complexity

Total Complexity

42

Size/Duplication

Total Lines	197
Duplicated Lines	8.12 %

Coupling/Cohesion

Components	2
Dependencies	4

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
D	register()	0	33	9
D	migrate()	6	75	16
A	setEntityPostfix()	0	5	1
A	setRepositoryPostfix()	0	5	1
A	getRepositorySpaceName()	0	4	1
B	getSpaceName()	10	23	6
A	toUnderscore()	0	12	4
A	getTarantoolType()	0	18	4

<?php

namespace Tarantool\Mapper\Plugin;

use Exception;

use phpDocumentor\Reflection\DocBlockFactory;
use ReflectionClass;
use ReflectionProperty;

use Tarantool\Mapper\Entity;
use Tarantool\Mapper\Plugin;
use Tarantool\Mapper\Repository;

class Annotation extends UserClasses
{
    protected $entityClasses = [];
    protected $entityPostfix;

    protected $repositoryClasses = [];
    protected $repositoryPostifx;

    public function register($class)
    {
        $isEntity = is_subclass_of($class, Entity::class);

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Tarantool\Mapper\Entity::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

        $isRepository = is_subclass_of($class, Repository::class);

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Tarantool\Mapper\Repository::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

        if (!$isEntity && !$isRepository) {
            throw new Exception("Invalid registration");
        }

        if ($isEntity) {
            if ($class == Entity::class) {
                throw new Exception("Invalid entity registration");
            }
            $this->entityClasses[] = $class;
        }

        if ($isRepository) {
            if ($class == Repository::class) {
                throw new Exception("Invalid repository registration");
            }
            $this->repositoryClasses[] = $class;
        }

        $space = $this->getSpaceName($class);
        if ($this->mapper->getSchema()->hasSpace($space)) {
            if ($isEntity) {
                $this->mapEntity($space, $class);
            } else {
                $this->mapRepository($space, $class);
            }
        }
        return $this;
    }

    public function migrate()
    {
        $factory = DocBlockFactory::createInstance();

        $schema = $this->mapper->getSchema();

        foreach ($this->entityClasses as $entity) {
            $spaceName = $this->getSpaceName($entity);
            $space = $schema->hasSpace($spaceName) ? $schema->getSpace($spaceName) : $schema->createSpace($spaceName);

            $this->mapEntity($spaceName, $entity);

            $class = new ReflectionClass($entity);

            foreach ($class->getProperties(ReflectionProperty::IS_PUBLIC) as $property) {
                $description = $factory->create($property->getDocComment());
                $tags = $description->getTags('var');

The call to DocBlock::getTags() has too many arguments starting with 'var'.

                if (!count($tags)) {

This code seems to be duplicated across your project.

                    throw new Exception("No var tag for ".$entity.'::'.$property->getName());
                }

                if (count($tags) > 1) {

This code seems to be duplicated across your project.

                    throw new Exception("Invalid var tag for ".$entity.'::'.$property->getName());
                }

                $property = $this->toUnderscore($property->getName());
                $type = $this->getTarantoolType($tags[0]->getType());

It seems like you code against a concrete implementation and not the interface phpDocumentor\Reflection\DocBlock\Tag as the method getType() does only exist in the following implementations of said interface: phpDocumentor\Reflection\DocBlock\Tags\Param, phpDocumentor\Reflection\DocBlock\Tags\Property, phpDocumentor\Reflection\DocBlock\Tags\PropertyRead, phpDocumentor\Reflection\DocBlock\Tags\PropertyWrite, phpDocumentor\Reflection\DocBlock\Tags\Return_, phpDocumentor\Reflection\DocBlock\Tags\Throws, phpDocumentor\Reflection\DocBlock\Tags\Var_.

                if (!$space->hasProperty($property)) {
                    $space->addProperty($property, $type);
                }
            }
        }

        foreach ($this->repositoryClasses as $repository) {
            $spaceName = $this->getSpaceName($repository);

            if (!$schema->hasSpace($spaceName)) {
                throw new Exception("Repository with no entity definition");
            }

            $this->mapRepository($spaceName, $repository);

            $space = $schema->getSpace($spaceName);

            $class = new ReflectionClass($repository);
            $properties = $class->getDefaultProperties();

            if (array_key_exists('indexes', $properties)) {
                foreach ($properties['indexes'] as $index) {

The expression $properties['indexes'] of type null|integer|double|string|boolean|array is not guaranteed to be traversable. How about adding an additional type check?

                    if (!is_array($index)) {
                        $index = (array) $index;
                    }
                    if (!array_key_exists('fields', $index)) {
                        $index = ['fields' => $index];
                    }

                    $index['if_not_exists'] = true;
                    $space->addIndex($index);
                }
            }
        }

        foreach ($schema->getSpaces() as $space) {
            if (!count($space->getIndexes())) {
                if (!$space->hasProperty('id')) {
                    throw new Exception("No primary index on ". $space->getName());
                }
                $space->addIndex(['id']);
            }
        }

        return $this;
    }

    public function setEntityPostfix($postfix)
    {
        $this->entityPostfix = $postfix;
        return $this;
    }

    public function setRepositoryPostfix($postfix)
    {
        $this->repositoryPostifx = $postfix;
        return $this;
    }

    private $spaceNames = [];

    public function getRepositorySpaceName($class)
    {
        return array_search($class, $this->repositoryMapping);
    }

    public function getSpaceName($class)
    {
        if (!array_key_exists($class, $this->spaceNames)) {
            $reflection = new ReflectionClass($class);
            $className = $reflection->getShortName();

            if ($reflection->isSubclassOf(Repository::class)) {

This code seems to be duplicated across your project.

                if ($this->repositoryPostifx) {
                    $className = substr($className, 0, strlen($className) - strlen($this->repositoryPostifx));
                }
            }

            if ($reflection->isSubclassOf(Entity::class)) {

This code seems to be duplicated across your project.

                if ($this->entityPostfix) {
                    $className = substr($className, 0, strlen($className) - strlen($this->entityPostfix));
                }
            }

            $this->spaceNames[$class] = $this->toUnderscore($className);
        }

        return $this->spaceNames[$class];
    }

    private $underscores = [];

    private function toUnderscore($input)
    {
        if (!array_key_exists($input, $this->underscores)) {
            preg_match_all('!([A-Z][A-Z0-9]*(?=$|[A-Z][a-z0-9])|[A-Za-z][a-z0-9]+)!', $input, $matches);
            $ret = $matches[0];
            foreach ($ret as &$match) {
                $match = $match == strtoupper($match) ? strtolower($match) : lcfirst($match);
            }
            $this->underscores[$input] = implode('_', $ret);
        }
        return $this->underscores[$input];
    }

    private $tarantoolTypes = [];

    private function getTarantoolType(string $type)
    {
        if (array_key_exists($type, $this->tarantoolTypes)) {
            return $this->tarantoolTypes[$type];
        }

        if ($type[0] == '\\') {
            return $this->tarantoolTypes[$type] = 'unsigned';
        }

        switch ($type) {
            case 'int':
                return $this->tarantoolTypes[$type] = 'unsigned';

            default:
                return $this->tarantoolTypes[$type] = 'str';
        }
    }
}