Cache::createKeyFromPath() - Code Metrics - Inspection of "Apply fixes from StyleCI" - Cecilapp/Cecil - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — analysis-gOJ73E ( 71f184 )

by Arnaud
created 2021-06-01 00:42 UTC
Cache::createKeyFromPath() A

↳ Parent: Cache
Complexity

Conditions	2
Paths	2
Size

Total Lines	8
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
eloc	4
nc	2
nop	2
dl	0
loc	8
rs	10
c	0
b	0
f	0
<?php
/**
 * This file is part of the Cecil/Cecil package.
 *
 * Copyright (c) Arnaud Ligny <[email protected]>
 *
 * 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\Collection\Page\Page;
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 $cacheDir;

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

    /**
     * {@inheritdoc}
     */
    public function get($key, $default = null)
    {
        try {
            $key = $this->prepareKey($key);
            $data = unserialize(Util\File::fileGetContents($this->getFilePathname($key)));
            $data = unserialize(/** @scrutinizer ignore-type */ Util\File::fileGetContents($this->getFilePathname($key)));
        } catch (Exception $e) {
            $this->builder->getLogger()->error($e->getMessage());

            return $default;
        }

        return $data['value'];
    }

    /**
     * {@inheritdoc}
     */
    public function set($key, $value, $ttl = null)
    {
        try {
            $key = $this->prepareKey($key);
            $data = serialize([
                'value'      => $value,
                'expiration' => time() + $ttl,
            ]);

            $this->prune($key);
            Util\File::getFS()->dumpFile($this->getFilePathname($key), $data);
        } catch (Exception $e) {
            $this->builder->getLogger()->error($e->getMessage());

            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function delete($key)
    {
        try {
            $key = $this->prepareKey($key);
            Util\File::getFS()->remove($this->getFilePathname($key));
            $this->prune($key);
        } catch (Exception $e) {
            $this->builder->getLogger()->error($e->getMessage());

            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function clear()
    {
        try {
            Util\File::getFS()->remove($this->cacheDir);
        } catch (Exception $e) {
            $this->builder->getLogger()->error($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)
    {
        $key = $this->prepareKey($key);
        if (!Util\File::getFS()->exists($this->getFilePathname($key))) {
            return false;
        }

        return true;
    }

    /**
     * Creates a cache key from a value.
     *
     * @param string $value
     *
     * @return string MD5 hash
     */
    public function createKeyFromValue(string $value): string
    {
        return hash('md5', $value);
    }

    /**
     * Creates a cache key from a path.
     *
     * @param string $path
     * @param string $relativePath
     *
     * @return string $relativePath + '__' + MD5 hash
     */
    public function createKeyFromPath(string $path, string $relativePath): string
    {
        if (false === $content = Util\File::fileGetContents($path)) {
            throw new Exception(sprintf('Can\'t create cache key for "%s"', $path));
        }
        $key = $this->prepareKey(\sprintf('%s__%s', $relativePath, $this->createKeyFromValue($content)));

        return $key;
    }

    /**
     * Creates a cache key from an Asset.
     *
     * @param Asset $asset
     *
     * @return string $path + '__' + MD5 hash
     */
    public function createKeyFromAsset(Asset $asset): string
    {
        $key = $this->prepareKey(\sprintf('%s__%s', $asset['path'], $this->createKeyFromValue($asset['source'])));
        $key = $this->prepareKey(\sprintf('%s__%s', $asset['path'], $this->createKeyFromValue(/** @scrutinizer ignore-type */ $asset['source'])));

        return $key;
    }

    /**
     * Returns cache file pathname from key.
     *
     * @param string $key
     *
     * @return string
     */
    private function getFilePathname(string $key): string
    {
        return Util::joinFile($this->cacheDir, $key);
    }

    /**
     * Removes previous cache files.
     *
     * @param string $key
     *
     * @return bool
     */
    private function prune(string $key): bool
    {
        try {
            $key = $this->prepareKey($key);
            $pattern = Util::joinFile($this->cacheDir, explode('__', $key)[0]).'*';
            foreach (glob($pattern) as $filename) {
                Util\File::getFS()->remove($filename);
            }
        } catch (Exception $e) {
            $this->builder->getLogger()->error($e->getMessage());

            return false;
        }

        return true;
    }

    /**
     * $key must be a string.
     *
     * @param string $key
     *
     * @return string
     */
    private function prepareKey(string $key): string
    {
        $key = str_replace(['https://', 'http://'], '', $key);
        $key = Page::slugify($key);
        $key = trim($key, '/');
        $key = str_replace(['\\', '/'], ['-', '-'], $key);

        return $key;
    }
}

Cecilapp / Cecil

Push — analysis-gOJ73E ( 71f184 )

Cache::createKeyFromPath() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
