Chubbyphp\Model\Resolver

Complexity

Total Complexity

14

Size/Duplication

Total Lines	167
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	__call()	0	14	2
A	find()	0	4	1
A	findOneBy()	0	4	1
A	findBy()	0	9	1
A	lazyFind()	0	6	1
A	lazyFindOneBy()	0	6	1
A	lazyFindBy()	0	11	1
A	persist()	0	4	1
A	remove()	0	4	1
A	getRepositoryByClass()	0	12	3

<?php

declare(strict_types=1);

namespace Chubbyphp\Model;

use Interop\Container\ContainerInterface;

final class Resolver implements ResolverInterface
{
    /**
     * @var ContainerInterface|RepositoryInterface[]
     */
    private $container;

    /**
     * @var string[]|array
     */
    private $repositoryKeys;

    /**
     * @param ContainerInterface $container
     * @param array              $repositoryKeys
     */
    public function __construct(ContainerInterface $container, array $repositoryKeys)
    {
        $this->container = $container;
        $this->repositoryKeys = $repositoryKeys;
    }

    /**
     * @param string $name
     * @param array  $arguments
     *
     * @return mixed
     */
    public function __call($name, $arguments)
    {
        $modelClass = array_shift($arguments);

        if (substr($name, 0, 4) === 'lazy') {
            $name = substr($name, 4);

            return function () use ($modelClass, $name, $arguments) {
                return $this->getRepositoryByClass($modelClass)->$name(...$arguments);
            };
        }

        return $this->getRepositoryByClass($modelClass)->$name(...$arguments);
    }

    /**
     * @param string $modelClass
     * @param string $id
     *
     * @return ModelInterface|null
     */
    public function find(string $modelClass, string $id)
    {
        return $this->getRepositoryByClass($modelClass)->find($id);
    }

    /**
     * @param string     $modelClass
     * @param array      $criteria
     * @param array|null $orderBy
     *
     * @return ModelInterface|null
     */
    public function findOneBy(string $modelClass, array $criteria, array $orderBy = null)
    {
        return $this->getRepositoryByClass($modelClass)->findOneBy($criteria, $orderBy);
    }

    /**
     * @param string     $modelClass
     * @param array      $criteria
     * @param array|null $orderBy
     * @param int|null   $limit
     * @param int|null   $offset
     *
     * @return array
     */
    public function findBy(
        string $modelClass,
        array $criteria,
        array $orderBy = null,
        int $limit = null,
        int $offset = null
    ): array {
        return $this->getRepositoryByClass($modelClass)->findBy($criteria, $orderBy, $limit, $offset);
    }

    /**
     * @param string $modelClass
     * @param string $id
     *
     * @return \Closure
     */
    public function lazyFind(string $modelClass, string $id): \Closure
    {
        return function () use ($modelClass, $id) {
            return $this->find($modelClass, $id);
        };
    }

    /**
     * @param string     $modelClass
     * @param array      $criteria
     * @param array|null $orderBy
     *
     * @return \Closure
     */
    public function lazyFindOneBy(string $modelClass, array $criteria, array $orderBy = null): \Closure
    {
        return function () use ($modelClass, $criteria, $orderBy) {
            return $this->findOneBy($modelClass, $criteria, $orderBy);
        };
    }

    /**
     * @param string     $modelClass
     * @param array      $criteria
     * @param array|null $orderBy
     * @param int|null   $limit
     * @param int|null   $offset
     *
     * @return \Closure
     */
    public function lazyFindBy(
        string $modelClass,
        array $criteria,
        array $orderBy = null,
        int $limit = null,
        int $offset = null
    ): \Closure {
        return function () use ($modelClass, $criteria, $orderBy, $limit, $offset) {
            return $this->findBy($modelClass, $criteria, $orderBy, $limit, $offset);
        };
    }

    /**
     * @param ModelInterface $model
     */
    public function persist(ModelInterface $model)
    {
        $this->getRepositoryByClass(get_class($model))->persist($model);
    }

    /**
     * @param ModelInterface $model
     */
    public function remove(ModelInterface $model)
    {
        $this->getRepositoryByClass(get_class($model))->remove($model);
    }

    /**
     * @param string $modelClass
     *
     * @return RepositoryInterface
     */
    private function getRepositoryByClass(string $modelClass): RepositoryInterface
    {
        foreach ($this->repositoryKeys as $repositoryKey) {
            /** @var RepositoryInterface $repository */
            $repository = $this->container->get($repositoryKey);
            if ($repository->isResponsible($modelClass)) {
                return $repository;
            }
        }

        throw MissingRepositoryException::create($modelClass);
    }
}