Tarantool\Mapper\Schema\Schema

Complexity

Total Complexity

20

Size/Duplication

Total Lines	94
Duplicated Lines	28.72 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

88.33%

Importance

Changes	9
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	hasSpace()	0	4	1
A	createSpace()	0	4	1
A	hasIndex()	0	7	1
A	getSpaceId()	13	13	4
A	getSpaceName()	14	14	4
A	listIndexes()	0	14	3
B	createIndex()	0	16	5

<?php

namespace Tarantool\Mapper\Schema;

use Tarantool\Client;
use Tarantool\Mapper\Contracts;
use Tarantool\Schema\Space;
use Tarantool\Schema\Index;

class Schema implements Contracts\Schema
{
    protected $client;
    protected $spaceSpace;
    protected $indexSpace;
    protected $spaceId = [];

    public function __construct(Client $client)
    {
        $this->client = $client;

        $this->spaceSpace = $client->getSpace('_vspace');
        $this->indexSpace = $client->getSpace('_vindex');
    }

    public function getSpaceId($space)

This method seems to be duplicated in your project.

    {
        if (!array_key_exists($space, $this->spaceId)) {
            $response = $this->spaceSpace->select([$space], Index::SPACE_NAME);
            $data = $response->getData();
            if (!empty($data)) {
                $this->spaceId[$space] = $data[0][0];
            }
        }
        if (array_key_exists($space, $this->spaceId)) {
            return $this->spaceId[$space];
        }
    }

    public function getSpaceName($spaceId)

This method seems to be duplicated in your project.

    {
        if (!in_array($spaceId, $this->spaceId)) {
            $response = $this->spaceSpace->select([$spaceId], 0);
            $data = $response->getData();
            if (!empty($data)) {
                $this->spaceId[$data[0][2]] = $spaceId;
            }
        }

        if (in_array($spaceId, $this->spaceId)) {
            return array_search($spaceId, $this->spaceId);
        }
    }

    public function hasSpace($space)
    {
        return $this->getSpaceId($space) !== null;
    }

    public function createSpace($space)
    {
        $this->client->evaluate("box.schema.space.create('$space')");
    }

    public function hasIndex($space, $index)
    {
        $spaceId = $this->getSpaceId($space);
        $response = $this->indexSpace->select([$spaceId, $index], Index::INDEX_NAME);

        return !empty($response->getData());
    }

    public function listIndexes($space)
    {
        $result = [];
        $response = $this->indexSpace->select([$this->getSpaceId($space)], Index::INDEX_NAME);

        foreach ($response->getData() as $row) {

The expression $response->getData() of type null|array is not guaranteed to be traversable. How about adding an additional type check?

            $result[$row[2]] = [];
            foreach ($row[5] as $f) {
                $result[$row[2]][] = $f[0];
            }
        }

        return $result;
    }

    public function createIndex($space, $index, array $arguments)
    {
        $config = [];
        foreach ($arguments as $k => $v) {
            if (is_array($v)) {
                // convert to lua array
                $v = str_replace(['[', ']'], ['{', '}'], json_encode($v));
            }
            if (is_bool($v)) {
                $v = $v ? 'true' : 'false';
            }
            $config[] = $k.' = '.$v;
        }
        $config = '{'.implode(', ', $config).'}';
        $this->client->evaluate("box.space.$space:create_index('$index', $config)");
    }
}