CommandFileDiscovery::discoverCommandFilesInLocation() - Code Metrics - Inspection of "Add some full-stack tests to ensure components wor..." - consolidation/annotated-command - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 5f8218...409b66 )

by Greg

created 2016-04-25 05:31 UTC

discoverCommandFilesInLocation() A

↳ Parent: CommandFileDiscovery

Complexity

Conditions	3
Paths	3

Size

Total Lines	21
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	21
rs	9.3142
cc	3
eloc	14
nc	3
nop	3

<?php
namespace Consolidation\AnnotatedCommand;

use Symfony\Component\Finder\Finder;

/**
 * Do discovery presuming that the namespace of the command will
 * contain the last component of the path.  This is the convention
 * that should be used when searching for command files that are
 * bundled with the modules of a framework.  The convention used
 * is that the namespace for a module in a framework should start with
 * the framework name followed by the module name.
 *
 * For example, if base namespace is "Drupal", then a command file in
 * modules/default_content/src/CliTools/ExampleCommands.cpp
 * will be in the namespace Drupal\default_content\CliTools.
 *
 * For global locations, the middle component of the namespace is
 * omitted.  For example, if the base namespace is "Drupal", then
 * a command file in __DRUPAL_ROOT__/CliTools/ExampleCommands.cpp
 * will be in the namespace Drupal\CliTools.
 *
 * To discover namespaced commands in modules:
 *
 * $commandFiles = $discovery->discoverNamespaced($moduleList, '\Drupal');
 *
 * To discover global commands:
 *
 * $commandFiles = $discovery->discover($drupalRoot, '\Drupal');
 */
class CommandFileDiscovery
{
    protected $excludeList;
    protected $searchLocations;
    protected $searchPattern = '*Commands.php';
    protected $includeFilesAtBase = true;

    public function __construct()
    {
        $this->excludeList = ['Exclude'];
        $this->searchLocations = [
            'Command',
            'CliTools', // TODO: Maybe remove
        ];
    }

    /**
     * Specify whether to search for files at the base directory
     * ($directoryList parameter to discover and discoverNamespaced
     * methods), or only in the directories listed in the search paths.
     *
     * @param type $includeFilesAtBase
     */
    public function setIncludeFilesAtBase($includeFilesAtBase)
    {
        $this->includeFilesAtBase = $includeFilesAtBase;

        return $this;
    }

    /**
     * Set the list of excludes to add to the finder, replacing
     * whatever was there before.
     *
     * @param array $excludeList The list of directory names to skip when
     *   searching for command files.
     */
    public function setExcludeList($excludeList)
    {
        $this->excludeList = $excludeList;
        return $this;
    }

    /**
     * Add one more location to the exclude list.
     *
     * @param string $exclude One directory name to skip when searching
     *   for command files.
     */
    public function addExclude($exclude)
    {
        $this->excludeList[] = $exclude;
        return $this;
    }

    /**
     * Set the list of search locations to examine in each directory where
     * command files may be found.  This replaces whatever was there before.
     *
     * @param array $searchLocations The list of locations to search for command files.
     */
    public function setSearchLocations($searchLocations)
    {
        $this->searchLocations = $searchLocations;
        return $this;
    }

    /**
     * Add one more location to the search location list.
     *
     * @param string $location One more relative path to search
     *   for command files.
     */
    public function addSearchLocation($location)
    {
        $this->searchLocations[] = $location;
        return $this;
    }

    /**
     * Specify the pattern / regex used by the finder to search for
     * command files.
     */
    public function setSearchPattern($searchPattern)
    {
        $this->searchPattern = $searchPattern;
        return $this;
    }

    /**
     * Given a list of directories, e.g. Drupal modules like:
     *
     *    core/modules/block
     *    core/modules/dblog
     *    modules/default_content
     *
     * Discover command files in any of these locations.
     *
     * @param string|string[] $directoryList Places to search for commands.
     *
     * @return array
     */
    public function discoverNamespaced($directoryList, $baseNamespace = '')
    {
        return $this->discover($this->convertToNamespacedList((array)$directoryList), $baseNamespace);
    }

    /**
     * Given a simple list containing paths to directories, where
     * the last component of the path should appear in the namespace,
     * after the base namespace, this function will return an
     * associative array mapping the path's basename (e.g. the module
     * name) to the directory path.
     *
     * Module names must be unique.
     *
     * @param string[] $directoryList A list of module locations
     *
     * @return array
     */
    public function convertToNamespacedList($directoryList)
    {
        $namespacedArray = [];
        foreach ((array)$directoryList as $directory) {
            $namespacedArray[basename($directory)] = $directory;
        }
        return $namespacedArray;
    }

    /**
     * Search for command files in the specified locations. This is the function that
     * should be used for all locations that are NOT modules of a framework.
     *
     * @param string|string[] $directoryList Places to search for commands.
     * @return array
     */
    public function discover($directoryList, $baseNamespace = '')
    {
        $commandFiles = [];
        foreach ((array)$directoryList as $key => $directory) {
            $itemsNamespace = $this->joinNamespace([$baseNamespace, $key]);
            $commandFiles = array_merge(
                $commandFiles,
                $this->discoverCommandFiles($directory, $itemsNamespace),
                $this->discoverCommandFiles("$directory/src", $itemsNamespace)
            );
        }
        return $commandFiles;
    }

    /**
     * Search for command files in specific locations within a single directory.
     *
     * In each location, we will accept only a few places where command files
     * can be found. This will reduce the need to search through many unrelated
     * files.
     *
     * The valid search locations include:
     *
     *    .
     *    CliTools
     *    src/CliTools
     *
     * The pattern we will look for is any file whose name ends in 'Commands.php'.
     * A list of paths to found files will be returned.
     */
    protected function discoverCommandFiles($directory, $baseNamespace)
    {
        $commandFiles = [];
        // In the search location itself, we will search for command files
        // immediately inside the directory only.
        if ($this->includeFilesAtBase) {
            $commandFiles = $this->discoverCommandFilesInLocation($directory, '== 0', $baseNamespace);
        }

        // In the other search locations,
        foreach ($this->searchLocations as $location) {
            $itemsNamespace = $this->joinNamespace([$baseNamespace, $location]);
            $commandFiles = array_merge(
                $commandFiles,
                $this->discoverCommandFilesInLocation("$directory/$location", '< 2', $itemsNamespace)
            );
        }
        return $commandFiles;
    }

    /**
     * Search for command files in just one particular location.  Returns
     * an associative array mapping from the pathname of the file to the
     * classname that it contains.  The pathname may be ignored if the search
     * location is included in the autoloader.
     *
     * @param string $directory The location to search
     * @param string $depth How deep to search (e.g. '== 0' or '< 2')
     * @param string $baseNamespace Namespace to prepend to each classname
     *
     * @return array
     */
    protected function discoverCommandFilesInLocation($directory, $depth, $baseNamespace)
    {
        if (!is_dir($directory)) {
            return [];
        }
        $finder = $this->createFinder($directory, $depth);

        $commands = [];
        foreach ($finder as $file) {
            $relativeNamespaceAndClassname = str_replace(
                ['/', '.php'],
                ['\\', ''],
                $file->getRelativePathname()
            );
            $classname = $this->joinNamespace([$baseNamespace, $relativeNamespaceAndClassname]);
            $commandFilePath = $this->joinPaths([$directory, $file->getRelativePathname()]);
            $commands[$commandFilePath] = $classname;
        }

        return $commands;
    }

    /**
     * Create a Finder object for use in searching a particular directory
     * location.
     *
     * @param string $directory The location to search
     * @param string $depth The depth limitation
     *
     * @return Finder
     */
    protected function createFinder($directory, $depth)
    {
        $finder = new Finder();
        $finder->files()
            ->name($this->searchPattern)
            ->in($directory)
            ->depth($depth);

        foreach ($this->excludeList as $item) {
            $finder->exclude($item);
        }

        return $finder;
    }

    /**
     * Combine the items of the provied array into a backslash-separated
     * namespace string.  Empty and numeric items are omitted.
     *
     * @param array $namespaceParts List of components of a namespace
     *
     * @return string
     */
    protected function joinNamespace(array $namespaceParts)
    {
        return $this->joinParts(
            '\\',
            $namespaceParts,
            function ($item) {
                return !is_numeric($item) && !empty($item);
            }
        );
    }

    /**
     * Combine the items of the provied array into a slash-separated
     * pathname.  Empty items are omitted.
     *
     * @param array $pathParts List of components of a path
     *
     * @return string
     */
    protected function joinPaths(array $pathParts)
    {
        return $this->joinParts(
            '/',
            $pathParts,
            function ($item) {
                return !empty($item);
            }
        );
    }

    /**
     * Simple wrapper around implode and array_filter.
     *
     * @param string $delimiter
     * @param array $parts
     * @param callable $filterFunction
     */
    protected function joinParts($delimiter, $parts, $filterFunction)
    {
        return implode(
            $delimiter,
            array_filter($parts, $filterFunction)
        );
    }
}


1			<?php
2			namespace Consolidation\AnnotatedCommand;
3
4			use Symfony\Component\Finder\Finder;
5
6			/**
7			* Do discovery presuming that the namespace of the command will
8			* contain the last component of the path. This is the convention
9			* that should be used when searching for command files that are
10			* bundled with the modules of a framework. The convention used
11			* is that the namespace for a module in a framework should start with
12			* the framework name followed by the module name.
13			*
14			* For example, if base namespace is "Drupal", then a command file in
15			* modules/default_content/src/CliTools/ExampleCommands.cpp
16			* will be in the namespace Drupal\default_content\CliTools.
17			*
18			* For global locations, the middle component of the namespace is
19			* omitted. For example, if the base namespace is "Drupal", then
20			* a command file in __DRUPAL_ROOT__/CliTools/ExampleCommands.cpp
21			* will be in the namespace Drupal\CliTools.
22			*
23			* To discover namespaced commands in modules:
24			*
25			* $commandFiles = $discovery->discoverNamespaced($moduleList, '\Drupal');
26			*
27			* To discover global commands:
28			*
29			* $commandFiles = $discovery->discover($drupalRoot, '\Drupal');
30			*/
31			class CommandFileDiscovery
32			{
33			protected $excludeList;
34			protected $searchLocations;
35			protected $searchPattern = '*Commands.php';
36			protected $includeFilesAtBase = true;
37
38			public function __construct()
39			{
40			$this->excludeList = ['Exclude'];
41			$this->searchLocations = [
42			'Command',
43			'CliTools', // TODO: Maybe remove
44			];
45			}
46
47			/**
48			* Specify whether to search for files at the base directory
49			* ($directoryList parameter to discover and discoverNamespaced
50			* methods), or only in the directories listed in the search paths.
51			*
52			* @param type $includeFilesAtBase
53			*/
54			public function setIncludeFilesAtBase($includeFilesAtBase)
55			{
56			$this->includeFilesAtBase = $includeFilesAtBase;
			0 ignored issues – show Documentation Bug introduced 2016-04-25 05:28 UTC by Report Bug Copy Issue Report It seems like `$includeFilesAtBase` of type `object<Consolidation\AnnotatedCommand\type>` is incompatible with the declared type `boolean` of property `$includeFilesAtBase`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
57			return $this;
58			}
59
60			/**
61			* Set the list of excludes to add to the finder, replacing
62			* whatever was there before.
63			*
64			* @param array $excludeList The list of directory names to skip when
65			* searching for command files.
66			*/
67			public function setExcludeList($excludeList)
68			{
69			$this->excludeList = $excludeList;
70			return $this;
71			}
72
73			/**
74			* Add one more location to the exclude list.
75			*
76			* @param string $exclude One directory name to skip when searching
77			* for command files.
78			*/
79			public function addExclude($exclude)
80			{
81			$this->excludeList[] = $exclude;
82			return $this;
83			}
84
85			/**
86			* Set the list of search locations to examine in each directory where
87			* command files may be found. This replaces whatever was there before.
88			*
89			* @param array $searchLocations The list of locations to search for command files.
90			*/
91			public function setSearchLocations($searchLocations)
92			{
93			$this->searchLocations = $searchLocations;
94			return $this;
95			}
96
97			/**
98			* Add one more location to the search location list.
99			*
100			* @param string $location One more relative path to search
101			* for command files.
102			*/
103			public function addSearchLocation($location)
104			{
105			$this->searchLocations[] = $location;
106			return $this;
107			}
108
109			/**
110			* Specify the pattern / regex used by the finder to search for
111			* command files.
112			*/
113			public function setSearchPattern($searchPattern)
114			{
115			$this->searchPattern = $searchPattern;
116			return $this;
117			}
118
119			/**
120			* Given a list of directories, e.g. Drupal modules like:
121			*
122			* core/modules/block
123			* core/modules/dblog
124			* modules/default_content
125			*
126			* Discover command files in any of these locations.
127			*
128			* @param string\|string[] $directoryList Places to search for commands.
129			*
130			* @return array
131			*/
132			public function discoverNamespaced($directoryList, $baseNamespace = '')
133			{
134			return $this->discover($this->convertToNamespacedList((array)$directoryList), $baseNamespace);
135			}
136
137			/**
138			* Given a simple list containing paths to directories, where
139			* the last component of the path should appear in the namespace,
140			* after the base namespace, this function will return an
141			* associative array mapping the path's basename (e.g. the module
142			* name) to the directory path.
143			*
144			* Module names must be unique.
145			*
146			* @param string[] $directoryList A list of module locations
147			*
148			* @return array
149			*/
150			public function convertToNamespacedList($directoryList)
151			{
152			$namespacedArray = [];
153			foreach ((array)$directoryList as $directory) {
154			$namespacedArray[basename($directory)] = $directory;
155			}
156			return $namespacedArray;
157			}
158
159			/**
160			* Search for command files in the specified locations. This is the function that
161			* should be used for all locations that are NOT modules of a framework.
162			*
163			* @param string\|string[] $directoryList Places to search for commands.
164			* @return array
165			*/
166			public function discover($directoryList, $baseNamespace = '')
167			{
168			$commandFiles = [];
169			foreach ((array)$directoryList as $key => $directory) {
170			$itemsNamespace = $this->joinNamespace([$baseNamespace, $key]);
171			$commandFiles = array_merge(
172			$commandFiles,
173			$this->discoverCommandFiles($directory, $itemsNamespace),
174			$this->discoverCommandFiles("$directory/src", $itemsNamespace)
175			);
176			}
177			return $commandFiles;
178			}
179
180			/**
181			* Search for command files in specific locations within a single directory.
182			*
183			* In each location, we will accept only a few places where command files
184			* can be found. This will reduce the need to search through many unrelated
185			* files.
186			*
187			* The valid search locations include:
188			*
189			* .
190			* CliTools
191			* src/CliTools
192			*
193			* The pattern we will look for is any file whose name ends in 'Commands.php'.
194			* A list of paths to found files will be returned.
195			*/
196			protected function discoverCommandFiles($directory, $baseNamespace)
197			{
198			$commandFiles = [];
199			// In the search location itself, we will search for command files
200			// immediately inside the directory only.
201			if ($this->includeFilesAtBase) {
202			$commandFiles = $this->discoverCommandFilesInLocation($directory, '== 0', $baseNamespace);
203			}
204
205			// In the other search locations,
206			foreach ($this->searchLocations as $location) {
207			$itemsNamespace = $this->joinNamespace([$baseNamespace, $location]);
208			$commandFiles = array_merge(
209			$commandFiles,
210			$this->discoverCommandFilesInLocation("$directory/$location", '< 2', $itemsNamespace)
211			);
212			}
213			return $commandFiles;
214			}
215
216			/**
217			* Search for command files in just one particular location. Returns
218			* an associative array mapping from the pathname of the file to the
219			* classname that it contains. The pathname may be ignored if the search
220			* location is included in the autoloader.
221			*
222			* @param string $directory The location to search
223			* @param string $depth How deep to search (e.g. '== 0' or '< 2')
224			* @param string $baseNamespace Namespace to prepend to each classname
225			*
226			* @return array
227			*/
228			protected function discoverCommandFilesInLocation($directory, $depth, $baseNamespace)
229			{
230			if (!is_dir($directory)) {
231			return [];
232			}
233			$finder = $this->createFinder($directory, $depth);
234
235			$commands = [];
236			foreach ($finder as $file) {
237			$relativeNamespaceAndClassname = str_replace(
238			['/', '.php'],
239			['\\', ''],
240			$file->getRelativePathname()
241			);
242			$classname = $this->joinNamespace([$baseNamespace, $relativeNamespaceAndClassname]);
243			$commandFilePath = $this->joinPaths([$directory, $file->getRelativePathname()]);
244			$commands[$commandFilePath] = $classname;
245			}
246
247			return $commands;
248			}
249
250			/**
251			* Create a Finder object for use in searching a particular directory
252			* location.
253			*
254			* @param string $directory The location to search
255			* @param string $depth The depth limitation
256			*
257			* @return Finder
258			*/
259			protected function createFinder($directory, $depth)
260			{
261			$finder = new Finder();
262			$finder->files()
263			->name($this->searchPattern)
264			->in($directory)
265			->depth($depth);
266
267			foreach ($this->excludeList as $item) {
268			$finder->exclude($item);
269			}
270
271			return $finder;
272			}
273
274			/**
275			* Combine the items of the provied array into a backslash-separated
276			* namespace string. Empty and numeric items are omitted.
277			*
278			* @param array $namespaceParts List of components of a namespace
279			*
280			* @return string
281			*/
282			protected function joinNamespace(array $namespaceParts)
283			{
284			return $this->joinParts(
285			'\\',
286			$namespaceParts,
287			function ($item) {
288			return !is_numeric($item) && !empty($item);
289			}
290			);
291			}
292
293			/**
294			* Combine the items of the provied array into a slash-separated
295			* pathname. Empty items are omitted.
296			*
297			* @param array $pathParts List of components of a path
298			*
299			* @return string
300			*/
301			protected function joinPaths(array $pathParts)
302			{
303			return $this->joinParts(
304			'/',
305			$pathParts,
306			function ($item) {
307			return !empty($item);
308			}
309			);
310			}
311
312			/**
313			* Simple wrapper around implode and array_filter.
314			*
315			* @param string $delimiter
316			* @param array $parts
317			* @param callable $filterFunction
318			*/
319			protected function joinParts($delimiter, $parts, $filterFunction)
320			{
321			return implode(
322			$delimiter,
323			array_filter($parts, $filterFunction)
324			);
325			}
326			}
327

consolidation / annotated-command

Push — master ( 5f8218...409b66 )

discoverCommandFilesInLocation() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like