Tarantool\Mapper\Plugin\NestedSet

Complexity

Total Complexity

22

Size/Duplication

Total Lines	161
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	addIndexes()	0	19	4
B	beforeCreate()	0	56	9
A	beforeRemove()	0	53	3
A	isNested()	0	14	4
A	resetNestedSpacesCache()	0	4	1

<?php

namespace Tarantool\Mapper\Plugin;

use Tarantool\Mapper\Entity;
use Tarantool\Mapper\Mapper;
use Tarantool\Mapper\Plugin;
use Tarantool\Mapper\Space;

class NestedSet extends Plugin
{
    private $keys = ['id', 'parent', 'root', 'depth', 'left', 'right'];
    private $nestedSpaces = [];

    public function __construct(Mapper $mapper)
    {
        $this->mapper = $mapper;
    }

    public function addIndexes(Space $space)
    {
        $indexes = [
            ['id'],
            [
                'fields' => ['parent'],
                'unique' => false,
            ],
            ['root', 'left'],
            ['root', 'right'],
        ];

        foreach ($indexes as $index) {
            $fields = array_key_exists('fields', $index) ? $index['fields'] : $index;
            if ($space->castIndex(array_flip($fields), true) === null) {
                $space->createIndex($index);
            }
        }
    }

    public function beforeCreate(Entity $entity, Space $space)
    {
        if ($this->isNested($space)) {
            $repository = $space->getRepository();

            if ($entity->parent) {
                $parent = $repository->findOne($entity->parent);

The property parent does not seem to exist in Tarantool\Mapper\Entity.

                $entity->depth = $parent->depth + 1;

The property depth does not seem to exist in Tarantool\Mapper\Entity.

                $updateLeft = [];
                $updateRight = [];
                foreach ($repository->find(['root' => $entity->root]) as $node) {

The property root does not seem to exist in Tarantool\Mapper\Entity.

                    if ($node->right >= $parent->right) {
                        if ($node->left > $parent->right) {
                            $updateLeft[$node->left] = $node;
                        }
                        $updateRight[$node->right] = $node;
                    }
                }

                $entity->left = $parent->right;

The property left does not seem to exist in Tarantool\Mapper\Entity.

                $entity->right = $entity->left + 1;

The property right does not seem to exist in Tarantool\Mapper\Entity.

                krsort($updateRight);
                foreach ($updateRight as $node) {
                    $node->right += 2;
                    $node->save();
                }

                krsort($updateLeft);
                foreach ($updateLeft as $node) {
                    $node->left += 2;
                    $node->save();
                }
            } else {
                // new root
                $map = $space->getTupleMap();

                $entity->root = $entity->root ?: 0;
                $max = $this->mapper->getClient()->evaluate("
                    local max = 0
                    local root = $entity->root
                    for i, n in box.space.tree.index.root_right:pairs(root, {iterator = 'le'}) do
                        if n[$map->root] == root then
                            max = n[$map->right]
                        end
                        break
                    end
                    return max
                ")->getData()[0];

                $entity->left = $max + 1;
                $entity->right = $entity->left + 1;
            }
        }
    }

    public function beforeRemove(Entity $instance, Space $space)
    {
        $spaceName = $space->getName();
        $map = $space->getTupleMap();

        $result = $this->mapper->getClient()->evaluate("
            local removed_node = box.space.$spaceName:get($instance->id)

The property id does not seem to exist in Tarantool\Mapper\Entity.

            local remove_list = {}
            local update_list = {}
            for i, current in box.space.$spaceName.index.root_left:pairs({removed_node[$map->root], removed_node[$map->left]}, 'gt') do
                if current[$map->root] ~= removed_node[$map->root] then
                    break
                end
                if current[$map->left] < removed_node[$map->right] then
                    table.insert(remove_list, current[$map->id])
                else
                    table.insert(update_list, current[$map->id])
                end
            end

            local delta = removed_node[$map->right] - removed_node[$map->left] + 1

            for i, id in ipairs(remove_list) do
                box.space.$spaceName:delete(id)
            end

            box.space.$spaceName:update($instance->id, {
                {'=', $map->left, 0},
                {'=', $map->right, 0},
            })

            for i, id in pairs(update_list) do
                box.space.$spaceName:update(id, {
                    {'-', $map->left, delta},
                    {'-', $map->right, delta}
                })
            end

            return remove_list, update_list, delta, removed_node
        ")->getData();

        // remove
        foreach ($result[0] as $id) {
            $space->getRepository()->forget($id);
        }

        // update
        foreach ($result[1] as $id) {
            $space->getRepository()->sync($id);
        }

        $space->getRepository()->flushCache();
    }

    public function isNested(Space $space, $force = false)
    {
        $spaceName = $space->getName();
        if ($force || !array_key_exists($spaceName, $this->nestedSpaces)) {
            $fields = [];
            foreach ($space->getFormat() as $field) {
                $fields[] = $field['name'];
            }

            $this->nestedSpaces[$spaceName] = !count(array_diff($this->keys, $fields));
        }

        return $this->nestedSpaces[$spaceName];
    }

    public function resetNestedSpacesCache()
    {
        $this->nestedSpaces = [];
    }
}