CRUDlex\YamlReader

Complexity

Total Complexity

14

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

97.3%

Importance

Changes	1
Bugs	0	Features	1

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getCacheFile()	0	3	1
A	__construct()	0	3	1
A	readFromCache()	0	10	4
A	writeToCache()	0	12	4
A	read()	0	19	4

<?php

/*
 * This file is part of the CRUDlex package.
 *
 * (c) Philip Lehmann-Böhm <philip@philiplb.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace CRUDlex;

use Symfony\Component\Yaml\Yaml;

/**
 * Reads Yaml files and caches them if a writable path is given. The cache is used first on the next read.
 * It is a simple PHP class internally.
 */
class YamlReader {

    /**
     * The path for the cache files.
     */
    protected $cachePath;

    /**
     * Gets an absolute path for a cache file.
     *
     * @param string $fileName
     * the file to cache
     * @return string
     * the absolute path of the cache file
     */
    protected function getCacheFile($fileName) {
        return $this->cachePath.'/'.basename($fileName).'CRUDlexCache.php';
    }

    /**
     * Reads the content of the cached file if it exists.
     *
     * @param string $fileName
     * the cache file to read from
     * @return null|array
     * the cached data structure or null if the cache file was not available
     */
    protected function readFromCache($fileName) {
        $cacheFile = $this->getCacheFile($fileName);
        if (file_exists($cacheFile) && is_readable($cacheFile)) {
            include($cacheFile);
            if (isset($crudlexCacheContent)) {
                return $crudlexCacheContent;
            }
        }
        return null;
    }

    /**
     * Writes the given content to a cached PHP file.
     *
     * @param string $fileName
     * the original filename
     * @param array $content
     * the content to cache
     */
    protected function writeToCache($fileName, $content) {
        if ($this->cachePath === null || !is_dir($this->cachePath) || !is_writable($this->cachePath)) {
            return;
        }
        $encoder    = new \Riimu\Kit\PHPEncoder\PHPEncoder();
        $contentPHP = $encoder->encode($content, [
            'whitespace' => false,
            'recursion.detect' => false
        ]);
        $cache      = '<?php $crudlexCacheContent = '.$contentPHP.';';
        file_put_contents($this->getCacheFile($fileName), $cache);
    }

    /**
     * YamlReader constructor.
     * @param string|null $cachePath
     * if given, the path for the cache files which should be a writable directory
     */
    public function __construct($cachePath) {
        $this->cachePath = $cachePath;
    }

    /**
     * Reads and returns the contents of the given Yaml file. If
     * it goes wrong, it throws an exception.
     *
     * @param string $fileName
     * the file to read
     *
     * @return array
     * the file contents
     *
     * @throws \RuntimeException
     * thrown if the file could not be read or parsed
     */
    public function read($fileName) {

        $parsedYaml = $this->readFromCache($fileName);
        if ($parsedYaml !== null) {
            return $parsedYaml;
        }

        try {
            $fileContent = file_get_contents($fileName);
            $parsedYaml  = Yaml::parse($fileContent);
            if (!is_array($parsedYaml)) {
                $parsedYaml = [];
            }
            $this->writeToCache($fileName, $parsedYaml);
            return $parsedYaml;
        } catch (\Exception $e) {
            throw new \RuntimeException('Could not read Yaml file '.$fileName, $e->getCode(), $e);
        }
    }

}