AlexMasterov\PsyshBundle\DependencyInjection\Configuration

Complexity

Total Complexity

8

Size/Duplication

Total Lines	149
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

98.94%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
B	getConfigTreeBuilder()	0	43	1
B	normalizeRootNode()	0	28	3
A	addVariablesNode()	0	17	1
B	addErrorLoggingLevelNode()	0	34	2
A	addArrayNode()	0	17	1

<?php
declare(strict_types=1);

namespace AlexMasterov\PsyshBundle\DependencyInjection;

use Symfony\Component\Config\Definition\{
    Builder\ArrayNodeDefinition,
    Builder\TreeBuilder,
    ConfigurationInterface,
    Exception\InvalidConfigurationException
};

class Configuration implements ConfigurationInterface
{
    /**
     * @inheritDoc
     */
    public function getConfigTreeBuilder()
    {
        $treeBuilder = new TreeBuilder();
        $rootNode = $treeBuilder->root('psysh');

        $rootNode
            ->children()
                ->append($this->addVariablesNode())
                ->append($this->addArrayNode('commands'))
                ->append($this->addArrayNode('default_includes'))
                ->append($this->addErrorLoggingLevelNode())
                ->scalarNode('config_dir')->end()
                ->scalarNode('data_dir')->end()
                ->scalarNode('runtime_dir')
                    ->info('Set the shell\'s temporary directory location')
                ->end()
                ->integerNode('history_size')
                    ->info('If set to zero (0), the history size is unlimited')
                ->end()
                ->scalarNode('history_file')->end()
                ->scalarNode('manual_db_file')->end()
                ->booleanNode('tab_completion')->end()
                ->append($this->addArrayNode('tab_completion_matchers'))
                ->scalarNode('startup_message')->end()
                ->booleanNode('require_semicolons')->end()
                ->booleanNode('erase_duplicates')->end()
                ->booleanNode('pcntl')->end()
                ->booleanNode('readline')->end()
                ->booleanNode('unicode')->end()
                ->enumNode('color_mode')
                    ->values(['auto', 'forced', 'disabled'])
                ->end()
                ->scalarNode('pager')->treatNullLike('less')->end()
                ->enumNode('update_check')->defaultValue('never')
                    ->values(['never', 'always', 'daily', 'weekly', 'monthly'])
                ->end()
            ->end()
        ;

        $this->normalizeRootNode($rootNode);

        return $treeBuilder;
    }

    private function normalizeRootNode(ArrayNodeDefinition $rootNode): void
    {
        $normalizer = static function (array $config): array {
            static $keys = [
                'pcntl'    => 'usePcntl',
                'readline' => 'useReadline',
                'unicode'  => 'useUnicode',
            ];

            // config_dir -> configDir
            $camelize = static function (string $value): string {
                return \str_replace('_', '', \lcfirst(\ucwords(\strtolower($value), '_')));
            };

            $normalized = [];
            foreach ($config as $key => $value) {
                if (empty($value)) {
                    continue;
                }
                $key = $keys[$key] ?? $camelize($key);
                $normalized[$key] = $value;
            }

            return $normalized;
        };

        $rootNode->validate()->always()->then($normalizer)->end();
    }

    private function addVariablesNode(): ArrayNodeDefinition
    {
        $node = new ArrayNodeDefinition('variables');
        $node
            ->normalizeKeys(false)
            ->useAttributeAsKey('name')
            ->prototype('variable')->end()
            ->validate()
                ->always()
                ->then(static function ($variables) {
                    return \array_filter($variables, 'is_string');
                })
            ->end()
        ;

        return $node;
    }

    private function addErrorLoggingLevelNode(): ArrayNodeDefinition
    {
        $node = new ArrayNodeDefinition('error_logging_level');
        $node
            ->beforeNormalization()
                ->ifString()
                ->then(static function ($v) {
                    return \preg_split('/\s*,\s*/', $v, -1, \PREG_SPLIT_NO_EMPTY);
                })
            ->end()
            ->prototype('scalar')->end()
            ->validate()
                ->always()
                ->then(static function ($methods) {
                    $invalidMethods = \array_filter($methods, static function ($method) {
                        return false === \defined("E_{$method}");
                    });

                    if (empty($invalidMethods)) {
                        return \array_reduce($methods, static function ($level, $method) {
                            return $level |= \constant("E_{$method}");
                        });
                    }

                    throw new InvalidConfigurationException(\sprintf(
                        'The errors are not supported: "%s".',
                        \implode('", "', $invalidMethods)
                    ));
                })
            ->end()
        ;

        return $node;
    }

    private function addArrayNode(string $name): ArrayNodeDefinition
    {
        $node = new ArrayNodeDefinition($name);
        $node
            ->normalizeKeys(false)
            ->useAttributeAsKey('name')
            ->beforeNormalization()
                ->ifString()
                ->then(static function ($v) {
                    return \preg_split('/\s*,\s*/', $v, -1, \PREG_SPLIT_NO_EMPTY);
                })
            ->end()
            ->prototype('scalar')->end()
        ;

        return $node;
    }
}