GpsLab\Bundle\GeoIP2Bundle\DependencyInjection\Configuration

Complexity

Total Complexity

63

Size/Duplication

Total Lines	418
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

97.69%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	2
A	getConfigTreeBuilder()	0	29	1
A	getDatabaseNode()	0	31	1
A	createTreeBuilder()	0	10	2
A	getRootNode()	0	18	3
A	normalizeDefaultDatabase()	0	18	4
A	normalizeRootConfigurationToDefaultDatabase()	0	20	5
B	normalizeLicenseDirtyHack()	0	18	7
A	validateAvailableDefaultDatabase()	0	17	4
B	allowGlobalLicense()	0	21	6
B	allowGlobalLocales()	0	21	6
B	validateDatabases()	0	33	9
A	normalizeUrl()	0	17	4
A	normalizePath()	0	13	3
A	validateURL()	0	11	3
A	arrayPrototype()	0	18	3

<?php
declare(strict_types=1);

/**
 * GpsLab component.
 *
 * @author    Peter Gribanov <info@peter-gribanov.ru>
 * @copyright Copyright (c) 2017, Peter Gribanov
 * @license   http://opensource.org/licenses/MIT
 */

namespace GpsLab\Bundle\GeoIP2Bundle\DependencyInjection;

use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
use Symfony\Component\Config\Definition\Builder\NodeDefinition;
use Symfony\Component\Config\Definition\Builder\TreeBuilder;
use Symfony\Component\Config\Definition\ConfigurationInterface;

class Configuration implements ConfigurationInterface
{
    private const URL = 'https://download.maxmind.com/app/geoip_download?edition_id=%s&license_key=%s&suffix=tar.gz';

    private const PATH = '%s/%s.mmdb';

    private const LICENSE_DIRTY_HACK = 'YOUR-LICENSE-KEY';

    private const DATABASE_EDITION_IDS = [
        'GeoLite2-ASN',
        'GeoLite2-City',
        'GeoLite2-Country',
        'GeoIP2-City',
        'GeoIP2-Country',
        'GeoIP2-Anonymous-IP',
        'GeoIP2-Domain',
        'GeoIP2-ISP',
    ];

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

    /**
     * @param string|null $cache_dir
     */
    public function __construct(?string $cache_dir)
    {
        $this->cache_dir = $cache_dir ?: sys_get_temp_dir();
    }

    /**
     * @return TreeBuilder
     */
    public function getConfigTreeBuilder(): TreeBuilder
    {
        $tree_builder = $this->createTreeBuilder('gpslab_geoip');
        $root_node = $this->getRootNode($tree_builder, 'gpslab_geoip');

        $this->normalizeDefaultDatabase($root_node);
        $this->normalizeRootConfigurationToDefaultDatabase($root_node);
        $this->normalizeLicenseDirtyHack($root_node);
        $this->validateAvailableDefaultDatabase($root_node);
        $this->allowGlobalLicense($root_node);
        $this->allowGlobalLocales($root_node);
        $this->validateDatabases($root_node);

        $root_node->fixXmlConfig('locale');
        $locales = $root_node->children()->arrayNode('locales');
        $locales->prototype('scalar');
        $locales->treatNullLike([]);
        $locales->defaultValue(['en']);

        $root_node->children()->scalarNode('license');

        $default_database = $root_node->children()->scalarNode('default_database');
        $default_database->defaultValue('default');

        $root_node->fixXmlConfig('database');
        $root_node->append($this->getDatabaseNode());

        return $tree_builder;
    }

    /**
     * @return ArrayNodeDefinition
     */
    private function getDatabaseNode(): ArrayNodeDefinition
    {
        $tree_builder = $this->createTreeBuilder('databases');
        $root_node = $this->getRootNode($tree_builder, 'databases');
        $root_node->useAttributeAsKey('name');

        $database_node = $this->arrayPrototype($root_node);

        $this->normalizeUrl($database_node);
        $this->normalizePath($database_node);

        $url = $database_node->children()->scalarNode('url');
        $url->isRequired();

        $this->validateURL($url);

        $path = $database_node->children()->scalarNode('path');
        $path->isRequired();

        $database_node->fixXmlConfig('locale');
        $locales = $database_node->children()->arrayNode('locales');
        $locales->prototype('scalar');
        $locales->treatNullLike([]);
        $locales->defaultValue(['en']);

        $database_node->children()->scalarNode('license');

        $database_node->children()->enumNode('edition')->values(self::DATABASE_EDITION_IDS);

        return $root_node;
    }

    /**
     * @param string $name
     *
     * @return TreeBuilder
     */
    private function createTreeBuilder(string $name): TreeBuilder
    {
        // Symfony 4.2 +
        if (method_exists(TreeBuilder::class, '__construct')) {
            return new TreeBuilder($name);
        }

        // Symfony 4.1 and below
        return new TreeBuilder();

The call to TreeBuilder::__construct() misses a required argument $name.

    }

    /**
     * @param TreeBuilder $tree_builder
     * @param string      $name
     *
     * @return ArrayNodeDefinition
     */
    private function getRootNode(TreeBuilder $tree_builder, string $name): ArrayNodeDefinition
    {
        if (method_exists($tree_builder, 'getRootNode')) {
            // Symfony 4.2 +
            $root = $tree_builder->getRootNode();
        } else {
            // Symfony 4.1 and below
            $root = $tree_builder->root($name);

The method root() does not seem to exist on object<Symfony\Component\Config\Definition\Builder\TreeBuilder>.

        }

        // @codeCoverageIgnoreStart
        if (!($root instanceof ArrayNodeDefinition)) { // should be always false
            throw new \RuntimeException(sprintf('The root node should be instance of %s, got %s instead.', ArrayNodeDefinition::class, get_class($root)));
        }
        // @codeCoverageIgnoreEnd

        return $root;
    }

    /**
     * @param ArrayNodeDefinition $root_node
     *
     * @return ArrayNodeDefinition
     */
    private function arrayPrototype(ArrayNodeDefinition $root_node): ArrayNodeDefinition
    {
        // Symfony 3.3 +
        if (method_exists($root_node, 'arrayPrototype')) {
            return $root_node->arrayPrototype();
        }

        // Symfony 3.2 and below
        $node = $root_node->prototype('array');

        // @codeCoverageIgnoreStart
        if (!($node instanceof ArrayNodeDefinition)) { // should be always false
            throw new \RuntimeException(sprintf('The "array" prototype should be instance of %s, got %s instead.', ArrayNodeDefinition::class, get_class($node)));
        }
        // @codeCoverageIgnoreEnd

        return $node;
    }

    /**
     * Normalize default_database from databases.
     *
     * @param NodeDefinition $root_node
     */
    private function normalizeDefaultDatabase(NodeDefinition $root_node): void
    {
        $root_node
            ->beforeNormalization()
            ->ifTrue(static function ($v): bool {
                return
                    is_array($v) &&
                    !array_key_exists('default_database', $v) &&
                    !empty($v['databases']) &&
                    is_array($v['databases']);
            })
            ->then(static function (array $v): array {
                $keys = array_keys($v['databases']);
                $v['default_database'] = reset($keys);

                return $v;
            });
    }

    /**
     * Normalize databases root configuration to default_database.
     *
     * @param NodeDefinition $root_node
     */
    private function normalizeRootConfigurationToDefaultDatabase(NodeDefinition $root_node): void
    {
        $root_node
            ->beforeNormalization()
            ->ifTrue(static function ($v): bool {
                return $v && is_array($v) && !array_key_exists('databases', $v) && !array_key_exists('database', $v);
            })
            ->then(static function (array $v): array {
                $database = $v;
                unset($database['default_database']);
                $default_database = isset($v['default_database']) ? (string) $v['default_database'] : 'default';

                return [
                    'default_database' => $default_database,
                    'databases' => [
                        $default_database => $database,
                    ],
                ];
            });
    }

    /**
     * Dirty hack for Symfony Flex.
     *
     * @see https://github.com/symfony/recipes-contrib/pull/837
     *
     * @param NodeDefinition $root_node
     */
    private function normalizeLicenseDirtyHack(NodeDefinition $root_node): void
    {
        $root_node
            ->beforeNormalization()
            ->ifTrue(static function ($v): bool {
                return $v && is_array($v) && array_key_exists('databases', $v) && is_array($v['databases']);
            })
            ->then(static function (array $v): array {
                foreach ($v['databases'] as $name => $database) {
                    if (isset($database['license']) && $database['license'] === self::LICENSE_DIRTY_HACK) {
                        unset($v['databases'][$name]);
                        @trigger_error(sprintf('License for downloaded database "%s" is not specified.', $name), E_USER_WARNING);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

                    }
                }

                return $v;
            });
    }

    /**
     * Validate that the default_database exists in the list of databases.
     *
     * @param NodeDefinition $root_node
     */
    private function validateAvailableDefaultDatabase(NodeDefinition $root_node): void
    {
        $root_node
            ->validate()
            ->ifTrue(static function ($v): bool {
                return
                    is_array($v) &&
                    array_key_exists('default_database', $v) &&
                    !empty($v['databases']) &&
                    !array_key_exists($v['default_database'], $v['databases']);
            })
            ->then(static function (array $v): array {
                $databases = implode('", "', array_keys($v['databases']));

                throw new \InvalidArgumentException(sprintf('Undefined default database "%s". Available "%s" databases.', $v['default_database'], $databases));
            });
    }

    /**
     * Add a license option to the databases configuration if it does not exist.
     * Allow use a global license for all databases.
     *
     * @param NodeDefinition $root_node
     */
    private function allowGlobalLicense(NodeDefinition $root_node): void
    {
        $root_node
            ->beforeNormalization()
            ->ifTrue(static function ($v): bool {
                return
                    is_array($v) &&
                    array_key_exists('license', $v) &&
                    array_key_exists('databases', $v) &&
                    is_array($v['databases']);
            })
            ->then(static function (array $v): array {
                foreach ($v['databases'] as $name => $database) {
                    if (!array_key_exists('license', $database)) {
                        $v['databases'][$name]['license'] = $v['license'];
                    }
                }

                return $v;
            });
    }

    /**
     * Add a locales option to the databases configuration if it does not exist.
     * Allow use a global locales for all databases.
     *
     * @param NodeDefinition $root_node
     */
    private function allowGlobalLocales(NodeDefinition $root_node): void
    {
        $root_node
            ->beforeNormalization()
            ->ifTrue(static function ($v): bool {
                return
                    is_array($v) &&
                    array_key_exists('locales', $v) &&
                    array_key_exists('databases', $v) &&
                    is_array($v['databases']);
            })
            ->then(static function (array $v): array {
                foreach ($v['databases'] as $name => $database) {
                    if (!array_key_exists('locales', $database)) {
                        $v['databases'][$name]['locales'] = $v['locales'];
                    }
                }

                return $v;
            });
    }

    /**
     * Validate database options.
     *
     * @param NodeDefinition $root_node
     */
    private function validateDatabases(NodeDefinition $root_node): void
    {
        $root_node
            ->validate()
            ->ifTrue(static function ($v): bool {
                return is_array($v) && array_key_exists('databases', $v) && is_array($v['databases']);
            })
            ->then(static function (array $v): array {
                foreach ($v['databases'] as $name => $database) {
                    if (empty($database['license'])) {
                        throw new \InvalidArgumentException(sprintf('License for downloaded database "%s" is not specified.', $name));
                    }

                    if (empty($database['edition'])) {
                        throw new \InvalidArgumentException(sprintf('Edition of downloaded database "%s" is not selected.', $name));
                    }

                    if (empty($database['url'])) {
                        throw new \InvalidArgumentException(sprintf('URL for download database "%s" is not specified.', $name));
                    }

                    if (empty($database['path'])) {
                        throw new \InvalidArgumentException(sprintf('The destination path to download database "%s" is not specified.', $name));
                    }

                    if (empty($database['locales'])) {
                        throw new \InvalidArgumentException(sprintf('The list of locales for database "%s" should not be empty.', $name));
                    }
                }

                return $v;
            });
    }

    /**
     * Normalize url option from license key and edition id.
     *
     * @param NodeDefinition $database_node
     */
    private function normalizeUrl(NodeDefinition $database_node): void
    {
        $database_node
            ->beforeNormalization()
            ->ifTrue(static function ($v): bool {
                return
                    is_array($v) &&
                    !array_key_exists('url', $v) &&
                    array_key_exists('license', $v) &&
                    array_key_exists('edition', $v);
            })
            ->then(static function (array $v): array {
                $v['url'] = sprintf(self::URL, urlencode($v['edition']), urlencode($v['license']));

                return $v;
            });
    }

    /**
     * Normalize path option from edition id.
     *
     * @param NodeDefinition $database_node
     */
    private function normalizePath(NodeDefinition $database_node): void
    {
        $database_node
            ->beforeNormalization()
            ->ifTrue(static function ($v): bool {
                return is_array($v) && !array_key_exists('path', $v) && array_key_exists('edition', $v);
            })
            ->then(function (array $v): array {
                $v['path'] = sprintf(self::PATH, $this->cache_dir, $v['edition']);

                return $v;
            });
    }

    /**
     * The url option must be a valid URL.
     *
     * @param NodeDefinition $url
     */
    private function validateURL(NodeDefinition $url): void
    {
        $url
            ->validate()
            ->ifTrue(static function ($v): bool {
                return is_string($v) && $v && !filter_var($v, FILTER_VALIDATE_URL);
            })
            ->then(static function (string $v): array {
                throw new \InvalidArgumentException(sprintf('URL "%s" must be valid.', $v));
            });
    }
}