Tarantool\Mapper\Plugins\DocBlock

Complexity

Total Complexity

30

Size/Duplication

Total Lines	138
Duplicated Lines	4.35 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
D	register()	0	33	9
C	migrate()	6	66	14
A	toUnderscore()	0	12	4
A	getTarantoolType()	0	14	3

<?php

namespace Tarantool\Mapper\Plugins;

use Exception;

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

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

class DocBlock extends UserClasses
{
    private $entities = [];

Consider using a different property name as you override a private property of the parent class.

    private $repositories = [];

Consider using a different property name as you override a private property of the parent class.

    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->entities[] = $class;
        }

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

        $reflection = new ReflectionClass($class);
        $space = $this->toUnderscore($reflection->getShortName());
        if($this->mapper->getSchema()->hasSpace($space)) {
            if($isEntity) {
                $this->mapEntity($name, $class);

The variable $name does not exist. Did you forget to declare it?

            } else {
                $this->mapRepository($name, $class);
            }
        }
    }

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

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

        foreach($this->entities as $entity) {

            $class = new ReflectionClass($entity);
            $spaceName = $this->toUnderscore($class->getShortName());

            $space = $schema->hasSpace($spaceName) ? $schema->getSpace($spaceName) : $schema->createSpace($spaceName);
            $this->mapEntity($spaceName, $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->repositories as $repository) {

            $class = new ReflectionClass($repository);
            $spaceName = $this->toUnderscore($class->getShortName());

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

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

            $space = $schema->getSpace($spaceName);
            $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?

                    $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']);
            }
        }
    }

    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];
        }

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

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