Tarantool\Mapper\Schema\Meta

Complexity

Total Complexity

32

Size/Duplication

Total Lines	190
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	has()	0	15	3
A	setConvention()	0	6	1
A	__construct()	0	13	2
A	get()	0	18	3
B	remove()	0	33	6
B	create()	0	30	6
A	getConvention()	0	9	2
C	collectData()	0	33	8
A	toArray()	0	10	1

<?php

namespace Tarantool\Mapper\Schema;

use Tarantool\Mapper\Contracts;
use Exception;
use LogicException;

class Meta implements Contracts\Meta
{
    protected $manager;
    protected $property = [];
    protected $indexes = [];
    protected $types = [];
    protected $instances = [];

    public function __construct(Contracts\Manager $manager, array $data = null)
    {
        $this->manager = $manager;

        if($data) {
            $this->property = $data['property'];
            $this->indexes = $data['indexes'];
            $this->types = $data['types'];

        } else {
            $this->collectData();
        }
    }

    /**
     * @return Type
     */
    public function get($type)
    {
        if (!array_key_exists($type, $this->instances)) {
            $spaceId = $this->manager->getSchema()->getSpaceId($type);
            if (!$spaceId) {
                throw new LogicException("Type $type not exists");
            }

            $this->instances[$type] = new Type(
                $this->manager, $type,
                $this->property[$spaceId],
                $this->types[$spaceId],
                $this->indexes[$spaceId]
            );
        }

        return $this->instances[$type];
    }

    public function has($type)
    {
        // was created
        if (array_key_exists($type, $this->instances)) {
            return true;
        }

        // can be created
        $spaceId = $this->manager->getSchema()->getSpaceId($type);
        if (array_key_exists($spaceId, $this->property)) {
            return true;
        }

        return false;
    }

    public function remove($type)
    {
        $other = $this->manager->get('property')->find(['type' => $type]);

The method find does only exist in Tarantool\Mapper\Contracts\Repository, but not in Tarantool\Mapper\Contracts\Entity.

        if (count($other)) {
            $name = $this->manager->getSchema()->getSpaceName($other[0]->space);
            throw new Exception("Space $name references ".$type);
        }
        $instance = $this->get($type);
        $rows = $instance->getSpace()->select([])->getData();
        if (count($rows)) {
            throw new Exception("Can't remove non-empty space $type");
        }

        $indexes = array_reverse(array_keys($instance->getIndexes()));
        foreach ($indexes as $index) {
            $instance->dropIndex($index);
        }

        foreach (array_reverse($instance->getProperties()) as $property) {
            $instance->removeProperty($property);
        }

        $sq = $this->manager->get('sequence')->findOne(['space' => $instance->getSpaceId()]);

The method findOne does only exist in Tarantool\Mapper\Contracts\Repository, but not in Tarantool\Mapper\Contracts\Entity.

        if ($sq) {
            $this->manager->remove($sq);
            $this->manager->get('sequence')->flushCache();
        }

        $this->manager->getSchema()->dropSpace($type);
        unset($this->instances[$type]);

        $this->manager->forgetRepository($type);
    }

    /**
     * @return Type
     */
    public function create($type, array $fields = null)
    {
        if ($this->manager->getSchema()->hasSpace($type)) {
            throw new LogicException("Type $type exists");
        }

        $this->manager->getSchema()->createSpace($type);

        $instance = new Type($this->manager, $type, [], [], []);

        $instance->addProperty('id');
        $instance->addIndex('id');

        if ($fields) {
            foreach ($fields as $index => $field) {
                if ($field instanceof Contracts\Type) {
                    if (!is_numeric($index)) {
                        $instance->reference($field, $index);
                    } else {
                        $instance->reference($field);
                    }
                } else {
                    $instance->addProperty($field);
                }
            }
        }
        $this->instances[$type] = $instance;

        return $instance;
    }

    public function setConvention(Contracts\Convention $convention)
    {
        $this->convention = $convention;

The property convention does not exist. Did you maybe forget to declare it?

        return $this;
    }

    public function getConvention()
    {
        if (!isset($this->convention)) {
            $this->convention = new Convention();
            $this->convention->setNumberType($this->manager->getSchema()->getNumberType());
        }

        return $this->convention;
    }

    private function collectData()
    {
        $client = $this->manager->getClient();
        foreach ($client->getSpace('property')->select([], 'space')->getData() as $property) {
            list($id, $spaceId, $line, $name, $type) = $property;

The assignment to $id is unused. Consider omitting it like so list($first,,$third).

            if (!array_key_exists($spaceId, $this->property)) {
                $this->property[$spaceId] = [];
                $this->types[$spaceId] = [];
            }
            $this->property[$spaceId][$line] = $name;
            $this->types[$spaceId][$name] = $type;
        }
        foreach ($client->getSpace('_vindex')->select([], 'primary')->getData() as $index) {
            list($spaceId, $num, $name, $type, $params, $properties) = $index;

The assignment to $name is unused. Consider omitting it like so list($first,,$third).

The assignment to $type is unused. Consider omitting it like so list($first,,$third).

The assignment to $params is unused. Consider omitting it like so list($first,,$third).

            if (!array_key_exists($spaceId, $this->property)) {
                // tarantool space index
                continue;
            }
            if (!isset($this->indexes[$spaceId])) {
                $this->indexes[$spaceId] = [];
            }
            $this->indexes[$spaceId][$num] = [];
            foreach ($properties as $row) {
                list($part, $type) = $row;

The assignment to $type is unused. Consider omitting it like so list($first,,$third).

                $this->indexes[$spaceId][$num][] = $this->property[$spaceId][$part];
            }
        }
        foreach ($this->property as $spaceId => $collection) {
            ksort($collection);
            $this->property[$spaceId] = $collection;
        }

    }

    public function toArray()
    {
        $this->collectData();

        return [
            'property' => $this->property,
            'indexes' => $this->indexes,
            'types' => $this->types,
        ];
    }
}