Chubbyphp\Model\Collection\LazyModelCollection

Complexity

Total Complexity

19

Size/Duplication

Total Lines	171
Duplicated Lines	14.62 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	loadModels()	0	13	2
A	modelsWithIdKey()	15	15	3
A	current()	0	6	1
A	next()	0	6	1
A	key()	0	6	1
A	valid()	0	6	1
A	rewind()	0	6	1
A	set()	0	6	1
A	persist()	0	8	2
A	remove()	10	10	3
A	jsonSerialize()	0	11	2

<?php

namespace Chubbyphp\Model\Collection;

use Chubbyphp\Model\ModelInterface;
use Chubbyphp\Model\RepositoryInterface;

class LazyModelCollection implements ModelCollectionInterface
{
    /**
     * @var RepositoryInterface
     */
    private $repository;

    /**
     * @var \Closure;
     */
    private $resolver;

    /**
     * @var ModelInterface[]|array
     */
    private $initialModels;

    /**
     * @var ModelInterface[]|array
     */
    private $models;

    /**
     * LazyModelCollection constructor.
     *
     * @param RepositoryInterface $repository
     * @param array               $criteria
     * @param array|null          $orderBy
     * @param int|null            $limit
     * @param int|null            $offset
     */
    public function __construct(
        RepositoryInterface $repository,
        array $criteria,
        array $orderBy = null,
        int $limit = null,
        int $offset = null
    ) {
        $this->repository = $repository;
        $this->resolver = function () use ($repository, $criteria, $orderBy, $limit, $offset) {
            return $repository->findBy($criteria, $orderBy, $limit, $offset);
        };
    }

    private function loadModels()
    {
        if (null !== $this->initialModels) {
            return;
        }

        $resolver = $this->resolver;

        $models = $this->modelsWithIdKey((array) $resolver());

        $this->initialModels = $models;
        $this->models = $models;
    }

    /**
     * @param ModelInterface[]|array $models
     *
     * @return ModelInterface[]|array
     */
    private function modelsWithIdKey(array $models): array

This method seems to be duplicated in your project.

    {
        $modelsWithIdKey = [];
        foreach ($models as $model) {
            if (!$model instanceof ModelInterface) {
                throw new \InvalidArgumentException(
                    sprintf('Model with index %d needs to implement: %s', ModelInterface::class)
                );
            }

            $modelsWithIdKey[$model->getId()] = $model;
        }

        return $modelsWithIdKey;
    }

    /**
     * @return ModelInterface
     */
    public function current()
    {
        $this->loadModels();

        return current($this->models);
    }

    /**
     * @return ModelInterface|false
     */
    public function next()
    {
        $this->loadModels();

        return next($this->models);
    }

    /**
     * @return string
     */
    public function key()
    {
        $this->loadModels();

        return key($this->models);
    }

    /**
     * @return bool
     */
    public function valid()
    {
        $this->loadModels();

        return (bool) current($this->models);
    }

    public function rewind()
    {
        $this->loadModels();

        reset($this->models);
    }

    /**
     * @param ModelInterface[]|array $models
     */
    public function set(array $models)
    {
        $this->loadModels();

        $this->models = $this->modelsWithIdKey($models);
    }

    public function persist()
    {
        $this->loadModels();

        foreach ($this->models as $model) {
            $this->repository->persist($model);
        }
    }

    public function remove()

This method seems to be duplicated in your project.

    {
        $this->loadModels();

        foreach ($this->initialModels as $initialModel) {
            if (!isset($this->models[$initialModel->getId()])) {
                $this->repository->remove($initialModel);
            }
        }
    }

    /**
     * @return array
     */
    public function jsonSerialize(): array
    {
        $this->loadModels();

        $serializedModels = [];
        foreach ($this->models as $model) {
            $serializedModels[] = $model->jsonSerialize();
        }

        return $serializedModels;
    }
}