Tarantool\Mapper\Mapper

Complexity

Total Complexity

25

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	2

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	create()	0	6	1
A	findOne()	0	4	1
A	find()	0	4	1
A	findRepository()	0	10	3
A	getClient()	0	4	1
A	getBootstrap()	0	8	2
A	addPlugin()	0	11	3
A	getPlugin()	0	8	3
A	getPlugins()	0	4	1
A	getRepository()	0	4	1
A	getRepositories()	0	10	3
A	getSchema()	0	4	2
A	remove()	0	4	1
A	save()	0	4	1

<?php

namespace Tarantool\Mapper;

use Tarantool\Client\Client;

This use statement conflicts with another class in this namespace, Tarantool\Mapper\Client.

use Exception;

class Mapper
{
    private $client;
    private $plugins = [];
    private $schema;
    private $bootstrap;

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

    public function addPlugin($class)
    {
        if(!is_subclass_of($class, Plugin::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Tarantool\Mapper\Plugin::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            throw new Exception("Plugin should extend " . Plugin::class . " class");
        }

        $plugin = is_object($class) ? $class : new $class($this);
        $this->plugins[] = $plugin;

        return $plugin;
    }

    public function create($space, $data)
    {
        $instance = $this->getRepository($space)->create($data);
        $this->getRepository($space)->save($instance);
        return $instance;
    }

    public function findOne($space, $params = [])
    {
        return $this->getRepository($space)->findOne($params);
    }

    public function find($space, $params = [])
    {
        return $this->getRepository($space)->find($params);
    }

    public function findRepository(Entity $instance)
    {
        foreach($this->getSchema()->getSpaces() as $space) {
            if($space->getRepository()->knows($instance)) {
                return $space->getRepository();
            }
        }

        throw new Exception("No Repository for given Entity");
    }

    public function getBootstrap()
    {
        if(!$this->bootstrap) {
            $this->bootstrap = new Bootstrap($this);
        }

        return $this->bootstrap;
    }

    public function getClient()
    {
        return $this->client;
    }

    public function getPlugin($class)
    {
        foreach($this->getPlugins() as $plugin) {
            if(is_a($plugin, $class)) {
                return $plugin;
            }
        }
    }

    public function getPlugins()
    {
        return $this->plugins;
    }

    public function getRepository($space)
    {
        return $this->getSchema()->getSpace($space)->getRepository();
    }

    public function getRepositories()
    {
        $repositories = [];
        foreach($this->getSchema()->getSpaces() as $space) {
            if($space->repositoryExists()) {
                $repositories[] = $space->getRepository();
            }
        }
        return $repositories;
    }

    public function getSchema()
    {
        return $this->schema ?: $this->schema = new Schema($this);
    }

    public function remove(Entity $instance)
    {
        $this->findRepository($instance)->remove($instance);
    }

    public function save(Entity $instance)
    {
        $this->findRepository($instance)->save($instance);
    }
}