SymbolRegistry::matches() - Code Metrics - humbug/php-scoper - Measure and Improve Code Quality continuously with Scrutinizer

SymbolRegistry::matches() A
last analyzed 2022-10-12 21:08 UTC

↳ Parent: SymbolRegistry

Complexity

Conditions	5
Paths	8

Size

Total Lines	18
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	5
eloc	10
nc	8
nop	1
dl	0
loc	18
rs	9.6111
c	1
b	0
f	0

<?php

declare(strict_types=1);

/*
 * This file is part of the humbug/php-scoper package.
 *
 * Copyright (c) 2017 Théo FIDRY <[email protected]>,
 *                    Pádraic Brady <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Humbug\PhpScoper\Symbol;

use InvalidArgumentException;
use function array_key_exists;
use function array_keys;
use function array_map;
use function array_pop;
use function array_unique;
use function explode;
use function implode;
use function ltrim;
use function Safe\array_flip;
use function Safe\preg_match;
use function strtolower;
use function trim;
use const SORT_STRING;

final class SymbolRegistry
{
    /**
     * @var array<string, mixed>
     */
    private array $names;

    /**
     * @var list<string>
filter:
    dependency_paths: ["lib/*"]
     */
    private array $regexes;

    private bool $constants;

    /**
     * @param string[] $names
     * @param string[] $regexes
     */
    public static function create(
        array $names = [],
        array $regexes = []
    ): self {
        return new self(
            array_map(
                static fn (string $name) => strtolower(trim($name, '\\')),
                $names,
            ),
            array_unique($regexes, SORT_STRING),
            false,
        );
    }

    /**
     * Unlike classes & functions, constants are not case-insensitive (although
     * the namespace part _is_). I.e. \Acme\FOO = \ACME\FOO but Acme\FOO ≠ Acme\Foo.
     *
     * @param string[] $names
     * @param string[] $regexes
     */
    public static function createForConstants(
        array $names = [],
        array $regexes = []
    ): self {
        return new self(
            array_map(
                static fn (string $name) => self::lowerCaseConstantName(
                    trim($name, '\\'),
                ),
                $names,
            ),
            array_unique($regexes, SORT_STRING),
            true,
        );
    }

    /**
     * @param list<string> $names
     * @param list<string> $regexes
     */
    private function __construct(
        array $names,
        array $regexes,
        bool $constants
    ) {
        $this->names = array_flip($names);
        $this->names = /** @scrutinizer ignore-deprecated */ array_flip($names);
        $this->regexes = $regexes;

        $this->constants = $constants;
    }

    public function matches(string $symbol): bool
    {
        $originalSymbol = ltrim($symbol, '\\');
        $symbol = $this->constants
            ? self::lowerCaseConstantName($originalSymbol)
            : strtolower($originalSymbol);

        if (array_key_exists($symbol, $this->names)) {
            return true;
        }

        foreach ($this->regexes as $regex) {
            if (preg_match($regex, $originalSymbol)) {
                return true;
            }
        }

        return false;
    }

    public function merge(self $registry): self
    {
        if ($this->constants !== $registry->constants) {
            throw new InvalidArgumentException('Cannot merge registries of different symbol types');
        }

        $args = [
            [
                ...$this->getNames(),
                ...$registry->getNames(),
            ],
            [
                ...$this->getRegexes(),
                ...$registry->getRegexes(),
            ],
        ];

        return $this->constants
            ? self::createForConstants(...$args)
            ? self::createForConstants(/** @scrutinizer ignore-type */ ...$args)
            : self::create(...$args);
            : self::create(/** @scrutinizer ignore-type */ ...$args);
    }

    /**
     * @internal
     *
     * @return list<string>
     */
    public function getNames(): array
    {
        return array_keys($this->names);

    }

    /**
     * @internal
     *
     * @erturn list<string>
     */
    public function getRegexes(): array
    {
        return $this->regexes;
    }

    /**
     * Transforms the constant FQ name "Acme\Foo\X" to "acme\foo\X" since the
     * namespace remains case-insensitive for constants regardless of whether
     * constants actually are case-insensitive.
     */
    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

SymbolRegistry::matches() A last analyzed 2022-10-12 21:08 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

SymbolRegistry::matches() A
last analyzed 2022-10-12 21:08 UTC