Cecil\Assets\Cache

Complexity

Total Complexity

23

Size/Duplication

Total Lines	209
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	get()	0	3	2
A	__construct()	0	7	1
A	getValueFilePathname()	0	6	1
A	createHash()	0	3	1
A	delete()	0	12	2
A	pruneHashFiles()	0	14	3
A	set()	0	18	3
A	getHashFilePathname()	0	6	1
A	has()	0	11	3
A	preparesHashFile()	0	3	1
A	getMultiple()	0	3	1
A	deleteMultiple()	0	3	1
A	setMultiple()	0	3	1
A	clear()	0	11	2

<?php
/**
 * This file is part of the Cecil/Cecil package.
 *
 * Copyright (c) Arnaud Ligny <arnaud@ligny.fr>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Cecil\Assets;

use Cecil\Builder;
use Cecil\Config;
use Cecil\Util;
use Exception;
use Psr\SimpleCache\CacheInterface;

class Cache implements CacheInterface
{
    /** @var Builder */
    protected $builder;
    /** @var Config */
    protected $config;
    /** @var string */
    protected $pool;
    /** @var string */
    protected $rootPath;
    /** @var string */
    protected $cacheDir;

    /**
     * @param Builder $builder
     * @param string  $pool
     * @param string  $rootPath
     */
    public function __construct(Builder $builder, string $pool, string $rootPath)
    {
        $this->builder = $builder;
        $this->config = $builder->getConfig();
        $this->pool = $pool;
        $this->rootPath = $rootPath;
        $this->cacheDir = Util::joinFile($this->config->getCachePath(), $pool);
    }

    /**
     * {@inheritdoc}
     */
    public function get($key, $default = null)
    {
        return file_get_contents($this->getValueFilePathname($key)) ?: $default;
    }

    /**
     * {@inheritdoc}
     */
    public function set($key, $value, $ttl = null)
    {
        if ($ttl !== null) {
            throw new Exception(sprintf('%s::%s(%s) not yet implemented.', __CLASS__, __FUNCTION__, 'ttl'));
        }

        try {
            Util::getFS()->dumpFile($this->getValueFilePathname($key), $value);
            $this->pruneHashFiles($key);
            Util::getFS()->mkdir(Util::joinFile($this->cacheDir, 'hash'));
            Util::getFS()->touch($this->getHashFilePathname($key, $this->createHash($value)));
        } catch (Exception $e) {
            $this->builder->getLogger()->warning($e->getMessage());

            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function delete($key)
    {
        try {
            Util::getFS()->remove($this->getValueFilePathname($key));
            $this->pruneHashFiles($key);
        } catch (Exception $e) {
            $this->builder->getLogger()->warning($e->getMessage());

            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function clear()
    {
        try {
            Util::getFS()->remove($this->cacheDir);
        } catch (Exception $e) {
            $this->builder->getLogger()->warning($e->getMessage());

            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function getMultiple($keys, $default = null)
    {
        throw new Exception(sprintf('%s::%s not yet implemented.', __CLASS__, __FUNCTION__));
    }

    /**
     * {@inheritdoc}
     */
    public function setMultiple($values, $ttl = null)
    {
        throw new Exception(sprintf('%s::%s not yet implemented.', __CLASS__, __FUNCTION__));
    }

    /**
     * {@inheritdoc}
     */
    public function deleteMultiple($keys)
    {
        throw new Exception(sprintf('%s::%s not yet implemented.', __CLASS__, __FUNCTION__));
    }

    /**
     * {@inheritdoc}
     */
    public function has($key)
    {
        if ($this->config->get('cache.enabled') === false) {
            return false;
        }

        if (!Util::getFS()->exists($this->getValueFilePathname($key))) {
            return false;
        }

        return true;
    }

    /**
     * Creates the hash (MD5) of a value.
     *
     * @param string $value
     *
     * @return string
     */
    public function createHash(string $value): string
    {
        return hash('md5', $value);
    }

    /**
     * Returns value file pathname.
     *
     * @param string $key
     *
     * @return string
     */
    protected function getValueFilePathname(string $key): string
    {
        return Util::joinFile(
            $this->cacheDir,
            'files',
            $key
        );
    }

    /**
     * Returns hash file pathname.
     *
     * @param string $key
     * @param string $hash
     *
     * @return string
     */
    protected function getHashFilePathname(string $key, string $hash): string
    {
        return Util::joinFile(
            $this->cacheDir,
            'hash',
            $this->preparesHashFile($key).trim($hash)
        );
    }

    /**
     * Prepares hash file.
     *
     * @param string $key
     *
     * @return string
     */
    private function preparesHashFile(string $key): string
    {
        return str_replace(DIRECTORY_SEPARATOR, '-', $key).'_';
    }

    /**
     * Removes previous hash files.
     *
     * @param string $key
     *
     * @return bool
     */
    private function pruneHashFiles(string $key): bool
    {
        try {
            $pattern = Util::joinFile($this->cacheDir, 'hash', $this->preparesHashFile($key)).'*';
            foreach (glob($pattern) as $filename) {
                Util::getFS()->remove($filename);
            }
        } catch (Exception $e) {
            $this->builder->getLogger()->warning($e->getMessage());

            return false;
        }

        return true;
    }
}