Isswp101\Persimmon\Repository\RuntimeCacheRepository

Complexity

Total Complexity

17

Size/Duplication

Total Lines	81
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getHash()	0	4	1
A	__construct()	0	5	1
A	instantiate()	0	8	2
B	find()	0	15	5
A	all()	0	4	1
A	insert()	0	5	1
A	update()	0	12	3
A	delete()	0	5	1
A	hasAllColumns()	0	4	1
A	setAllColumns()	0	4	1

<?php

namespace Isswp101\Persimmon\Repository;

use Isswp101\Persimmon\Collection\Collection;
use Isswp101\Persimmon\Collection\ICollection;
use Isswp101\Persimmon\Contracts\Storable;
use Isswp101\Persimmon\Exceptions\ClassTypeErrorException;
use Isswp101\Persimmon\Helpers\Cast;
use Isswp101\Persimmon\QueryBuilder\IQueryBuilder;

class RuntimeCacheRepository implements ICacheRepository
{
    private $collection;
    private $allColumns;

    public function __construct()
    {
        $this->collection = new Collection();
        $this->allColumns = new Collection();
    }

    private function getHash(string $class, string $id): string
    {
        return $class . '@' . $id;
    }

    public function instantiate(string $class): Storable
    {
        $instance = new $class;
        if (!$instance instanceof Storable) {
            throw new ClassTypeErrorException(Storable::class);
        }
        return $instance;
    }

    public function find(string $id, string $class, array $columns = []): ?Storable
    {
        if (!$columns && !$this->hasAllColumns($id, $class)) {

The expression $columns of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return null;
        }
        $cachedModel = $this->collection->get($this->getHash($class, $id));
        if ($cachedModel != null && $columns) {

The expression $columns of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $cachedModel = Cast::storable($cachedModel);
            $model = $this->instantiate($class);
            $model->setPrimaryKey($cachedModel->getPrimaryKey());
            $model->fill(array_intersect_key($cachedModel->toArray(), array_flip($columns)));
            return $model;
        }
        return $cachedModel;
    }

    public function all(IQueryBuilder $query, string $class, callable $callback = null): ICollection
    {
        return $this->collection;
    }

    public function insert(Storable $model): void
    {
        $hash = $this->getHash(get_class($model), $model->getPrimaryKey());
        $this->collection->put($hash, $model);
    }

    public function update(Storable $model): void
    {
        $hash = $this->getHash(get_class($model), $model->getPrimaryKey());
        if (!$this->collection->has($hash)) {
            $this->collection->put($hash, $model);
        } else {
            $cachedModel = $this->collection->get($hash);
            foreach ($model->toArray() as $key => $value) {
                $cachedModel->{$key} = $value;
            }
        }
    }

    public function delete(Storable $model): void
    {
        $hash = $this->getHash(get_class($model), $model->getPrimaryKey());
        $this->collection->forget($hash);
    }

    public function hasAllColumns(string $id, string $class): bool
    {
        return $this->allColumns->has($this->getHash($class, $id));
    }

    public function setAllColumns(string $id, string $class): void
    {
        $this->allColumns->put($this->getHash($class, $id), true);
    }
}