ConfigurationFactory::retrieveAllInternalSymbols() - Code Metrics - Inspection of "Move excluded (aka internal) user symbols to the S..." - humbug/php-scoper - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#603)

by Théo

created 2022-01-26 11:03 UTC

ConfigurationFactory::retrieveAllInternalSymbols() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	1
dl	0
loc	6
rs	10
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\Configuration;

use Humbug\PhpScoper\Patcher\ComposerPatcher;
use Humbug\PhpScoper\Patcher\Patcher;
use Humbug\PhpScoper\Patcher\PatcherChain;
use Humbug\PhpScoper\Patcher\SymfonyPatcher;
use InvalidArgumentException;
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_unique;
use function array_unshift;
use function array_values;
use function bin2hex;
use function dirname;
use function file_exists;
use function gettype;
use function Humbug\PhpScoper\chain;
use function in_array;
use function is_array;
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 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;
use const SORT_STRING;

final class ConfigurationFactory
{
    private Filesystem $fileSystem;
    private SymbolsConfigurationFactory $configurationWhitelistFactory;

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

    /**
     * @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());
        array_unshift($patchers, new ComposerPatcher());

        $symbolsConfiguration = $this->configurationWhitelistFactory->createSymbolsConfiguration($config);

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

        return new Configuration(
            $path,
            $prefix,
            $filesWithContents,
            self::retrieveFilesWithContents($whitelistedFiles),
            new PatcherChain($patchers),
            $symbolsConfiguration,
        );
    }

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

        return new Configuration(
            $config->getPath(),
            $config->getPrefix(),
            array_merge(
                $config->getFilesWithContents(),
                $filesWithContents,
            ),
            $config->getWhitelistedFilesWithContents(),
            $config->getPatcher(),
            $config->getSymbolsConfiguration(),
        );
    }

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

        return new Configuration(
            $config->getPath(),
            $prefix,
            $config->getFilesWithContents(),
            $config->getWhitelistedFilesWithContents(),
            $config->getPatcher(),
            $config->getSymbolsConfiguration(),
        );
    }

    private function loadConfigFile(string $path): array
    {
        if (!$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 (!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 (!$isADirectoryLink && !is_file($path)) {
            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 (!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(
            static fn (string $key) => self::validateConfigKey($key),
            array_keys($config),
        );
    }

    private static function validateConfigKey(string $key): void
    {
        if (in_array($key, ConfigurationKeys::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[ConfigurationKeys::PREFIX_KEYWORD] ?? ''));

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

        return $prefix;
    }

    /**
     * @return array<(callable(string,string,string): string)|Patcher>

     */
    private static function retrievePatchers(array $config): array
    {
        if (!array_key_exists(ConfigurationKeys::PATCHERS_KEYWORD, $config)) {
            return [];
        }

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

        if (!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;
    }

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

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

        if (!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 (!is_string($file)) {
                throw new InvalidArgumentException(
                    sprintf(
                        'Expected whitelisted files to be an array of string, the "%d" element is not.',
                        $index,
                    ),
                );
            }

            if (!$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 (!array_key_exists(ConfigurationKeys::FINDER_KEYWORD, $config)) {
            return [];
        }

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

        if (!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 (!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 iterable<SplFileInfo|string> $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(iterable $files): array
    {
        $filesWithContents = [];

        foreach ($files as $filePathOrFileInfo) {
            $filePath = $filePathOrFileInfo instanceof SplFileInfo
                ? $filePathOrFileInfo->getRealPath()
                : realpath($filePathOrFileInfo);

            if (!$filePath) {
                throw new RuntimeException(
                    sprintf(
                        'Could not find the file "%s".',
                        (string) $filePathOrFileInfo,
                    ),
                );
            }

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

            $filesWithContents[$filePath] = [$filePath, file_get_contents($filePath)];
        }

        return $filesWithContents;
    }

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

humbug / php-scoper

Pull Request — master (#603)

ConfigurationFactory::retrieveAllInternalSymbols() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like