kalanis\kw_cache\Storage\Basic

Complexity

Total Complexity

11

Size/Duplication

Total Lines	58
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	set()	0	7	2
A	clear()	0	7	2
A	exists()	0	7	2
A	init()	0	7	1
A	get()	0	7	3
A	__construct()	0	3	1

<?php

namespace kalanis\kw_cache\Storage;


use kalanis\kw_cache\CacheException;
use kalanis\kw_cache\Interfaces\ICache;
use kalanis\kw_paths\ArrayPath;
use kalanis\kw_paths\PathsException;
use kalanis\kw_paths\Stuff;
use kalanis\kw_storage\Interfaces\IStorage;
use kalanis\kw_storage\StorageException;


/**
 * Class Basic
 * @package kalanis\kw_cache\Storage
 * Caching content in storage
 */
class Basic implements ICache
{
    protected IStorage $cacheStorage;
    /** @var string[] */
    protected array $cachePath = [ICache::EXT_CACHE];

    public function __construct(IStorage $cacheStorage)
    {
        $this->cacheStorage = $cacheStorage;
    }

    public function init(array $what): void
    {
        $arr = new ArrayPath();
        $arr->setArray($what);
        $this->cachePath = array_merge(
            $arr->getArrayDirectory(),
            [$arr->getFileName() . ICache::EXT_CACHE]
        );
    }

    public function exists(): bool
    {
        try {
            $cachePath = Stuff::arrayToPath($this->cachePath);
            return $this->cacheStorage->exists($cachePath);
        } catch (StorageException | PathsException $ex) {
            throw new CacheException($ex->getMessage(), $ex->getCode(), $ex);
        }
    }

    public function set(string $content): bool
    {
        try {
            $cachePath = Stuff::arrayToPath($this->cachePath);
            return $this->cacheStorage->write($cachePath, $content);
        } catch (StorageException | PathsException $ex) {
            throw new CacheException($ex->getMessage(), $ex->getCode(), $ex);
        }
    }

    public function get(): string
    {
        try {
            $cachePath = Stuff::arrayToPath($this->cachePath);
            return $this->exists() ? strval($this->cacheStorage->read($cachePath)) : '';
        } catch (StorageException | PathsException $ex) {
            throw new CacheException($ex->getMessage(), $ex->getCode(), $ex);
        }
    }

    public function clear(): void
    {
        try {
            $cachePath = Stuff::arrayToPath($this->cachePath);
            $this->cacheStorage->remove($cachePath);
        } catch (StorageException | PathsException $ex) {
            throw new CacheException($ex->getMessage(), $ex->getCode(), $ex);
        }
    }
}