ConfigurationFactory::retrievePatchers() - Code Metrics - Inspection of "Move Prefix validation to the Configuration class..." - humbug/php-scoper - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( e11383...6e4589 )

by Théo

created 2021-05-31 06:55 UTC

ConfigurationFactory::retrievePatchers() A

↳ Parent: ConfigurationFactory

Complexity

Conditions	5
Paths	5

Size

Total Lines	31
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	5
eloc	16
c	1
b	0
f	0
nc	5
nop	1
dl	0
loc	31
rs	9.4222

<?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 Humbug\PhpScoper\Patcher\SymfonyPatcher;
use InvalidArgumentException;
use Iterator;
use RuntimeException;
use SplFileInfo;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Finder\Finder;
use function array_filter;
use function array_key_exists;
use function array_keys;
use function array_map;
use function array_merge;
use function array_reduce;
use function array_unique;
use function array_unshift;
use function bin2hex;
use function dirname;
use function file_exists;
use function gettype;
use function in_array;
use function is_array;
use function is_bool;
use function is_callable;
use function is_dir;
use function is_file;
use function is_link;
use function is_readable;
use function is_string;
use function iterator_to_array;
use function random_bytes;
use function readlink as native_readlink;
use function realpath;
use function Safe\file_get_contents;
use function Safe\sprintf;
use function trim;
use const DIRECTORY_SEPARATOR;

final class ConfigurationFactory
{
    private const PREFIX_KEYWORD = 'prefix';
    private const WHITELISTED_FILES_KEYWORD = 'files-whitelist';
    private const FINDER_KEYWORD = 'finders';
    private const PATCHERS_KEYWORD = 'patchers';
    private const WHITELIST_KEYWORD = 'whitelist';
    private const WHITELIST_GLOBAL_CONSTANTS_KEYWORD = 'whitelist-global-constants';
    private const WHITELIST_GLOBAL_CLASSES_KEYWORD = 'whitelist-global-classes';
    private const WHITELIST_GLOBAL_FUNCTIONS_KEYWORD = 'whitelist-global-functions';

    private const KEYWORDS = [
        self::PREFIX_KEYWORD,
        self::WHITELISTED_FILES_KEYWORD,
        self::FINDER_KEYWORD,
        self::PATCHERS_KEYWORD,
        self::WHITELIST_KEYWORD,
        self::WHITELIST_GLOBAL_CONSTANTS_KEYWORD,
        self::WHITELIST_GLOBAL_CLASSES_KEYWORD,
        self::WHITELIST_GLOBAL_FUNCTIONS_KEYWORD,
    ];

    private Filesystem $fileSystem;

    public function __construct(Filesystem $fileSystem)
    {
        $this->fileSystem = $fileSystem;
    }

    /**
     * @param string|null $path  Absolute path to the configuration file.
     * @param string[]    $paths List of paths to append besides the one configured
     */
    public function create(?string $path = null, array $paths = []): Configuration
    {
        if (null === $path) {
            $config = [];
        } else {
            $config = $this->loadConfigFile($path);
        }

        self::validateConfigKeys($config);

        $prefix = self::retrievePrefix($config);

        $whitelistedFiles = null === $path
            ? []
            : $this->retrieveWhitelistedFiles(
                dirname($path),
                $config,
            );

        $patchers = self::retrievePatchers($config);

        array_unshift($patchers, new SymfonyPatcher());

        $whitelist = self::retrieveWhitelist($config);

        $finders = self::retrieveFinders($config);
        $filesFromPaths = self::retrieveFilesFromPaths($paths);
        $filesWithContents = self::retrieveFilesWithContents(chain($filesFromPaths, ...$finders));

        return new Configuration(
            $path,
            $prefix,
            $filesWithContents,
            $patchers,
            $whitelist,
            $whitelistedFiles,
        );
    }

    /**
     * @param string[] $paths
     */
    public function createWithPaths(Configuration $config, array $paths): Configuration
    {
        $filesWithContents = self::retrieveFilesWithContents(
            chain(
                self::retrieveFilesFromPaths(
                    array_unique($paths),
                ),
            ),
        );

        return new Configuration(
            $config->getPath(),
            $config->getPrefix(),
            array_merge(
                $config->getFilesWithContents(),
                $filesWithContents,
            ),
            $config->getPatchers(),
            $config->getWhitelist(),
            $config->getWhitelistedFiles(),
        );
    }

    public function createWithPrefix(Configuration $config, string $prefix): Configuration
    {
        $prefix = self::retrievePrefix([self::PREFIX_KEYWORD => $prefix]);

        return new Configuration(
            $config->getPath(),
            $prefix,
            $config->getFilesWithContents(),
            $config->getPatchers(),
            $config->getWhitelist(),
            $config->getWhitelistedFiles(),
        );
    }

    private function loadConfigFile(string $path): array
    {
        if (false === $this->fileSystem->isAbsolutePath($path)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Expected the path of the configuration file to load to be an absolute path, got "%s" instead',
                    $path,
                ),
            );
        }

        if (false === file_exists($path)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Expected the path of the configuration file to exists but the file "%s" could not be found',
                    $path,
                ),
            );
        }

        $isADirectoryLink = is_link($path)
            && false !== native_readlink($path)
            && is_file(native_readlink($path));

        if (false === is_file($path) && false === $isADirectoryLink) {
            throw new InvalidArgumentException(
                sprintf(
                    'Expected the path of the configuration file to be a file but "%s" appears to be a directory.',
                    $path
                )
            );
        }

        $config = include $path;

        if (false === is_array($config)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Expected configuration to be an array, found "%s" instead.',
                    gettype($config)
                )
            );
        }

        return $config;
    }

    private static function validateConfigKeys(array $config): void
    {
        array_map(
            [self::class, 'validateConfigKey'],
            array_keys($config),
        );
    }

    private static function validateConfigKey(string $key): void
    {
        if (in_array($key, self::KEYWORDS, true)) {
            return;
        }

        throw new InvalidArgumentException(
            sprintf(
                'Invalid configuration key value "%s" found.',
                $key,
            ),
        );
    }

    private static function retrievePrefix(array $config): string
    {
        $prefix = trim((string) $config[self::PREFIX_KEYWORD] ?? '');

        if ('' === $prefix) {
            return self::generateRandomPrefix();
        }

        throw new InvalidArgumentException(
            sprintf(
                'The prefix needs to be composed solely of letters and digits. Got "%s"',
                $prefix,
            ),
        );
    }

    /**
     * @return callable[]
     */
    private static function retrievePatchers(array $config): array
    {
        if (false === array_key_exists(self::PATCHERS_KEYWORD, $config)) {
            return [];
        }

        $patchers = $config[self::PATCHERS_KEYWORD];

        if (false === is_array($patchers)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Expected patchers to be an array of callables, found "%s" instead.',
                    gettype($patchers)
                )
            );
        }

        foreach ($patchers as $index => $patcher) {
            if (is_callable($patcher)) {
                continue;
            }

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

        return $patchers;
    }

    private static function retrieveWhitelist(array $config): Whitelist
    {
        if (false === array_key_exists(self::WHITELIST_KEYWORD, $config)) {
            $whitelist = [];
        } else {
            $whitelist = $config[self::WHITELIST_KEYWORD];

            if (false === is_array($whitelist)) {
                throw new InvalidArgumentException(
                    sprintf(
                        'Expected whitelist to be an array of strings, found "%s" instead.',
                        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
                    )
                );
            }
        }

        if (false === array_key_exists(self::WHITELIST_GLOBAL_CONSTANTS_KEYWORD, $config)) {
            $whitelistGlobalConstants = true;
        } else {
            $whitelistGlobalConstants = $config[self::WHITELIST_GLOBAL_CONSTANTS_KEYWORD];

            if (false === is_bool($whitelistGlobalConstants)) {
                throw new InvalidArgumentException(
                    sprintf(
                        'Expected %s to be a boolean, found "%s" instead.',
                        self::WHITELIST_GLOBAL_CONSTANTS_KEYWORD,
                        gettype($whitelistGlobalConstants)
                    )
                );
            }
        }

        if (false === array_key_exists(self::WHITELIST_GLOBAL_CLASSES_KEYWORD, $config)) {
            $whitelistGlobalClasses = true;
        } else {
            $whitelistGlobalClasses = $config[self::WHITELIST_GLOBAL_CLASSES_KEYWORD];

            if (false === is_bool($whitelistGlobalClasses)) {
                throw new InvalidArgumentException(
                    sprintf(
                        'Expected %s to be a boolean, found "%s" instead.',
                        self::WHITELIST_GLOBAL_CLASSES_KEYWORD,
                        gettype($whitelistGlobalClasses)
                    )
                );
            }
        }

        if (false === array_key_exists(self::WHITELIST_GLOBAL_FUNCTIONS_KEYWORD, $config)) {
            $whitelistGlobalFunctions = true;
        } else {
            $whitelistGlobalFunctions = $config[self::WHITELIST_GLOBAL_FUNCTIONS_KEYWORD];

            if (false === is_bool($whitelistGlobalFunctions)) {
                throw new InvalidArgumentException(
                    sprintf(
                        'Expected %s to be a boolean, found "%s" instead.',
                        self::WHITELIST_GLOBAL_FUNCTIONS_KEYWORD,
                        gettype($whitelistGlobalFunctions)
                    )
                );
            }
        }

        return Whitelist::create(
            $whitelistGlobalConstants,
            $whitelistGlobalClasses,
            $whitelistGlobalFunctions,
            ...$whitelist,
        );
    }

    /**
     * @return string[] Absolute paths
     */
    private function retrieveWhitelistedFiles(string $dirPath, array $config): array
    {
        if (false === array_key_exists(self::WHITELISTED_FILES_KEYWORD, $config)) {
            return [];
        }

        $whitelistedFiles = $config[self::WHITELISTED_FILES_KEYWORD];

        if (false === is_array($whitelistedFiles)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Expected whitelisted files to be an array of strings, found "%s" instead.',
                    gettype($whitelistedFiles)
                )
            );
        }

        foreach ($whitelistedFiles as $index => $file) {
            if (false === is_string($file)) {
                throw new InvalidArgumentException(
                    sprintf(
                        'Expected whitelisted files to be an array of string, the "%d" element is not.',
                        $index
                    )
                );
            }

            if (false === $this->fileSystem->isAbsolutePath($file)) {
                $file = $dirPath.DIRECTORY_SEPARATOR.$file;
            }

            $whitelistedFiles[$index] = realpath($file);
        }

        return array_filter($whitelistedFiles);
    }

    /**
     * @return Finder[]
     */
    private static function retrieveFinders(array $config): array
    {
        if (false === array_key_exists(self::FINDER_KEYWORD, $config)) {
            return [];
        }

        $finders = $config[self::FINDER_KEYWORD];

        if (false === is_array($finders)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Expected finders to be an array of "%s", found "%s" instead.',
                    Finder::class,
                    gettype($finders)
                )
            );
        }

        foreach ($finders as $index => $finder) {
            if ($finder instanceof Finder) {
                continue;
            }

            throw new InvalidArgumentException(
                sprintf(
                    'Expected finders to be an array of "%s", the "%d" element is not.',
                    Finder::class,
                    $index
                )
            );
        }

        return $finders;
    }

    /**
     * @param string[] $paths
     *
     * @return iterable<SplFileInfo>
     */
    private static function retrieveFilesFromPaths(array $paths): iterable
    {
        if ([] === $paths) {
            return [];
        }

        $pathsToSearch = [];
        $filesToAppend = [];

        foreach ($paths as $path) {
            if (false === file_exists($path)) {
                throw new RuntimeException(
                    sprintf(
                        'Could not find the file "%s".',
                        $path
                    )
                );
            }

            if (is_dir($path)) {
                $pathsToSearch[] = $path;
            } else {
                $filesToAppend[] = $path;
            }
        }

        $finder = new Finder();

        $finder->files()
            ->in($pathsToSearch)
            ->append($filesToAppend)
            ->filter(
                static fn (SplFileInfo $fileInfo) => $fileInfo->isLink() ? false : null
            )
            ->sortByName();

        return $finder;
    }

    /**
     * @param Iterator<SplFileInfo> $files
     *
     * @return array<string, array{string, string}> Array of tuple with the first argument being the file path and the second its contents

     */
    private static function retrieveFilesWithContents(Iterator $files): array
    {
        return array_reduce(
            iterator_to_array($files, false),
            static function (array $files, SplFileInfo $fileInfo): array {
                $file = $fileInfo->getRealPath();

                if (false === $file) {
                    throw new RuntimeException(
                        sprintf(
                            'Could not find the file "%s".',
                            (string) $fileInfo,
                        ),
                    );
                }

                if (false === is_readable($file)) {
                    throw new RuntimeException(
                        sprintf(
                            'Could not read the file "%s".',
                            $file,
                        ),
                    );
                }

                $files[$fileInfo->getRealPath()] = [$fileInfo->getRealPath(), file_get_contents($file)];

                return $files;
            },
            [],
        );
    }

    private static function generateRandomPrefix(): string
    {
        return '_PhpScoper'.bin2hex(random_bytes(6));
    }
}


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 Humbug\PhpScoper\Patcher\SymfonyPatcher;
18			use InvalidArgumentException;
19			use Iterator;
20			use RuntimeException;
21			use SplFileInfo;
22			use Symfony\Component\Filesystem\Filesystem;
23			use Symfony\Component\Finder\Finder;
24			use function array_filter;
25			use function array_key_exists;
26			use function array_keys;
27			use function array_map;
28			use function array_merge;
29			use function array_reduce;
30			use function array_unique;
31			use function array_unshift;
32			use function bin2hex;
33			use function dirname;
34			use function file_exists;
35			use function gettype;
36			use function in_array;
37			use function is_array;
38			use function is_bool;
39			use function is_callable;
40			use function is_dir;
41			use function is_file;
42			use function is_link;
43			use function is_readable;
44			use function is_string;
45			use function iterator_to_array;
46			use function random_bytes;
47			use function readlink as native_readlink;
48			use function realpath;
49			use function Safe\file_get_contents;
50			use function Safe\sprintf;
51			use function trim;
52			use const DIRECTORY_SEPARATOR;
53
54			final class ConfigurationFactory
55			{
56			private const PREFIX_KEYWORD = 'prefix';
57			private const WHITELISTED_FILES_KEYWORD = 'files-whitelist';
58			private const FINDER_KEYWORD = 'finders';
59			private const PATCHERS_KEYWORD = 'patchers';
60			private const WHITELIST_KEYWORD = 'whitelist';
61			private const WHITELIST_GLOBAL_CONSTANTS_KEYWORD = 'whitelist-global-constants';
62			private const WHITELIST_GLOBAL_CLASSES_KEYWORD = 'whitelist-global-classes';
63			private const WHITELIST_GLOBAL_FUNCTIONS_KEYWORD = 'whitelist-global-functions';
64
65			private const KEYWORDS = [
66			self::PREFIX_KEYWORD,
67			self::WHITELISTED_FILES_KEYWORD,
68			self::FINDER_KEYWORD,
69			self::PATCHERS_KEYWORD,
70			self::WHITELIST_KEYWORD,
71			self::WHITELIST_GLOBAL_CONSTANTS_KEYWORD,
72			self::WHITELIST_GLOBAL_CLASSES_KEYWORD,
73			self::WHITELIST_GLOBAL_FUNCTIONS_KEYWORD,
74			];
75
76			private Filesystem $fileSystem;
77
78			public function __construct(Filesystem $fileSystem)
79			{
80			$this->fileSystem = $fileSystem;
81			}
82
83			/**
84			* @param string\|null $path Absolute path to the configuration file.
85			* @param string[] $paths List of paths to append besides the one configured
86			*/
87			public function create(?string $path = null, array $paths = []): Configuration
88			{
89			if (null === $path) {
90			$config = [];
91			} else {
92			$config = $this->loadConfigFile($path);
93			}
94
95			self::validateConfigKeys($config);
96
97			$prefix = self::retrievePrefix($config);
98
99			$whitelistedFiles = null === $path
100			? []
101			: $this->retrieveWhitelistedFiles(
102			dirname($path),
103			$config,
104			);
105
106			$patchers = self::retrievePatchers($config);
107
108			array_unshift($patchers, new SymfonyPatcher());
109
110			$whitelist = self::retrieveWhitelist($config);
111
112			$finders = self::retrieveFinders($config);
113			$filesFromPaths = self::retrieveFilesFromPaths($paths);
114			$filesWithContents = self::retrieveFilesWithContents(chain($filesFromPaths, ...$finders));
115
116			return new Configuration(
117			$path,
118			$prefix,
119			$filesWithContents,
120			$patchers,
121			$whitelist,
122			$whitelistedFiles,
123			);
124			}
125
126			/**
127			* @param string[] $paths
128			*/
129			public function createWithPaths(Configuration $config, array $paths): Configuration
130			{
131			$filesWithContents = self::retrieveFilesWithContents(
132			chain(
133			self::retrieveFilesFromPaths(
134			array_unique($paths),
135			),
136			),
137			);
138
139			return new Configuration(
140			$config->getPath(),
141			$config->getPrefix(),
142			array_merge(
143			$config->getFilesWithContents(),
144			$filesWithContents,
145			),
146			$config->getPatchers(),
147			$config->getWhitelist(),
148			$config->getWhitelistedFiles(),
149			);
150			}
151
152			public function createWithPrefix(Configuration $config, string $prefix): Configuration
153			{
154			$prefix = self::retrievePrefix([self::PREFIX_KEYWORD => $prefix]);
155
156			return new Configuration(
157			$config->getPath(),
158			$prefix,
159			$config->getFilesWithContents(),
160			$config->getPatchers(),
161			$config->getWhitelist(),
162			$config->getWhitelistedFiles(),
163			);
164			}
165
166			private function loadConfigFile(string $path): array
167			{
168			if (false === $this->fileSystem->isAbsolutePath($path)) {
169			throw new InvalidArgumentException(
170			sprintf(
171			'Expected the path of the configuration file to load to be an absolute path, got "%s" instead',
172			$path,
173			),
174			);
175			}
176
177			if (false === file_exists($path)) {
178			throw new InvalidArgumentException(
179			sprintf(
180			'Expected the path of the configuration file to exists but the file "%s" could not be found',
181			$path,
182			),
183			);
184			}
185
186			$isADirectoryLink = is_link($path)
187			&& false !== native_readlink($path)
188			&& is_file(native_readlink($path));
189
190			if (false === is_file($path) && false === $isADirectoryLink) {
191			throw new InvalidArgumentException(
192			sprintf(
193			'Expected the path of the configuration file to be a file but "%s" appears to be a directory.',
194			$path
195			)
196			);
197			}
198
199			$config = include $path;
200
201			if (false === is_array($config)) {
202			throw new InvalidArgumentException(
203			sprintf(
204			'Expected configuration to be an array, found "%s" instead.',
205			gettype($config)
206			)
207			);
208			}
209
210			return $config;
211			}
212
213			private static function validateConfigKeys(array $config): void
214			{
215			array_map(
216			[self::class, 'validateConfigKey'],
217			array_keys($config),
218			);
219			}
220
221			private static function validateConfigKey(string $key): void
222			{
223			if (in_array($key, self::KEYWORDS, true)) {
224			return;
225			}
226
227			throw new InvalidArgumentException(
228			sprintf(
229			'Invalid configuration key value "%s" found.',
230			$key,
231			),
232			);
233			}
234
235			private static function retrievePrefix(array $config): string
236			{
237			$prefix = trim((string) $config[self::PREFIX_KEYWORD] ?? '');
238
239			if ('' === $prefix) {
240			return self::generateRandomPrefix();
241			}
242
243			throw new InvalidArgumentException(
244			sprintf(
245			'The prefix needs to be composed solely of letters and digits. Got "%s"',
246			$prefix,
247			),
248			);
249			}
250
251			/**
252			* @return callable[]
253			*/
254			private static function retrievePatchers(array $config): array
255			{
256			if (false === array_key_exists(self::PATCHERS_KEYWORD, $config)) {
257			return [];
258			}
259
260			$patchers = $config[self::PATCHERS_KEYWORD];
261
262			if (false === is_array($patchers)) {
263			throw new InvalidArgumentException(
264			sprintf(
265			'Expected patchers to be an array of callables, found "%s" instead.',
266			gettype($patchers)
267			)
268			);
269			}
270
271			foreach ($patchers as $index => $patcher) {
272			if (is_callable($patcher)) {
273			continue;
274			}
275
276			throw new InvalidArgumentException(
277			sprintf(
278			'Expected patchers to be an array of callables, the "%d" element is not.',
279			$index
280			)
281			);
282			}
283
284			return $patchers;
285			}
286
287			private static function retrieveWhitelist(array $config): Whitelist
288			{
289			if (false === array_key_exists(self::WHITELIST_KEYWORD, $config)) {
290			$whitelist = [];
291			} else {
292			$whitelist = $config[self::WHITELIST_KEYWORD];
293
294			if (false === is_array($whitelist)) {
295			throw new InvalidArgumentException(
296			sprintf(
297			'Expected whitelist to be an array of strings, found "%s" instead.',
298			gettype($whitelist)
299			)
300			);
301			}
302
303			foreach ($whitelist as $index => $className) {
304			if (is_string($className)) {
305			continue;
306			}
307
308			throw new InvalidArgumentException(
309			sprintf(
310			'Expected whitelist to be an array of string, the "%d" element is not.',
311			$index
312			)
313			);
314			}
315			}
316
317			if (false === array_key_exists(self::WHITELIST_GLOBAL_CONSTANTS_KEYWORD, $config)) {
318			$whitelistGlobalConstants = true;
319			} else {
320			$whitelistGlobalConstants = $config[self::WHITELIST_GLOBAL_CONSTANTS_KEYWORD];
321
322			if (false === is_bool($whitelistGlobalConstants)) {
323			throw new InvalidArgumentException(
324			sprintf(
325			'Expected %s to be a boolean, found "%s" instead.',
326			self::WHITELIST_GLOBAL_CONSTANTS_KEYWORD,
327			gettype($whitelistGlobalConstants)
328			)
329			);
330			}
331			}
332
333			if (false === array_key_exists(self::WHITELIST_GLOBAL_CLASSES_KEYWORD, $config)) {
334			$whitelistGlobalClasses = true;
335			} else {
336			$whitelistGlobalClasses = $config[self::WHITELIST_GLOBAL_CLASSES_KEYWORD];
337
338			if (false === is_bool($whitelistGlobalClasses)) {
339			throw new InvalidArgumentException(
340			sprintf(
341			'Expected %s to be a boolean, found "%s" instead.',
342			self::WHITELIST_GLOBAL_CLASSES_KEYWORD,
343			gettype($whitelistGlobalClasses)
344			)
345			);
346			}
347			}
348
349			if (false === array_key_exists(self::WHITELIST_GLOBAL_FUNCTIONS_KEYWORD, $config)) {
350			$whitelistGlobalFunctions = true;
351			} else {
352			$whitelistGlobalFunctions = $config[self::WHITELIST_GLOBAL_FUNCTIONS_KEYWORD];
353
354			if (false === is_bool($whitelistGlobalFunctions)) {
355			throw new InvalidArgumentException(
356			sprintf(
357			'Expected %s to be a boolean, found "%s" instead.',
358			self::WHITELIST_GLOBAL_FUNCTIONS_KEYWORD,
359			gettype($whitelistGlobalFunctions)
360			)
361			);
362			}
363			}
364
365			return Whitelist::create(
366			$whitelistGlobalConstants,
367			$whitelistGlobalClasses,
368			$whitelistGlobalFunctions,
369			...$whitelist,
370			);
371			}
372
373			/**
374			* @return string[] Absolute paths
375			*/
376			private function retrieveWhitelistedFiles(string $dirPath, array $config): array
377			{
378			if (false === array_key_exists(self::WHITELISTED_FILES_KEYWORD, $config)) {
379			return [];
380			}
381
382			$whitelistedFiles = $config[self::WHITELISTED_FILES_KEYWORD];
383
384			if (false === is_array($whitelistedFiles)) {
385			throw new InvalidArgumentException(
386			sprintf(
387			'Expected whitelisted files to be an array of strings, found "%s" instead.',
388			gettype($whitelistedFiles)
389			)
390			);
391			}
392
393			foreach ($whitelistedFiles as $index => $file) {
394			if (false === is_string($file)) {
395			throw new InvalidArgumentException(
396			sprintf(
397			'Expected whitelisted files to be an array of string, the "%d" element is not.',
398			$index
399			)
400			);
401			}
402
403			if (false === $this->fileSystem->isAbsolutePath($file)) {
404			$file = $dirPath.DIRECTORY_SEPARATOR.$file;
405			}
406
407			$whitelistedFiles[$index] = realpath($file);
408			}
409
410			return array_filter($whitelistedFiles);
411			}
412
413			/**
414			* @return Finder[]
415			*/
416			private static function retrieveFinders(array $config): array
417			{
418			if (false === array_key_exists(self::FINDER_KEYWORD, $config)) {
419			return [];
420			}
421
422			$finders = $config[self::FINDER_KEYWORD];
423
424			if (false === is_array($finders)) {
425			throw new InvalidArgumentException(
426			sprintf(
427			'Expected finders to be an array of "%s", found "%s" instead.',
428			Finder::class,
429			gettype($finders)
430			)
431			);
432			}
433
434			foreach ($finders as $index => $finder) {
435			if ($finder instanceof Finder) {
436			continue;
437			}
438
439			throw new InvalidArgumentException(
440			sprintf(
441			'Expected finders to be an array of "%s", the "%d" element is not.',
442			Finder::class,
443			$index
444			)
445			);
446			}
447
448			return $finders;
449			}
450
451			/**
452			* @param string[] $paths
453			*
454			* @return iterable<SplFileInfo>
455			*/
456			private static function retrieveFilesFromPaths(array $paths): iterable
457			{
458			if ([] === $paths) {
459			return [];
460			}
461
462			$pathsToSearch = [];
463			$filesToAppend = [];
464
465			foreach ($paths as $path) {
466			if (false === file_exists($path)) {
467			throw new RuntimeException(
468			sprintf(
469			'Could not find the file "%s".',
470			$path
471			)
472			);
473			}
474
475			if (is_dir($path)) {
476			$pathsToSearch[] = $path;
477			} else {
478			$filesToAppend[] = $path;
479			}
480			}
481
482			$finder = new Finder();
483
484			$finder->files()
485			->in($pathsToSearch)
486			->append($filesToAppend)
487			->filter(
488			static fn (SplFileInfo $fileInfo) => $fileInfo->isLink() ? false : null
489			)
490			->sortByName();
491
492			return $finder;
493			}
494
495			/**
496			* @param Iterator<SplFileInfo> $files
497			*
498			* @return array<string, array{string, string}> Array of tuple with the first argument being the file path and the second its contents
			1 ignored issue – show Documentation Bug introduced 2020-11-29 20:59 UTC by Report Bug Copy Issue Report The doc comment `array<string, array{string, string}>` at position `6` could not be parsed: Expected ':' at position 6, but found 'string'. Loading history...
499			*/
500			private static function retrieveFilesWithContents(Iterator $files): array
501			{
502			return array_reduce(
503			iterator_to_array($files, false),
504			static function (array $files, SplFileInfo $fileInfo): array {
505			$file = $fileInfo->getRealPath();
506
507			if (false === $file) {
508			throw new RuntimeException(
509			sprintf(
510			'Could not find the file "%s".',
511			(string) $fileInfo,
512			),
513			);
514			}
515
516			if (false === is_readable($file)) {
517			throw new RuntimeException(
518			sprintf(
519			'Could not read the file "%s".',
520			$file,
521			),
522			);
523			}
524
525			$files[$fileInfo->getRealPath()] = [$fileInfo->getRealPath(), file_get_contents($file)];
526
527			return $files;
528			},
529			[],
530			);
531			}
532
533			private static function generateRandomPrefix(): string
534			{
535			return '_PhpScoper'.bin2hex(random_bytes(6));
536			}
537			}
538

humbug / php-scoper

Push — master ( e11383...6e4589 )

ConfigurationFactory::retrievePatchers() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like