allejo\stakx\Configuration

Complexity

Total Complexity

47

Size/Duplication

Total Lines	396
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

90.06%

Importance

Changes

0

25 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	readFile()	0	8	2
A	parse()	0	11	1
B	parseConfig()	0	38	4
A	setLogger()	0	4	1
A	isDebug()	0	4	1
A	getBaseUrl()	0	12	3
A	getDataFolders()	0	4	1
A	getDataSets()	0	4	1
A	getIncludes()	0	4	1
A	getExcludes()	0	4	1
A	getTheme()	0	4	1
A	getConfiguration()	0	4	1
A	getPageViewFolders()	0	4	1
A	getTargetFolder()	0	4	1
A	getCollectionsFolders()	0	4	1
A	getTwigAutoescape()	0	4	1
A	getRedirectTemplate()	0	4	1
A	returnConfigOption()	0	4	2
A	mergeDefaultConfiguration()	0	23	1
A	handleDeprecations()	0	10	2
C	handleImports()	0	66	8
C	isValidImport()	0	33	7
A	isRecursiveImport()	0	11	2
A	mergeImports()	0	8	1

<?php

/**
 * @copyright 2017 Vladimir Jimenez
 * @license   https://github.com/allejo/stakx/blob/master/LICENSE.md MIT
 */

namespace allejo\stakx;

use allejo\stakx\Exception\FileAccessDeniedException;
use allejo\stakx\Exception\RecursiveConfigurationException;
use allejo\stakx\System\Filesystem;
use allejo\stakx\Utilities\ArrayUtilities;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Symfony\Component\Filesystem\Exception\FileNotFoundException;
use Symfony\Component\Yaml\Exception\ParseException;
use Symfony\Component\Yaml\Yaml;

class Configuration implements LoggerAwareInterface
{
    const DEFAULT_NAME = '_config.yml';
    const IMPORT_KEYWORD = 'import';

    private static $configImports = array();

    /**
     * A list of regular expressions or files directly related to stakx websites that should not be copied over to the
     * compiled website as an asset.
     *
     * @var array
     */
    public static $stakxSourceFiles = array('/^_(?!themes).*/', '/.twig$/');

    /**
     * An array representation of the main Yaml configuration.
     *
     * @var array
     */
    private $configuration;

    /**
     * @var string
     */
    private $parentConfig;

    /** @var string */
    private $currentFile;

    /**
     * @var LoggerInterface
     */
    private $output;

    /**
     * @var Filesystem
     */
    private $fs;

Avoid variables with short names like $fs. Configured minimum length is 3.

    /**
     * Configuration constructor.
     */
    public function __construct()
    {
        $this->configuration = array();
        $this->fs = new Filesystem();
    }

    private static function readFile($filePath)
    {
        $fs = new Filesystem();

Avoid variables with short names like $fs. Configured minimum length is 3.

        $fileRaw = $fs->safeReadFile($filePath);
        $parsed = Yaml::parse($fileRaw);

        return (null === $parsed) ? array() : $parsed;
    }

    public function parse($configFile = null)
    {
        $this->parentConfig = $configFile;
        self::$configImports = array();

        $this->configuration = $this->parseConfig($configFile);
        $this->mergeDefaultConfiguration();
        $this->handleDeprecations();

        self::$configImports = array();
    }

    /**
     * Parse a given configuration file and configure this Configuration instance.
     *
     * This function should be called with 'null' passed when "configuration-less" mode is used
     *
     * @param string|null $configFile     The path to the configuration file. If null, the default configuration will be
     *                                    used
     *
     * @return array
     */
    private function parseConfig($configFile = null)
    {
        if (null === $configFile)
        {
            return array();
        }

        $this->currentFile = $configFile;

        try
        {
            $this->isRecursiveImport($configFile);

            $parsedConfig = self::readFile($configFile);

            $this->handleImports($parsedConfig);

            unset($parsedConfig[self::IMPORT_KEYWORD]);
            return $parsedConfig;
        }
        catch (ParseException $e)
        {
            $this->output->error('{file}: parsing failed... {message}', array(
                'message' => $e->getMessage(),
                'file' => $configFile,
            ));
            $this->output->error('Using default configuration...');
        }
        catch (RecursiveConfigurationException $e)
        {
            $this->output->error("{file}: you can't recursively import a file that's already been imported: {import}", array(
                'file' => $configFile,
                'import' => $e->getRecursiveImport(),
            ));
        }

        return array();
    }

    /**
     * {@inheritdoc}
     */
    public function setLogger(LoggerInterface $logger)
    {
        $this->output = $logger;
    }

    public function isDebug()
    {
        return $this->returnConfigOption('debug', false);
    }

    /**
     * @TODO 1.0.0 Remove support for 'base' in next major release; it has been replaced by 'baseurl'
     *
     * @return mixed|null
     */
    public function getBaseUrl()
    {
        $base = $this->returnConfigOption('base');
        $baseUrl = $this->returnConfigOption('baseurl');

        if (is_null($base) || (!empty($baseUrl)))
        {
            return $baseUrl;
        }

        return $base;
    }

    /**
     * @return string[]
     */
    public function getDataFolders()
    {
        return $this->returnConfigOption('data');
    }

    /**
     * @return string[]
     */
    public function getDataSets()
    {
        return $this->returnConfigOption('datasets');
    }

    public function getIncludes()
    {
        return $this->returnConfigOption('include', array());
    }

    public function getExcludes()
    {
        return $this->returnConfigOption('exclude', array());
    }

    public function getTheme()
    {
        return $this->returnConfigOption('theme');
    }

    public function getConfiguration()
    {
        return $this->configuration;
    }

    public function getPageViewFolders()
    {
        return $this->returnConfigOption('pageviews');
    }

    public function getTargetFolder()
    {
        return $this->returnConfigOption('target');
    }

    public function getCollectionsFolders()
    {
        return $this->returnConfigOption('collections');
    }

    public function getTwigAutoescape()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->configuration['twig']['autoescape'];
    }

    public function getRedirectTemplate()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->configuration['templates']['redirect'];
    }

    /**
     * Return the specified configuration option if available, otherwise return the default.
     *
     * @param string     $name    The configuration option to lookup
     * @param mixed|null $default The default value returned if the configuration option isn't found
     *
     * @return mixed|null
     */
    private function returnConfigOption($name, $default = null)
    {
        return isset($this->configuration[$name]) ? $this->configuration[$name] : $default;
    }

    private function mergeDefaultConfiguration()
    {
        $defaultConfig = array(
            'baseurl'   => '',
            'target'    => '_site',
            'twig'      => array(
                'autoescape' => false,
            ),
            'include'   => array(
                '.htaccess',
            ),
            'exclude'   => array(
                'node_modules/',
                'stakx-theme.yml',
                self::DEFAULT_NAME,
            ),
            'templates' => array(
                'redirect' => false,
            ),
        );

        $this->configuration = ArrayUtilities::array_merge_defaults($defaultConfig, $this->configuration, 'name');
    }

    private function handleDeprecations()
    {
        // @TODO 1.0.0 handle 'base' deprecation in _config.yml
        $base = $this->returnConfigOption('base');

        if (!is_null($base))
        {
            $this->output->warning("The 'base' configuration option has been replaced by 'baseurl' and will be removed in in version 1.0.0.");
        }
    }

    private function handleImports(&$configuration)
    {
        if (!array_key_exists(self::IMPORT_KEYWORD, $configuration))
        {
            $this->output->debug('{file}: does not import any other files', array(
                'file' => $this->parentConfig,
            ));

            return;
        }

        if (!is_array($imports = $configuration[self::IMPORT_KEYWORD]))
        {
            $this->output->error('{file}: the reserved "import" keyword can only be an array');

            return;
        }

        $thisFile = $this->fs->getRelativePath($this->parentConfig);
        $parentConfigLocation = $this->fs->getFolderPath($thisFile);

        foreach ($imports as $_import)

$_import does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        {
            if (!is_string($_import))

$_import does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            {
                $this->output->error('{file}: invalid import: {message}', array(
                    'file' => $thisFile,
                    'message' => $_import,

$_import does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                ));

                continue;
            }

            $import = $this->fs->appendPath($parentConfigLocation, $_import);

$_import does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            if (!$this->isValidImport($import))
            {
                continue;
            }

            $this->output->debug('{file}: imports additional file: {import}', array(
                'file' => $thisFile,
                'import' => $import,
            ));

            try
            {
                $importedConfig = $this->parseConfig($import);
                $configuration = $this->mergeImports($importedConfig, $configuration);
            }
            catch (FileAccessDeniedException $e)
            {
                $this->output->warning('{file}: trying access file outside of project directory: {import}', array(
                    'file' => $thisFile,
                    'import' => $import,
                ));
            }
            catch (FileNotFoundException $e)
            {
                $this->output->warning('{file}: could not find file to import: {import}', array(
                    'file' => $thisFile,
                    'import' => $import,
                ));
            }
        }
    }

    /**
     * Check whether a given file path is a valid import
     *
     * @param  string $filePath
     *
     * @return bool
     */
    private function isValidImport($filePath)
    {
        $thisFile = $this->fs->getRelativePath($this->parentConfig);
        $errorMsg = '';

        if ($this->fs->isDir($filePath))
        {
            $errorMsg = 'a directory';
        }
        elseif ($this->fs->isSymlink($filePath))
        {
            $errorMsg = 'a symbolically linked file';
        }
        elseif ($this->fs->absolutePath($this->currentFile) == $this->fs->absolutePath($filePath))
        {
            $errorMsg = 'yourself';
        }
        elseif (($ext = $this->fs->getExtension($filePath)) != 'yml' && $ext != 'yaml')
        {
            $errorMsg = 'a non-YAML configuration';
        }

        if (!($noErrors = empty($errorMsg)))
        {
            $this->output->error("{file}: you can't import {message}: {import}", array(
                'file' => $thisFile,
                'message' => $errorMsg,
                'import' => $filePath
            ));
        }

        return $noErrors;
    }

    private function isRecursiveImport($filePath)
    {
        if (in_array($filePath, self::$configImports))
        {
            throw new RecursiveConfigurationException($filePath, sprintf(
                'The %s file has already been imported', $filePath
            ));
        }

        self::$configImports[] = $filePath;
    }

    /**
     * Merge the given array with existing configuration
     *
     * @param  array $importedConfig
     * @param  array $existingConfig
     *
     * @return array
     */
    private function mergeImports(array $importedConfig, array $existingConfig)
    {
        $arraySplit = ArrayUtilities::associative_array_split(self::IMPORT_KEYWORD, $existingConfig, false);
        $beforeImport = ArrayUtilities::array_merge_defaults($arraySplit[0], $importedConfig, 'name');
        $result = ArrayUtilities::array_merge_defaults($beforeImport, $arraySplit[1], 'name');

        return $result;
    }
}