Whitelist::belongsToWhitelistedNamespace() - Code Metrics - Inspection of "Reworking the whitelist API (#247)" - humbug/php-scoper - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 53494e...bc3061 )

by Théo

created 2018-07-16 16:20 UTC

Whitelist::belongsToWhitelistedNamespace() A

↳ Parent: Whitelist

Complexity

Conditions	5
Paths	6

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
nc	6
nop	1
dl	0
loc	16
rs	9.4222
c	0
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;

use Countable;
use InvalidArgumentException;
use PhpParser\Node\Name\FullyQualified;
use const SORT_REGULAR;
use function array_flip;
use function array_key_exists;
use function array_map;
use function array_pop;
use function array_unique;
use function array_values;
use function count;
use function explode;
use function implode;
use function preg_match;
use function sprintf;
use function str_replace;
use function strpos;
use function strtolower;
use function substr;
use function trim;

final class Whitelist implements Countable
{
    private $original;
    private $symbols;
    private $constants;
    private $namespaces;
    private $patterns;

    private $whitelistGlobalConstants;
    private $whitelistGlobalFunctions;

    private $whitelistedFunctions = [];
    private $whitelistedClasses = [];

    public static function create(bool $whitelistGlobalConstants, bool $whitelistGlobalFunctions, string ...$elements): self
    {
        $symbols = [];
        $constants = [];
        $namespaces = [];
        $patterns = [];
        $original = [];

        foreach ($elements as $element) {
            if (isset($element[0]) && '\\' === $element[0]) {
                $element = substr($element, 1);
            }

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

            $original[] = $element;

            if ('\*' === substr($element, -2)) {
                $namespaces[] = strtolower(substr($element, 0, -2));
            } elseif ('*' === $element) {
                $namespaces[] = '';
            } elseif (false !== strpos($element, '*')) {
                self::assertValidPattern($element);

                $patterns[] = sprintf(
                    '/^%s$/u',
                    str_replace(
                        '\\',
                        '\\\\',
                        str_replace(
                            '*',
                            '.*',
                            $element
                        )
                    )
                );
            } else {
                $symbols[] = strtolower($element);
                $constants[] = self::lowerConstantName($element);
            }
        }

        return new self(
            $whitelistGlobalConstants,
            $whitelistGlobalFunctions,
            array_unique($original),
            array_flip($symbols),
            array_flip($constants),
            array_unique($patterns),
            array_unique($namespaces)
        );
    }

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

    /**
     * @param string[] $original
     * @param string[] $patterns
     * @param string[] $namespaces
     */
    private function __construct(
        bool $whitelistGlobalConstants,
        bool $whitelistGlobalFunctions,
        array $original,
        array $symbols,
        array $constants,
        array $patterns,
        array $namespaces
    ) {
        $this->whitelistGlobalConstants = $whitelistGlobalConstants;
        $this->whitelistGlobalFunctions = $whitelistGlobalFunctions;
        $this->original = $original;
        $this->symbols = $symbols;
        $this->constants = $constants;
        $this->namespaces = $namespaces;
        $this->patterns = $patterns;
    }

    public function belongsToWhitelistedNamespace(string $name): bool
    {
        $name = strtolower($name);

        if (0 === strpos($name, '\\')) {
            $name = substr($name, 1);
        }

        foreach ($this->namespaces as $namespace) {
            if ('' === $namespace || 0 === strpos($name, $namespace)) {
                return true;
            }
        }

        return false;
    }

    /**
     * @internal
     */
    public function whitelistGlobalFunctions(): bool
    {
        return $this->whitelistGlobalFunctions;
    }

    public function isGlobalWhitelistedFunction(string $functionName): bool
    {
        return $this->whitelistGlobalFunctions && false === strpos($functionName, '\\');
    }

    public function recordWhitelistedFunction(FullyQualified $original, FullyQualified $alias): void
    {
        $this->whitelistedFunctions[] = [(string) $original, (string) $alias];
    }

    public function getWhitelistedFunctions(): array
    {
        return array_values(
            array_unique(
                $this->whitelistedFunctions,
                SORT_REGULAR
            )
        );
    }

    /**
     * @internal
     */
    public function whitelistGlobalConstants(): bool
    {
        return $this->whitelistGlobalConstants;
    }

    public function isGlobalWhitelistedConstant(string $constantName): bool
    {
        return $this->whitelistGlobalConstants && false === strpos($constantName, '\\');
    }

    /**
     * @internal
     */
    public function whitelistGlobalClasses(): bool
    {
        return $this->whitelistGlobalFunctions;
    }

    public function isGlobalWhitelistedClass(string $className): bool

    {
        return false;
    }

    public function recordWhitelistedClass(FullyQualified $original, FullyQualified $alias): void
    {
        $this->whitelistedClasses[] = [(string) $original, (string) $alias];
    }

    public function getWhitelistedClasses(): array
    {
        return $this->whitelistedClasses;
    }

    /**
     * Tells if a given symbol is whitelisted. Note however that it does not account for when:.
     *
     * - The symbol belongs to the global namespace and the symbols of the global namespace of this type are whitelisted
     * - Belongs to a whitelisted namespace
     *
     * @param bool $constant Unlike other symbols, constants _can_ be case insensitive but 99% are not so we leave out
     *                       the case where they are not case sensitive.
     */
    public function isSymbolWhitelisted(string $name, bool $constant = false): bool
    {
        if (false === $constant && array_key_exists(strtolower($name), $this->symbols)) {
            return true;
        }

        if ($constant && array_key_exists(self::lowerConstantName($name), $this->constants)) {
            return true;
        }

        foreach ($this->patterns as $pattern) {
            $pattern = false === $constant ? $pattern.'i' : $pattern;

            if (1 === preg_match($pattern, $name)) {
                return true;
            }
        }

        return false;
    }

    /**
     * @return string[]
     *
     * @deprecated To be replaced by getWhitelistedClasses
     */
    public function getClassWhitelistArray(): array
    {
        return array_filter(
            $this->original,
            function (string $name): bool {
                return '*' !== $name && '\*' !== substr($name, -2);
            }
        );
    }

    public function toArray(): array
    {
        return $this->original;
    }

    /**
     * {@inheritdoc}
     */
    public function count(): int
    {
        return count($this->whitelistedFunctions) + count($this->whitelistedClasses);
    }

    /**
     * Transforms the constant FQ name "Acme\Foo\X" to "acme\foo\X" since the namespace remains case insensitive for
     * constants regardless of whether or not constants actually are case insensitive.
     */
    private static function lowerConstantName(string $name): string
    {
        $parts = explode('\\', $name);

        $lastPart = array_pop($parts);

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

        $parts[] = $lastPart;

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


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the humbug/php-scoper package.
7			*
8			* Copyright (c) 2017 Théo FIDRY <[email protected]>,
9			* Pádraic Brady <[email protected]>
10			*
11			* For the full copyright and license information, please view the LICENSE
12			* file that was distributed with this source code.
13			*/
14
15			namespace Humbug\PhpScoper;
16
17			use Countable;
18			use InvalidArgumentException;
19			use PhpParser\Node\Name\FullyQualified;
20			use const SORT_REGULAR;
21			use function array_flip;
22			use function array_key_exists;
23			use function array_map;
24			use function array_pop;
25			use function array_unique;
26			use function array_values;
27			use function count;
28			use function explode;
29			use function implode;
30			use function preg_match;
31			use function sprintf;
32			use function str_replace;
33			use function strpos;
34			use function strtolower;
35			use function substr;
36			use function trim;
37
38			final class Whitelist implements Countable
39			{
40			private $original;
41			private $symbols;
42			private $constants;
43			private $namespaces;
44			private $patterns;
45
46			private $whitelistGlobalConstants;
47			private $whitelistGlobalFunctions;
48
49			private $whitelistedFunctions = [];
50			private $whitelistedClasses = [];
51
52			public static function create(bool $whitelistGlobalConstants, bool $whitelistGlobalFunctions, string ...$elements): self
53			{
54			$symbols = [];
55			$constants = [];
56			$namespaces = [];
57			$patterns = [];
58			$original = [];
59
60			foreach ($elements as $element) {
61			if (isset($element[0]) && '\\' === $element[0]) {
62			$element = substr($element, 1);
63			}
64
65			if ('' === trim($element)) {
66			throw new InvalidArgumentException(
67			sprintf(
68			'Invalid whitelist element "%s": cannot accept an empty string',
69			$element
70			)
71			);
72			}
73
74			$original[] = $element;
75
76			if ('\*' === substr($element, -2)) {
77			$namespaces[] = strtolower(substr($element, 0, -2));
78			} elseif ('*' === $element) {
79			$namespaces[] = '';
80			} elseif (false !== strpos($element, '*')) {
81			self::assertValidPattern($element);
82
83			$patterns[] = sprintf(
84			'/^%s$/u',
85			str_replace(
86			'\\',
87			'\\\\',
88			str_replace(
89			'*',
90			'.*',
91			$element
92			)
93			)
94			);
95			} else {
96			$symbols[] = strtolower($element);
97			$constants[] = self::lowerConstantName($element);
98			}
99			}
100
101			return new self(
102			$whitelistGlobalConstants,
103			$whitelistGlobalFunctions,
104			array_unique($original),
105			array_flip($symbols),
106			array_flip($constants),
107			array_unique($patterns),
108			array_unique($namespaces)
109			);
110			}
111
112			private static function assertValidPattern(string $element): void
113			{
114			if (1 !== preg_match('/^(([\p{L}_]+\\\\)+)?[\p{L}_]\$/u', $element)) {
115			throw new \InvalidArgumentException(
116			sprintf(
117			'Invalid whitelist pattern "%s".',
118			$element
119			)
120			);
121			}
122			}
123
124			/**
125			* @param string[] $original
126			* @param string[] $patterns
127			* @param string[] $namespaces
128			*/
129			private function __construct(
130			bool $whitelistGlobalConstants,
131			bool $whitelistGlobalFunctions,
132			array $original,
133			array $symbols,
134			array $constants,
135			array $patterns,
136			array $namespaces
137			) {
138			$this->whitelistGlobalConstants = $whitelistGlobalConstants;
139			$this->whitelistGlobalFunctions = $whitelistGlobalFunctions;
140			$this->original = $original;
141			$this->symbols = $symbols;
142			$this->constants = $constants;
143			$this->namespaces = $namespaces;
144			$this->patterns = $patterns;
145			}
146
147			public function belongsToWhitelistedNamespace(string $name): bool
148			{
149			$name = strtolower($name);
150
151			if (0 === strpos($name, '\\')) {
152			$name = substr($name, 1);
153			}
154
155			foreach ($this->namespaces as $namespace) {
156			if ('' === $namespace \|\| 0 === strpos($name, $namespace)) {
157			return true;
158			}
159			}
160
161			return false;
162			}
163
164			/**
165			* @internal
166			*/
167			public function whitelistGlobalFunctions(): bool
168			{
169			return $this->whitelistGlobalFunctions;
170			}
171
172			public function isGlobalWhitelistedFunction(string $functionName): bool
173			{
174			return $this->whitelistGlobalFunctions && false === strpos($functionName, '\\');
175			}
176
177			public function recordWhitelistedFunction(FullyQualified $original, FullyQualified $alias): void
178			{
179			$this->whitelistedFunctions[] = [(string) $original, (string) $alias];
180			}
181
182			public function getWhitelistedFunctions(): array
183			{
184			return array_values(
185			array_unique(
186			$this->whitelistedFunctions,
187			SORT_REGULAR
188			)
189			);
190			}
191
192			/**
193			* @internal
194			*/
195			public function whitelistGlobalConstants(): bool
196			{
197			return $this->whitelistGlobalConstants;
198			}
199
200			public function isGlobalWhitelistedConstant(string $constantName): bool
201			{
202			return $this->whitelistGlobalConstants && false === strpos($constantName, '\\');
203			}
204
205			/**
206			* @internal
207			*/
208			public function whitelistGlobalClasses(): bool
209			{
210			return $this->whitelistGlobalFunctions;
211			}
212
213			public function isGlobalWhitelistedClass(string $className): bool
			0 ignored issues – show Unused Code introduced 2018-07-14 14:08 UTC by Report Bug Copy Issue Report The parameter `$className` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
214			{
215			return false;
216			}
217
218			public function recordWhitelistedClass(FullyQualified $original, FullyQualified $alias): void
219			{
220			$this->whitelistedClasses[] = [(string) $original, (string) $alias];
221			}
222
223			public function getWhitelistedClasses(): array
224			{
225			return $this->whitelistedClasses;
226			}
227
228			/**
229			* Tells if a given symbol is whitelisted. Note however that it does not account for when:.
230			*
231			* - The symbol belongs to the global namespace and the symbols of the global namespace of this type are whitelisted
232			* - Belongs to a whitelisted namespace
233			*
234			* @param bool $constant Unlike other symbols, constants _can_ be case insensitive but 99% are not so we leave out
235			* the case where they are not case sensitive.
236			*/
237			public function isSymbolWhitelisted(string $name, bool $constant = false): bool
238			{
239			if (false === $constant && array_key_exists(strtolower($name), $this->symbols)) {
240			return true;
241			}
242
243			if ($constant && array_key_exists(self::lowerConstantName($name), $this->constants)) {
244			return true;
245			}
246
247			foreach ($this->patterns as $pattern) {
248			$pattern = false === $constant ? $pattern.'i' : $pattern;
249
250			if (1 === preg_match($pattern, $name)) {
251			return true;
252			}
253			}
254
255			return false;
256			}
257
258			/**
259			* @return string[]
260			*
261			* @deprecated To be replaced by getWhitelistedClasses
262			*/
263			public function getClassWhitelistArray(): array
264			{
265			return array_filter(
266			$this->original,
267			function (string $name): bool {
268			return '' !== $name && '\' !== substr($name, -2);
269			}
270			);
271			}
272
273			public function toArray(): array
274			{
275			return $this->original;
276			}
277
278			/**
279			* {@inheritdoc}
280			*/
281			public function count(): int
282			{
283			return count($this->whitelistedFunctions) + count($this->whitelistedClasses);
284			}
285
286			/**
287			* Transforms the constant FQ name "Acme\Foo\X" to "acme\foo\X" since the namespace remains case insensitive for
288			* constants regardless of whether or not constants actually are case insensitive.
289			*/
290			private static function lowerConstantName(string $name): string
291			{
292			$parts = explode('\\', $name);
293
294			$lastPart = array_pop($parts);
295
296			$parts = array_map('strtolower', $parts);
297
298			$parts[] = $lastPart;
299
300			return implode('\\', $parts);
301			}
302			}
303

humbug / php-scoper

Push — master ( 53494e...bc3061 )

Whitelist::belongsToWhitelistedNamespace() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like