SymbolsConfigurationFactory::lowerCaseConstantName() - Code Metrics - Inspection of "Make use of the expose symbol keywords (#594)" - humbug/php-scoper - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 210c58...766469 )

by Théo
created 2022-01-24 09:14 UTC
lowerCaseConstantName() A

↳ Parent: SymbolsConfigurationFactory
Complexity

Conditions	1
Paths	1
Size

Total Lines	11
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	5
nc	1
nop	1
dl	0
loc	11
rs	10
c	0
b	0
f	0
<?php

declare(strict_types=1);

namespace Humbug\PhpScoper\Configuration;

use Humbug\PhpScoper\RegexChecker;
use Humbug\PhpScoper\Symbol\NamespaceRegistry;
use Humbug\PhpScoper\Symbol\SymbolRegistry;
use InvalidArgumentException;
use function array_key_exists;
use function array_keys;
use function array_map;
use function array_merge;
use function array_pop;
use function array_values;
use function explode;
use function get_debug_type;
use function gettype;
use function implode;
use function is_array;
use function is_bool;
use function is_string;
use function ltrim;
use function Safe\preg_match as native_preg_match;
use function Safe\sprintf;
use function Safe\substr;
use function str_replace;
use function strpos;
use function strtolower;
use function trim;

final class SymbolsConfigurationFactory
{
    private RegexChecker $regexChecker;

    public function __construct(RegexChecker $regexChecker)
    {
        $this->regexChecker = $regexChecker;
    }

    public function createSymbolsConfiguration(array $config): SymbolsConfiguration
    {
        [
            $excludedNamespaceNames,
            $excludedNamespaceRegexes,
        ] = $this->retrieveElements(
            $config,
            ConfigurationKeys::EXCLUDE_NAMESPACES_KEYWORD,
        );

        $legacyExposedElements = self::retrieveLegacyExposedElements($config);

        [
            $legacyExposedSymbols,
            $legacyExposedSymbolsPatterns,
            $legacyExposedConstants,
            $excludedNamespaceNames,
        ] = self::parseLegacyExposedElements($legacyExposedElements, $excludedNamespaceNames);
        ] = /** @scrutinizer ignore-deprecated */ self::parseLegacyExposedElements($legacyExposedElements, $excludedNamespaceNames);

        $exposeGlobalConstants = self::retrieveExposeGlobalSymbol(
            $config,
            ConfigurationKeys::EXPOSE_GLOBAL_CONSTANTS_KEYWORD,
        );
        $exposeGlobalClasses = self::retrieveExposeGlobalSymbol(
            $config,
            ConfigurationKeys::EXPOSE_GLOBAL_CLASSES_KEYWORD,
        );
        $exposeGlobalFunctions = self::retrieveExposeGlobalSymbol(
            $config,
            ConfigurationKeys::EXPOSE_GLOBAL_FUNCTIONS_KEYWORD,
        );

        [$exposedClassNames, $exposedClassRegexes] = $this->retrieveElements(
            $config,
            ConfigurationKeys::EXPOSE_CLASSES_SYMBOLS_KEYWORD,
        );

        [$exposedFunctionNames, $exposedFunctionRegexes] = $this->retrieveElements(
            $config,
            ConfigurationKeys::EXPOSE_FUNCTIONS_SYMBOLS_KEYWORD,
        );

        [$exposedConstantNames, $exposedConstantRegexes] = $this->retrieveElements(
            $config,
            ConfigurationKeys::EXPOSE_CONSTANTS_SYMBOLS_KEYWORD,
        );

        return SymbolsConfiguration::create(
            $exposeGlobalConstants,
            $exposeGlobalClasses,
            $exposeGlobalFunctions,
            NamespaceRegistry::create(
                $excludedNamespaceNames,
                $excludedNamespaceRegexes,
            ),
            null,
            SymbolRegistry::create(
                array_merge(
                    $exposedClassNames,
                    $legacyExposedSymbols,
                ),
                array_merge(
                    $exposedClassRegexes,
                    $legacyExposedSymbolsPatterns,
                ),
            ),
            SymbolRegistry::create(
                array_merge(
                    $exposedFunctionNames,
                    $legacyExposedSymbols,
                ),
                array_merge(
                    $exposedFunctionRegexes,
                    $legacyExposedSymbolsPatterns,
                ),
            ),
            SymbolRegistry::createForConstants(
                array_merge(
                    $exposedConstantNames,
                    $legacyExposedConstants,
                ),
                array_merge(
                    $exposedConstantRegexes,
                    $legacyExposedSymbolsPatterns,
                ),
            ),
        );
    }

    private static function retrieveExposeGlobalSymbol(array $config, string $key): bool
    {
        if (!array_key_exists($key, $config)) {
            return false;
        }

        $value = $config[$key];

        if (!is_bool($value)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Expected %s to be a boolean, found "%s" instead.',
                    $key,
                    gettype($value),
                ),
            );
        }

        return $value;
    }

    /**
     * return list<string>
     */
    private static function retrieveLegacyExposedElements(array $config): array
    {
        $key = ConfigurationKeys::WHITELIST_KEYWORD;

        if (!array_key_exists($key, $config)) {
            return [];
        }

        $whitelist = $config[$key];

        if (!is_array($whitelist)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Expected "%s" to be an array of strings, found "%s" instead.',
                    $key,
                    gettype($whitelist),
                ),
            );
        }

        foreach ($whitelist as $index => $className) {
            if (is_string($className)) {
                continue;
            }

            throw new InvalidArgumentException(
                sprintf(
                    'Expected whitelist to be an array of string, the "%d" element is not.',
                    $index,
                ),
            );
        }

        return array_values($whitelist);
    }

    /**
     * return array{string[], string[]}
     */
    private function retrieveElements(array $config, string $key): array
    {
        if (!array_key_exists($key, $config)) {
            return [[], []];
        }

        $symbolNamesAndRegexes = $config[$key];

        self::assertIsArrayOfStrings($config[$key], $key);

        // Store the strings in the keys for avoiding a unique check later on
        $names = [];
        $regexes = [];

        foreach ($symbolNamesAndRegexes as $index => $nameOrRegex) {
            if (!$this->regexChecker->isRegexLike($nameOrRegex)) {
                $names[$nameOrRegex] = null;

                continue;
            }

            $regex = $nameOrRegex;

            $this->assertValidRegex($regex, $key, (string) $index);

            $errorMessage = $this->regexChecker->validateRegex($regex);

            if (null !== $errorMessage) {
                throw new InvalidArgumentException(
                    sprintf(
                        'Expected "%s" to be an array of valid regexes. The element "%s" with the index "%s" is not: %s.',
                        $key,
                        $regex,
                        $index,
                        $errorMessage,
                    ),
                );
            }

            // Ensure namespace comparisons are always case-insensitive
            // TODO: double check that we are not adding it twice or that adding it twice does not break anything
            $regex .= 'i';
            $regexes[$regex] = null;
        }

        return [
            array_keys($names),
            array_keys($regexes),
        ];
    }

    /**
     * @deprecated
     *
     * @param list<string> $elements
filter:
    dependency_paths: ["lib/*"]
     * @param list<string> $excludedNamespaceNames
     */
    private static function parseLegacyExposedElements(array $elements, array $excludedNamespaceNames): array
    {
        $exposedSymbols = [];
        $exposedConstants = [];
        $exposedSymbolsPatterns = [];
        $excludedNamespaceNames = array_map('strtolower', $excludedNamespaceNames);

        foreach ($elements as $element) {
            $element = ltrim(trim($element), '\\');

            self::assertValidElement($element);
            /** @scrutinizer ignore-deprecated */ self::assertValidElement($element);

            if ('\*' === substr($element, -2)) {
                $excludedNamespaceNames[] = strtolower(substr($element, 0, -2));
            } elseif ('*' === $element) {
                $excludedNamespaceNames[] = '';
            } elseif (false !== strpos($element, '*')) {
                $exposedSymbolsPatterns[] = self::createExposePattern($element);
                $exposedSymbolsPatterns[] = /** @scrutinizer ignore-deprecated */ self::createExposePattern($element);
            } else {
                $exposedSymbols[] = strtolower($element);
                $exposedConstants[] = self::lowerCaseConstantName($element);
                $exposedConstants[] = /** @scrutinizer ignore-deprecated */ self::lowerCaseConstantName($element);
            }
        }

        return [
            $exposedSymbols,
            $exposedSymbolsPatterns,
            $exposedConstants,
            $excludedNamespaceNames,
        ];
    }

    /**
     * @psalm-assert string[] $value
     *
     * @param mixed $value
     */
    private static function assertIsArrayOfStrings($value, string $key): void
    {
        if (!is_array($value)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Expected "%s" to be an array of strings, found "%s" instead.',
                    $key,
                    get_debug_type($value),
                ),
            );
        }

        foreach ($value as $index => $element) {
            if (is_string($element)) {
                continue;
            }

            throw new InvalidArgumentException(
                sprintf(
                    'Expected "%s" to be an array of strings, found "%s" for the element with the index "%s".',
                    $key,
                    get_debug_type($element),
                    $index,
                ),
            );
        }
    }

    private function assertValidRegex(string $regex, string $key, string $index): void
    {
        $errorMessage = $this->regexChecker->validateRegex($regex);

        if (null !== $errorMessage) {
            throw new InvalidArgumentException(
                sprintf(
                    'Expected "%s" to be an array of valid regexes. The element "%s" with the index "%s" is not: %s.',
                    $key,
                    $regex,
                    $index,
                    $errorMessage,
                ),
            );
        }
    }

    /**
     * @deprecated
     */
    private static function assertValidElement(string $element): void
    {
        if ('' !== $element) {
            return;
        }

        throw new InvalidArgumentException(
            sprintf(
                'Invalid whitelist element "%s": cannot accept an empty string',
                $element,
            ),
        );
    }

    /**
     * @deprecated
     */
    private static function createExposePattern(string $element): string
    {
        self::assertValidPattern($element);
        /** @scrutinizer ignore-deprecated */ self::assertValidPattern($element);

        return sprintf(
            '/^%s$/u',
            str_replace(
                '\\',
                '\\\\',
                str_replace(
                    '*',
                    '.*',
                    $element,
                ),
            ),
        );
    }

    /**
     * @deprecated
     */
    private static function assertValidPattern(string $element): void
    {
        if (1 !== native_preg_match('/^(([\p{L}_]+\\\\)+)?[\p{L}_]*\*$/u', $element)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Invalid whitelist pattern "%s".',
                    $element,
                ),
            );
        }
    }

    /**
     * @deprecated
     */
    private static function lowerCaseConstantName(string $name): string
    {
        $parts = explode('\\', $name);

        $lastPart = array_pop($parts);

        $parts = array_map('strtolower', $parts);

        $parts[] = $lastPart;

        return implode('\\', $parts);
    }
}

humbug / php-scoper

Push — master ( 210c58...766469 )

lowerCaseConstantName() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
