SourceFileIteratorFactory.php$0 ➔ preparePattern() - Code Metrics - Inspection of "Fix: Windows path seperators break some regexes" - mediact/dependency-guard - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#31)

by Björn

created 2018-11-24 12:06 UTC

SourceFileIteratorFactory.php$0 ➔ preparePattern() A

↳ Parent: SourceFileIteratorFactory

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	13
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	18
ccs	13
cts	13
cp	1
c	0
b	0
f	0
cc	2
crap	2
rs	9.6666

<?php
/**
 * Copyright MediaCT. All rights reserved.
 * https://www.mediact.nl
 */

namespace Mediact\DependencyGuard\Composer\Iterator;

use AppendIterator;
use ArrayIterator;
use Composer\Composer;
use FilterIterator;
use Iterator;
use Mediact\DependencyGuard\Iterator\FileIterator;
use Mediact\DependencyGuard\Iterator\FileIteratorFactoryInterface;
use Mediact\DependencyGuard\Iterator\FileIteratorInterface;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use SplFileInfo;

class SourceFileIteratorFactory implements FileIteratorFactoryInterface
{
    /**
     * Get an iterable list of source files for the root package of the given
     * Composer instance.
     *
     * @param Composer $composer
     *
     * @return FileIteratorInterface
     */
    public function create(Composer $composer): FileIteratorInterface
    {
        $config              = $composer->getConfig();
        $autoloadGenerator   = $composer->getAutoloadGenerator();
        $installationManager = $composer->getInstallationManager();
        $package             = $composer->getPackage();

        $autoloadGenerator->setClassMapAuthoritative(
            $config->get('classmap-authoritative')
        );
        $autoloadGenerator->setDevMode(false);

        $packageMap = $autoloadGenerator->buildPackageMap(
            $installationManager,
            $package,
            [$package]
        );

        $directives = $autoloadGenerator->parseAutoloads($packageMap, $package);

        $files = new AppendIterator();

        $files->append(
            $this->createClassmapIterator(
                $directives['classmap'] ?? [],
                $directives['exclude-from-classmap'] ?? []
            )
        );
        $files->append(
            $this->createFilesIterator(
                ...array_values($directives['files'] ?? [])
            )
        );
        $files->append(
            $this->createNamespaceIterator($directives['psr-0'] ?? [])
        );
        $files->append(
            $this->createNamespaceIterator($directives['psr-4'] ?? [])
        );

        return new FileIterator($files);
    }

    /**
     * Create an iterator for the given file paths.
     *
     * @param string ...$paths
     *
     * @return Iterator
     */
    private function createFilesIterator(string ...$paths): Iterator
    {
        return new ArrayIterator(
            array_map(
                function (string $path) : SplFileInfo {
                    return new SplFileInfo($path);
                },
                array_filter(
                    $paths,
                    function (string $path) : bool {
                        return is_readable($path);
                    }
                )
            )
        );
    }

    /**
     * Create an iterator for the given namespaces.
     *
     * @param array $namespaces
     *
     * @return Iterator
     */
    private function createNamespaceIterator(array $namespaces): Iterator
    {
        $files = new AppendIterator();

        foreach ($namespaces as $classmap) {
            $files->append(
                $this->createClassmapIterator($classmap)
            );
        }

        return $files;
    }

    /**
     * Create a class map iterator using the given class maps and exclude patterns.
     *
     * @param iterable|string[] $classmap
     * @param iterable|string[] $exclude
     *
     * @return Iterator|SplFileInfo[]
     */
    private function createClassmapIterator(
        iterable $classmap,
        iterable $exclude = []
    ): Iterator {
        $files = new AppendIterator();

        foreach ($classmap as $directory) {
            if (!is_dir($directory)) {
                continue;
            }

            $files->append(
                new RecursiveIteratorIterator(
                    new RecursiveDirectoryIterator($directory)
                )
            );
        }

        return new class ($files, $this->preparePattern(...$exclude)) extends FilterIterator {
            /** @var string|null */
            private $excludePattern;

            /**
             * Constructor.
             *
             * @param Iterator    $iterator
             * @param string|null $excludePattern
             */
            public function __construct(
                Iterator $iterator,
                ?string $excludePattern
            ) {
                $this->excludePattern = $excludePattern;

                parent::__construct($iterator);
            }

            /**
             * Check whether the current element of the iterator is acceptable.
             *
             * @return bool
             */
            public function accept(): bool
            {
                /** @var SplFileInfo $file */
                $file = $this->getInnerIterator()->current();

                return (
                    $file->isFile()
                    && (
                        $this->excludePattern === null
                        ?: !preg_match(
                            $this->excludePattern,
                            str_replace('\\', '/', $file->getRealPath())
                        )
                    )
                );
            }
        };
    }

    /**
     * @param string ...$excludePatterns
     *
     * @return string|null
     */
    private function preparePattern(string ...$excludePatterns): ?string
    {
        if (count($excludePatterns) === 0) {
            return null;
        }

        return sprintf(
            '@^(%s)$@',
            implode(
                '|',
                array_map(
                    function (string $pattern): string {
                        return preg_quote(
                            str_replace('\\', '/', $pattern),
                            '@'
                        );
                    },
                    $excludePatterns
                )
            )
        );
    }
}


1		<?php
2		/**
3		* Copyright MediaCT. All rights reserved.
4		* https://www.mediact.nl
5		*/
6
7		namespace Mediact\DependencyGuard\Composer\Iterator;
8
9		use AppendIterator;
10		use ArrayIterator;
11		use Composer\Composer;
12		use FilterIterator;
13		use Iterator;
14		use Mediact\DependencyGuard\Iterator\FileIterator;
15		use Mediact\DependencyGuard\Iterator\FileIteratorFactoryInterface;
16		use Mediact\DependencyGuard\Iterator\FileIteratorInterface;
17		use RecursiveDirectoryIterator;
18		use RecursiveIteratorIterator;
19		use SplFileInfo;
20
21		class SourceFileIteratorFactory implements FileIteratorFactoryInterface
22		{
23		/**
24		* Get an iterable list of source files for the root package of the given
25		* Composer instance.
26		*
27		* @param Composer $composer
28		*
29		* @return FileIteratorInterface
30		*/
31	9	public function create(Composer $composer): FileIteratorInterface
32		{
33	9	$config = $composer->getConfig();
34	9	$autoloadGenerator = $composer->getAutoloadGenerator();
35	9	$installationManager = $composer->getInstallationManager();
36	9	$package = $composer->getPackage();
37
38	9	$autoloadGenerator->setClassMapAuthoritative(
39	9	$config->get('classmap-authoritative')
40		);
41	9	$autoloadGenerator->setDevMode(false);
42
43	9	$packageMap = $autoloadGenerator->buildPackageMap(
44	9	$installationManager,
45	9	$package,
46	9	[$package]
47		);
48
49	9	$directives = $autoloadGenerator->parseAutoloads($packageMap, $package);
50
51	9	$files = new AppendIterator();
52
53	9	$files->append(
54	9	$this->createClassmapIterator(
55	9	$directives['classmap'] ?? [],
56	9	$directives['exclude-from-classmap'] ?? []
57		)
58		);
59	9	$files->append(
60	9	$this->createFilesIterator(
61	9	...array_values($directives['files'] ?? [])
62		)
63		);
64	9	$files->append(
65	9	$this->createNamespaceIterator($directives['psr-0'] ?? [])
66		);
67	9	$files->append(
68	9	$this->createNamespaceIterator($directives['psr-4'] ?? [])
69		);
70
71	9	return new FileIterator($files);
72		}
73
74		/**
75		* Create an iterator for the given file paths.
76		*
77		* @param string ...$paths
78		*
79		* @return Iterator
80		*/
81	9	private function createFilesIterator(string ...$paths): Iterator
82		{
83	9	return new ArrayIterator(
84	9	array_map(
85		function (string $path) : SplFileInfo {
86	1	return new SplFileInfo($path);
87	9	},
88	9	array_filter(
89	9	$paths,
90		function (string $path) : bool {
91	1	return is_readable($path);
92	9	}
93		)
94		)
95		);
96		}
97
98		/**
99		* Create an iterator for the given namespaces.
100		*
101		* @param array $namespaces
102		*
103		* @return Iterator
104		*/
105	9	private function createNamespaceIterator(array $namespaces): Iterator
106		{
107	9	$files = new AppendIterator();
108
109	9	foreach ($namespaces as $classmap) {
110	2	$files->append(
111	2	$this->createClassmapIterator($classmap)
112		);
113		}
114
115	9	return $files;
116		}
117
118		/**
119		* Create a class map iterator using the given class maps and exclude patterns.
120		*
121		* @param iterable\|string[] $classmap
122		* @param iterable\|string[] $exclude
123		*
124		* @return Iterator\|SplFileInfo[]
125		*/
126	9	private function createClassmapIterator(
127		iterable $classmap,
128		iterable $exclude = []
129		): Iterator {
130	9	$files = new AppendIterator();
131
132	9	foreach ($classmap as $directory) {
133	5	if (!is_dir($directory)) {
134	1	continue;
135		}
136
137	5	$files->append(
138	5	new RecursiveIteratorIterator(
139	5	new RecursiveDirectoryIterator($directory)
140		)
141		);
142		}
143
144		return new class ($files, $this->preparePattern(...$exclude)) extends FilterIterator {
145		/** @var string\|null */
146		private $excludePattern;
147
148		/**
149		* Constructor.
150		*
151		* @param Iterator $iterator
152		* @param string\|null $excludePattern
153		*/
154	9	public function __construct(
155		Iterator $iterator,
156		?string $excludePattern
157		) {
158	9	$this->excludePattern = $excludePattern;
159
160	9	parent::__construct($iterator);
161	9	}
162
163		/**
164		* Check whether the current element of the iterator is acceptable.
165		*
166		* @return bool
167		*/
168	5	public function accept(): bool
169		{
170		/** @var SplFileInfo $file */
171	5	$file = $this->getInnerIterator()->current();
172
173		return (
174	5	$file->isFile()
175		&& (
176	5	$this->excludePattern === null
177	1	?: !preg_match(
178	1	$this->excludePattern,
179	5	str_replace('\\', '/', $file->getRealPath())
180		)
181		)
182		);
183		}
184		};
185		}
186
187		/**
188		* @param string ...$excludePatterns
189		*
190		* @return string\|null
191		*/
192	9	private function preparePattern(string ...$excludePatterns): ?string
193		{
194	9	if (count($excludePatterns) === 0) {
195	8	return null;
196		}
197
198	1	return sprintf(
199	1	'@^(%s)$@',
200	1	implode(
201	1	'\|',
202	1	array_map(
203		function (string $pattern): string {
204	1	return preg_quote(
205	1	str_replace('\\', '/', $pattern),
206	1	'@'
207		);
208	1	},
209	1	$excludePatterns
210		)
211		)
212		);
213		}
214		}
215

mediact / dependency-guard

Pull Request — master (#31)

SourceFileIteratorFactory.php$0 ➔ preparePattern() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like