Incenteev\ParameterHandler\Processor

Complexity

Total Complexity

35

Size/Duplication

Total Lines	196
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	processFile()	0	45	7
B	processConfig()	0	24	6
A	processParams()	0	22	5
A	getEnvValues()	0	21	4
A	setValueByPath()	0	10	2
A	processRenamedValues()	0	16	4
B	getParams()	0	34	6

<?php

namespace Incenteev\ParameterHandler;

use Composer\IO\IOInterface;

class Processor
{
    /**
     * @var IOInterface
     */
    protected $io;

    /**
     * @var FileHandlerInterface
     */
    protected $fileHandler;

    public function __construct(IOInterface $io)
    {
        $this->io = $io;
    }

    public function processFile(array $config)
    {
        $config = $this->processConfig($config);

        $realFile = $config['file'];
        $this->fileHandler = FileHandlerFactory::createFileHandler($config['file-type']);
        $parameterKey = $config['parameter-key'];

        $exists = is_file($realFile);

        $action = $exists ? 'Updating' : 'Creating';
        $this->io->write(sprintf('<info>%s the "%s" file</info>', $action, $realFile));

        // Find the expected params
        $expectedValues = $this->fileHandler->load($config['dist-file']);
        if (!isset($expectedValues[$parameterKey])) {
            throw new \InvalidArgumentException(sprintf('The top-level key %s is missing.', $parameterKey));
        }
        $expectedParams = (array) $expectedValues[$parameterKey];

        // find the actual params
        $actualValues = array_merge(
            // Preserve other top-level keys than `$parameterKey` in the file
            $expectedValues,
            [$parameterKey => []]
        );
        if ($exists) {
            $existingValues = $this->fileHandler->load($realFile);
            if ($existingValues === null) {
                $existingValues = [];
            }
            if (!is_array($existingValues)) {
                throw new \InvalidArgumentException(sprintf('The existing "%s" file does not contain an array', $realFile));
            }
            $actualValues = array_merge($actualValues, $existingValues);
        }

        $actualValues[$parameterKey] = $this->processParams($config, $expectedParams, (array) $actualValues[$parameterKey]);

        if (!is_dir($dir = dirname($realFile))) {
            mkdir($dir, 0755, true);
        }

        $this->fileHandler->save($realFile, $actualValues);
    }

    protected function processConfig(array $config)
    {
        if (empty($config['file'])) {
            throw new \InvalidArgumentException('The extra.incenteev-parameters.file setting is required to use this script handler.');
        }

        if (empty($config['file-type'])) {
            throw new \InvalidArgumentException('The extra.incenteev-parameters.file-type setting is required to use this script handler.');
        }

        if (empty($config['dist-file'])) {
            $config['dist-file'] = $config['file'] . '.dist';
        }

        if (!is_file($config['dist-file'])) {
            throw new \InvalidArgumentException(sprintf('The dist file "%s" does not exist. Check your dist-file config or create it.', $config['dist-file']));
        }

        if (empty($config['parameter-key'])) {
            $config['parameter-key'] = 'parameters';
        }

        return $config;
    }

    protected function processParams(array $config, array $expectedParams, array $actualParams)
    {
        // Grab values for parameters that were renamed
        $renameMap = empty($config['rename-map']) ? [] : (array) $config['rename-map'];
        $actualParams = array_replace($actualParams, $this->processRenamedValues($renameMap, $actualParams));

        $keepOutdatedParams = false;
        if (isset($config['keep-outdated'])) {
            $keepOutdatedParams = (boolean) $config['keep-outdated'];
        }

        if (!$keepOutdatedParams) {
            $actualParams = array_intersect_key($actualParams, $expectedParams);
        }

        $envMap = empty($config['env-map']) ? [] : (array) $config['env-map'];

        // Add the params coming from the environment values
        $actualParams = array_replace($actualParams, $this->getEnvValues($envMap));

        return $this->getParams($expectedParams, $actualParams);
    }

    protected function getEnvValues(array $envMap)
    {
        $params = [];
        foreach ($envMap as $param => $env) {
            $value = getenv($env);

            if (!$value) {
                continue;
            }

            if (false !== strpos($param, '.')) {
                $this->setValueByPath($params, $param, $this->fileHandler->parseInline($value));

                continue;
            }

            $params[$param] = $this->fileHandler->parseInline($value);
        }

        return $params;
    }

    protected function setValueByPath(array &$array, $path, $value)
    {
        $index = &$array;

        foreach (explode('.', $path) as $level) {
            $index = &$index[$level];
        }

        $index = $value;
    }

    protected function processRenamedValues(array $renameMap, array $actualParams)
    {
        foreach ($renameMap as $param => $oldParam) {
            if (array_key_exists($param, $actualParams)) {
                continue;
            }

            if (!array_key_exists($oldParam, $actualParams)) {
                continue;
            }

            $actualParams[$param] = $actualParams[$oldParam];
        }

        return $actualParams;
    }

    protected function getParams(array $expectedParams, array $actualParams)
    {
        // Simply use the expectedParams value as default for the missing params.
        if (!$this->io->isInteractive()) {
            return array_replace($expectedParams, $actualParams);
        }

        $isStarted = false;

        foreach ($expectedParams as $key => $message) {
            if (array_key_exists($key, $actualParams)) {
                continue;
            }

            if (!$isStarted) {
                $isStarted = true;
                $this->io->write('<comment>Some parameters are missing. Please provide them.</comment>');
            }

            $default = $this->fileHandler->dumpInline($message);

            if (is_array($default)) {
                $actualParams[$key] = $default;

                continue;
            }

            $value = $this->io->ask(sprintf('<question>%s</question> (<comment>%s</comment>): ', $key, $default), $default);

            $actualParams[$key] = $this->fileHandler->parseInline($value);
        }

        return $actualParams;
    }
}