Webcreate\Conveyor\Config\YamlConfig

Complexity

Total Complexity

29

Size/Duplication

Total Lines	206
Duplicated Lines	2.43 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

69.23%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	2
A	getConfig()	0	6	1
A	getFile()	0	4	1
A	flatten()	0	6	1
A	process()	0	13	2
A	load()	0	8	2
A	compile()	0	11	2
B	replaceParameters()	0	14	5
A	expandTasksTargetGroups()	0	16	2
C	expandTasksTargetGroupsForSection()	5	32	8
A	setParameter()	0	14	3

<?php

/*
 * This file is part of the Conveyor package.
 *
 * (c) Jeroen Fiege <jeroen@webcreate.nl>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Webcreate\Conveyor\Config;

use Symfony\Component\Config\Definition\Processor;
use Symfony\Component\Yaml\Yaml;
use Webcreate\Conveyor\Config\Definition\DeployConfiguration;
use Webcreate\Conveyor\Factory\StrategyFactory;
use Webcreate\Conveyor\Factory\TaskFactory;
use Webcreate\Conveyor\Factory\TransporterFactory;
use Webcreate\Conveyor\Util\ArrayUtil;

/**
 * @todo refactor getConfig() method: might want to implement \ArrayAccess interface
 */
class YamlConfig
{
    protected $processedConfig;
    protected $loadedConfig;
    protected $compiledConfig;
    protected $parameters = array();
    protected $taskFactory;
    protected $transporterFactory;
    protected $strategyFactory;
    protected $file;

    /**
     * Constructor.
     *
     * @param  string                    $file
     * @param  TaskFactory               $taskFactory
     * @param  TransporterFactory        $transporterFactory
     * @param  StrategyFactory           $strategyFactory
     * @throws \InvalidArgumentException
     */
    public function __construct($file, TaskFactory $taskFactory, TransporterFactory $transporterFactory, StrategyFactory $strategyFactory)
    {
        if (!file_exists($file)) {
            throw new \InvalidArgumentException(sprintf('File %s does not exists', $file));
        }

        $this->file               = $file;
        $this->taskFactory        = $taskFactory;
        $this->transporterFactory = $transporterFactory;
        $this->strategyFactory    = $strategyFactory;
    }

    /**
     * @return array
     */
    public function getConfig()
    {
        $this->compile();

        return $this->compiledConfig;
    }

    /**
     * @return string
     */
    public function getFile()
    {
        return $this->file;
    }

    /**
     * @return array
     */
    protected function process()
    {
        if (null === $this->processedConfig) {
            $this->load();

            $configuration = new DeployConfiguration($this->taskFactory, $this->transporterFactory, $this->strategyFactory);
            $processor = new Processor();

            $this->processedConfig = $processor->processConfiguration($configuration, $this->loadedConfig);

It seems like $this->loadedConfig can also be of type string; however, Symfony\Component\Config\Definition\Processor::processConfiguration() does only seem to accept array, maybe add an additional type check?

        }

        return $this->processedConfig;
    }

    /**
     * @return array
     */
    protected function load()
    {
        if (null === $this->loadedConfig) {
            $this->loadedConfig = Yaml::parse($this->file);
        }

        return $this->loadedConfig;
    }

    /**
     * @return mixed
     */
    protected function compile()
    {
        if (null === $this->compiledConfig) {
            $this->process();

            $this->compiledConfig = $this->replaceParameters($this->processedConfig, $this->parameters);
            $this->compiledConfig = $this->expandTasksTargetGroups($this->compiledConfig);
        }

        return $this->compiledConfig;
    }

    /**
     * @param  array $config
     * @param  array $parameters
     * @return array
     */
    protected function replaceParameters(array $config, array $parameters)
    {
        foreach ($config as &$value) {
            if (is_array($value)) {
                $value = $this->replaceParameters($value, $parameters);
            } elseif (is_string($value)) {
                foreach ($parameters as $key => $val) {
                    $value = str_replace(sprintf('{{%s}}', $key), $val, $value);
                }
            }
        }

        return $config;
    }

    /**
     * Expand target groups
     *
     * @param array $config
     * @return array
     */
    protected function expandTasksTargetGroups(array $config)
    {
        $sections = array(
            &$config['build']['tasks'],
            &$config['deploy']['before'],
            &$config['deploy']['after'],
            &$config['deploy']['final'],
            &$config['undeploy']['tasks'],
        );

        foreach ($sections as &$section) {
            $section = $this->expandTasksTargetGroupsForSection($config, $section);
        }

        return $config;
    }

    /**
     * Expand target groups for a certain section
     *
     * @param array $config
     * @param array $section
     * @return array
     */
    protected function expandTasksTargetGroupsForSection(array $config, array $section = null)
    {
        if (null === $section) {
            return $section;
        }

        $groups = array();
        foreach ($config['targets'] as $targetName => $targetConfig) {

This code seems to be duplicated across your project.

            foreach ($targetConfig['groups'] as $group) {
                $groups[$group][] = $targetName;
            }
        }

        foreach ($section as &$taskConfig) {
            $targets = $taskConfig['targets'];
            $expandedTargets = array();

            foreach ($targets as $target) {
                if (isset($groups[$target])) {
                    foreach ($groups[$target] as $groupTarget) {
                        $expandedTargets[] = $groupTarget;
                    }
                } else {
                    $expandedTargets[] = $target;
                }
            }

            $taskConfig['targets'] = $expandedTargets;
        }

        return $section;
    }

    /**
     * @return array
     */
    public function flatten()
    {
        $util = new ArrayUtil();

        return $util->flatten($this->getConfig());
    }

    /**
     * @param string $name
     * @param mixed  $value
     */
    public function setParameter($name, $value)
    {
        $this->process();

        $this->parameters[$name] = $value;

        if ('target' === $name) {
            foreach ($this->processedConfig['targets'][$value]['parameters'] as $key => $value) {
                $this->setParameter('target.' . $key, $value);
            }
        }

        $this->compiledConfig = null;
    }
}