kalanis\kw_cache\Files\Semaphore

Complexity

Total Complexity

15

Size/Duplication

Total Lines	78
Duplicated Lines	0 %

Test Coverage

Coverage

94.44%

Importance

Changes	1
Bugs	0	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	set()	0	15	4
A	__construct()	0	4	1
A	clear()	0	6	2
A	exists()	0	6	3
A	get()	0	9	3
A	init()	0	13	2

<?php

namespace kalanis\kw_cache\Files;


use kalanis\kw_cache\CacheException;
use kalanis\kw_cache\Interfaces\ICache;
use kalanis\kw_files\Access\CompositeAdapter;
use kalanis\kw_files\FilesException;
use kalanis\kw_files\Traits\TToString;
use kalanis\kw_paths\ArrayPath;
use kalanis\kw_paths\PathsException;
use kalanis\kw_paths\Stuff;
use kalanis\kw_semaphore\Interfaces\ISemaphore;
use kalanis\kw_semaphore\SemaphoreException;


/**
 * Class Semaphore
 * @package kalanis\kw_cache\Files
 * Caching content by files - semaphore for detection
 */
class Semaphore implements ICache
{
    use TToString;

    /** @var CompositeAdapter */
    protected $lib = null;
    /** @var ISemaphore */
    protected $reloadSemaphore = null;
    /** @var string[] */
    protected $cachePath = [ICache::EXT_CACHE];

    public function __construct(CompositeAdapter $lib, ISemaphore $reloadSemaphore)
    {
        $this->lib = $lib;
        $this->reloadSemaphore = $reloadSemaphore;
    }

    public function init(string $what): void
    {
        try {
            $arr = new ArrayPath();
            $arr->setString($what);
            $this->cachePath = array_merge(
                $arr->getArrayDirectory(),
                [$arr->getFileName() . ICache::EXT_CACHE]
            );
            // @codeCoverageIgnoreStart
        } catch (PathsException $ex) {
            // just when it has problems with separating the path
            throw new CacheException($ex->getMessage(), $ex->getCode(), $ex);
        }
        // @codeCoverageIgnoreEnd
    }

    public function exists(): bool
    {
        try {
            return $this->lib->exists($this->cachePath) && !$this->reloadSemaphore->has();
        } catch (SemaphoreException | FilesException | PathsException $ex) {
            throw new CacheException($ex->getMessage(), $ex->getCode(), $ex);
        }
    }

    public function set(string $content): bool
    {
        try {
            $result = $this->lib->saveFile($this->cachePath, $content);
            if (false === $result) {
                return false;
            }
            // remove signal to save
            if ($this->reloadSemaphore->has()) {
                $this->reloadSemaphore->remove();
            }
        } catch (SemaphoreException | FilesException | PathsException $ex) {
            throw new CacheException($ex->getMessage(), $ex->getCode(), $ex);
        }
        return true;
    }

    public function get(): string
    {
        try {
            return $this->exists()
                ? $this->toString(Stuff::arrayToPath($this->cachePath), $this->lib->readFile($this->cachePath))
                : ''
            ;
        } catch (FilesException | PathsException $ex) {
            throw new CacheException($ex->getMessage(), $ex->getCode(), $ex);
        }
    }

    public function clear(): void
    {
        try {
            $this->lib->deleteFile($this->cachePath);
        } catch (FilesException | PathsException $ex) {
            throw new CacheException($ex->getMessage(), $ex->getCode(), $ex);
        }
    }
}