Tarantool\Mapper\Repository

Complexity

Total Complexity

55

Size/Duplication

Total Lines	249
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes	36
Bugs	8	Features	9

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
D	create()	0	34	10
A	__call()	0	13	3
A	findOne()	0	4	1
C	find()	0	65	19
A	knows()	0	4	1
A	remove()	0	7	1
C	save()	0	49	12
A	register()	0	11	4
B	generateId()	0	27	2
A	getType()	0	4	1

<?php

namespace Tarantool\Mapper;

use BadMethodCallException;
use LogicException;

class Repository implements Contracts\Repository
{
    private $type;
    private $entities = [];
    private $keyMap = [];
    private $findCache = [];

    private $magicMethodRules = [
        'by' => false,
        'firstBy' => true,
        'oneBy' => true,
    ];

    public function __construct(Contracts\Type $type)
    {
        $this->type = $type;
    }

    public function create($params = null)
    {
        if ($params && !is_array($params)) {
            $params = [$params];
        }

        $data = [];
        foreach ($params as $k => $v) {
            if (is_numeric($k)) {
                if ($v instanceof Contracts\Entity) {
                    $type = $this->type->getManager()->findRepository($v)->getType();
                    $k = $this->type->getReferenceProperty($type);
                } else {
                    $primitive = [];
                    foreach ($this->type->getProperties() as $property) {
                        if (!$this->type->isReference($property)) {
                            $primitive[] = $property;
                        }
                    }
                    if (count($primitive) == 2) {
                        $k = $primitive[1];
                    } else {
                        throw new \Exception("Can't calculate key name");
                    }
                }
            }
            if (!$this->type->hasProperty($k)) {
                throw new \Exception("Unknown property $k");
            }
            $data[$k] = $this->type->encodeProperty($k, $v);
        }

        return $this->register(new Entity($data));
    }

    public function __call($method, $arguments)
    {
        foreach ($this->magicMethodRules as $prefix => $oneItem) {
            if (substr($method, 0, strlen($prefix)) == $prefix) {
                $tail = substr($method, strlen($prefix));
                $fields = array_map('strtolower', explode('And', $tail));

                return $this->find(array_combine($fields, $arguments), $oneItem);
            }
        }

        throw new BadMethodCallException("Method $method not found");
    }

    public function findOne($params)
    {
        return $this->find($params, true);

The expression $this->find($params, true); of type Tarantool\Mapper\Contracts\Entity|Tarantool\Mapper\Contracts\Entity[] adds the type Tarantool\Mapper\Contracts\Entity[] to the return on line 77 which is incompatible with the return type declared by the interface Tarantool\Mapper\Contracts\Repository::findOne of type Tarantool\Mapper\Contracts\Entity.

    }

    public function find($params = [], $oneItem = false)
    {
        $query = [];

        if (is_string($params) && 1 * $params == $params) {
            $params = 1 * $params;
        }

        if (is_int($params)) {
            if (isset($this->keyMap[$params])) {
                return $this->entities[$this->keyMap[$params]];
            }
            $query = [
                'id' => $params,
            ];
            $oneItem = true;
        }

        if ($params instanceof Contracts\Entity) {
            $params = [$params];
        }

        if (is_array($params)) {
            foreach ($params as $key => $value) {
                if (is_numeric($key) && $value instanceof Contracts\Entity) {
                    $type = $this->type->getManager()->findRepository($value)->getType();
                    $key = $this->type->getReferenceProperty($type);
                }
                if ($this->type->hasProperty($key)) {
                    $query[$key] = $this->type->encodeProperty($key, $value);
                }
            }
        }

        $findKey = md5(json_encode($query));
        if (array_key_exists($findKey, $this->findCache)) {
            return $this->findCache[$findKey];
        }

        $index = $this->type->findIndex(array_keys($query));
        $values = count($query) ? $this->type->getIndexTuple($index, $query) : [];

        $data = $this->type->getSpace()->select($values, $index);

        $result = [];
        if (!empty($data->getData())) {
            foreach ($data->getData() as $tuple) {
                $data = $this->type->fromTuple($tuple);
                if (isset($data['id']) && array_key_exists($data['id'], $this->keyMap)) {
                    $entity = $this->entities[$this->keyMap[$data['id']]];
                    $entity->update($data);
                } else {
                    $entity = new Entity($data);
                    $this->register($entity);
                }
                if ($oneItem) {
                    return $this->findCache[$findKey] = $entity;
                }
                $result[] = $entity;
            }
        }
        if (!$oneItem) {
            return $this->findCache[$findKey] = $result;

The return type of return $this->findCache[$findKey] = $result; (array) is incompatible with the return type declared by the interface Tarantool\Mapper\Contracts\Repository::find of type Tarantool\Mapper\Contracts\Entity|Tarantool\Mapper\Contracts\Entity[].

        }
    }

    /**
     * @return Entity
     */
    public function knows(Contracts\Entity $entity)
    {
        return in_array($entity, $this->entities);
    }

    public function remove(Contracts\Entity $entity)
    {
        unset($this->entities[$this->keyMap[$entity->id]]);
        unset($this->keyMap[$entity->id]);

        $this->type->getSpace()->delete([$entity->id]);

Accessing id on the interface Tarantool\Mapper\Contracts\Entity suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    public function save(Contracts\Entity $entity)
    {
        if (!$this->knows($entity)) {
            throw new LogicException('Entity is not related with this repository');
        }

        if (!$entity->getId()) {
            $this->generateId($entity);
            $tuple = $this->type->getTuple($entity->toArray());

            $required = $this->type->getRequiredProperties();

            foreach ($this->type->getProperties() as $index => $field) {
                if (in_array($field, $required) && !array_key_exists($index, $tuple)) {
                    if ($this->type->isReference($field)) {
                        $tuple[$index] = 0;
                    } else {
                        $tuple[$index] = '';
                    }
                }
            }

            // normalize tuple
            if (array_values($tuple) != $tuple) {
                // index was skipped
                $max = max(array_keys($tuple));
                foreach (range(0, $max) as $index) {
                    if (!array_key_exists($index, $tuple)) {
                        $tuple[$index] = null;
                    }
                }
                ksort($tuple);
            }

            $this->type->getSpace()->insert($tuple);
        } else {
            $changes = $entity->pullChanges();
            if (count($changes)) {
                $operations = [];
                foreach ($this->type->getTuple($changes) as $key => $value) {
                    $operations[] = ['=', $key, $value];
                }

                $this->type->getSpace()->update($entity->getId(), $operations);
            }
        }

        return $entity;
    }

    private function register(Contracts\Entity $entity)
    {
        if (!$this->knows($entity)) {
            $this->entities[] = $entity;
        }
        if ($entity->getId() && !array_key_exists($entity->getId(), $this->keyMap)) {
            $this->keyMap[$entity->getId()] = array_search($entity, $this->entities);
        }

        return $entity;
    }

    private function generateId(Contracts\Entity $entity)
    {
        $manager = $this->type->getManager();
        $name = $this->type->getName();

$name is not used, you could remove the assignment.

        $spaceId = $this->type->getSpaceId();

        $sequence = $manager->get('sequence')->oneBySpace($spaceId);
        if (!$sequence) {
            $sequence = $manager->get('sequence')->create([
                'space' => $spaceId,
                'value' => 0,
            ]);
            $manager->save($sequence);
        }

        $nextValue = +$manager->getMeta()
            ->get('sequence')
            ->getSpace()
            ->update($sequence->id, [['+', 2, 1]])
            ->getData()[0][2];

        $entity->setId($nextValue);

        $this->register($entity);

        return $entity;
    }

    public function getType()
    {
        return $this->type;
    }
}