DirectoryExplorer::getIgnoredPaths() - Code Metrics - SierraTecnologia/Finder - Measure and Improve Code Quality continuously with Scrutinizer

DirectoryExplorer::getIgnoredPaths() A
last analyzed 2021-05-27 22:55 UTC

↳ Parent: DirectoryExplorer

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
nc	1
nop	0
dl	0
loc	6
rs	10
c	0
b	0
f	0

<?php
namespace Finder\Console\External\Explorer;

use League\CLImate\CLImate;
use Finder\Logic\Output\AbstractOutput;
use Finder\Logic\Output\Filter\DiffOutputFilter;
use ReflectionMethod;
use SebastianBergmann\Diff\Parser;
use SebastianBergmann\Git\Git;
use UnexpectedValueException;
use Finder\Spider\SpiderLinuxCommand;

/**
 * Command line tool that run all script analyzers.
 */
class DirectoryExplorer
{
    /**
     * CLI tool.
     *
     * @var CLImate CLImate instance.
     */
    protected $cli;

    /**
     * Analyser.
     *
     * @var SpiderLinuxCommand analyser instance.
     */
    protected $analyser;

    /**
     * Command line arguments.
     *
     * @var array list of arguments.
     */
    protected $arguments;

    /**
     * Analysis targets paths.
     *
     * @var array list of files and directories paths.
     */
    protected $analysedPaths;

    /**
     * Composer binaries directory path.
     *
     * @var string directory path.
     */
    protected $binariesPath;

    /**
     * Set dependencies and initialize CLI.
     *
     * @param CLImate $climate      CLImate instance.
     * @param string  $binariesPath Composer binaries path.
     * @param array   $arguments    command line arguments.
     */
    public function __construct(CLImate $climate, $binariesPath, array $arguments)

    {
        $this->cli = $climate;
        $this->cli->description($this->getDescription());
        $this->cli->arguments->add($this->getArguments());
        $this->cli->arguments->parse($arguments);

        $this->arguments = $arguments;
        $this->binariesPath = $binariesPath;
        $this->setAnalysedPathsFromString($this->getArgumentValue('path'));
    }

    /**
     * Run Code-Analyser command.
     *
     * @return boolean true if it didn't find code issues or ran successfully.
     */
    public function run()

    {
        if ($this->hasArgumentValue('help')) {
            $this->cli->usage();
            return true;
        }

        if ($this->hasArgumentValue('version')) {
            $this->cli->out($this->getDescription());
            return true;
        }

        if ($this->hasArgumentValue('git-diff')) {
            $gitDiff = $this->getArgumentValue('git-diff');
            $filter = $this->getGitDiffFilter($gitDiff);
            $analysedFiles = $filter->getFilesWithAddedCode();
            $this->setAnalysedPaths($analysedFiles);
            $this->getAnalyser()->setResultsFilter($filter);
            $this->getAnalyser()->setAnalysedPaths($analysedFiles);
        }

        return $this->getAnalyser()->run();
    }

    /**
     * Create a DiffOutputFilter based on a git-diff param.
     *
     * @param  string $gitDiff git diff arguments.
     * @return DiffOutputFilter filter instance.
     */
    protected function getGitDiffFilter($gitDiff)

    {
        $analysedPaths = $this->getAnalysedPaths();
        $gitPath = array_shift($analysedPaths);
        if (!is_dir($gitPath)) {
            $gitPath = dirname($gitPath);
        }
        $git = new Git($gitPath);
        $executeMethod = new ReflectionMethod($git, 'execute');
        $executeMethod->setAccessible(true);
        $gitRoot = trim(implode("\n", $executeMethod->invoke($git, 'git rev-parse --show-toplevel')));
        list($base, $changed) = explode('..', $gitDiff);
        $diff = $git->getDiff($base, $changed);
        $diffParser = new Parser;
        return new DiffOutputFilter($gitRoot, $diffParser->parse($diff));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Initialize output.
     *
     * @throws UnexpectedValueException on invalid format value.
     * @return AbstractOutput
     */
    protected function getOutput()

    {
        $format = $this->getOutputFormat();
        $formatClasses = $this->getOutputFormatClasses();

        if (!isset($formatClasses[$format])) {
            throw new UnexpectedValueException(
                'Invalid format: "' . $format . '"'
            );
        }

        $outputClassName = $formatClasses[$format];

        return new $outputClassName(
            $this->cli,
            $this->getWorkingDirectory()
        );
    }

    /**
     * Command line arguments list for CLImate.
     *
     * @return array CLI list of arguments.
     */
    protected function getArguments()

    {
        return [
            'help' => [
                'prefix' => 'h',
                'longPrefix' => 'help',
                'description' => 'Prints a usage statement',
                'noValue' => true,
            ],
            'version' => [
                'prefix' => 'v',
                'longPrefix' => 'version',
                'description' => 'Prints installed version',
                'noValue' => true,
            ],
            'ignore' => [
                'prefix' => 'i',
                'longPrefix' => 'ignore',
                'description' => 'Ignore a comma-separated list of directories',
                'castTo' => 'string',
                'defaultValue' => 'vendor,tests,features,spec',
            ],
            'format' => [
                'prefix' => 'f',
                'longPrefix' => 'format',
                'description' => 'Output format',
                'castTo' => 'string',
                'defaultValue' => 'text',
            ],
            'git-diff' => [
                'prefix' => 'g',
                'longPrefix' => 'git-diff',
                'description' => 'Limit to files and lines changed between two '
                                . 'commits or branches, e.g., "master..other".',
                'castTo' => 'string',
            ],
            'path' => [
                'description' => 'File or directory path to analyze',
                'defaultValue' => '.',
            ],
        ];
    }

    /**
     * Get a list of paths to be ignored by the analysis.
     *
     * @return string[] a list of file and/or directory paths.
     */
    public function getIgnoredPaths()
    {
        $ignoredArgument = $this->getArgumentValue('ignore');
        $ignoredPaths = explode(',', $ignoredArgument);
        return array_filter($ignoredPaths);
    }

    /**
     * Parse a string of comma separated files and/or directories to be analysed.
     *
     * @param  string $pathsString the path argument value.
     * @return void
     */
    protected function setAnalysedPathsFromString($pathsString)
    {
        $rawAnalysedPaths = explode(',', $pathsString);
        $analysedPaths = array_filter($rawAnalysedPaths);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $this->setAnalysedPaths(array_filter($rawAnalysedPaths));
    }

    /**
     * Set target files and/or directories to be analysed. Fix relative paths.
     *
     * @param  string[] $paths target paths.
     * @return void
     */
    protected function setAnalysedPaths(array $paths)

    {
        foreach ($paths as &$path) {
            if (0 === strpos($path, DIRECTORY_SEPARATOR)) {
                continue;
            }
            $path = $this->getWorkingDirectory() . DIRECTORY_SEPARATOR . $path;
        }
        $this->analysedPaths = $paths;
    }

    /**
     * Analysis target paths.
     *
     * @return string[] a list of analysed paths (usually just one).
     */
    public function getAnalysedPaths()
    {
        return $this->analysedPaths;
    }

    /**
     * Running script path.
     *
     * @return string current script directory.
     */
    public function getWorkingDirectory()
    {
        return getcwd();
    }

    /**
     * Output format.
     *
     * @return string format type.
     */
    public function getOutputFormat()
    {
        return $this->getArgumentValue('format');
    }

    /**
     * CLI output description.
     *
     * @return string description.
     */
    public function getDescription()
    {
        return 'BOSS SPIDER ' . SpiderLinuxCommand::VERSION;
    }

    /**
     * SpiderLinuxCommand instance.
     *
     * @return SpiderLinuxCommand instance.
     */
    public function getAnalyser()
    {
        $paths = $this->getAnalysedPaths();
        // $pipeline = \Finder\Pipelines\Finder\Directory::pipeline();
        foreach ($paths as $path) {
            $spider = new \Finder\Spider\Directory($path);
            dd('GetAnaliser',$spider->run());
            // $spider = new \Finder\Pipelines\Finder\Directory($path);
            // $pipeline->process(
            //     \Fabrica\Entities\DirectoryEntity::make($path)
            // );
        }
        
        if (null === $this->analyser) {

            $this->analyser = new SpiderLinuxCommand(
                $this->getOutput(),
                $this->binariesPath,
                $this->getAnalysedPaths(),
                $this->getIgnoredPaths()
            );
        }
        return $this->analyser;
    }

    /**
     * List of output format classes.
     *
     * @return array array where the key is a format and its value the class.
     */
    protected function getOutputFormatClasses()

    {
        return [
            'text' => 'Finder\Logic\Output\TextOutput',
            'json' => 'Finder\Logic\Output\JsonOutput',
            'xml' => 'Finder\Logic\Output\XmlOutput',
            'csv' => 'Finder\Logic\Output\CsvOutput',
            'html' => 'Finder\Logic\Output\HtmlOutput',
        ];
    }

    /**
     * Get argument value from user informed arguments.
     *
     * @param  string $name argument name.
     * @return Mixed argument value.
     */
    protected function getArgumentValue($name)
    {
        return $this->cli->arguments->get($name);
    }

    /**
     * Check if the user supplied an argument.
     *
     * @param  string $name argument name.
     * @return boolean if the argument has informed or not.
     */
    protected function hasArgumentValue($name)
    {
        return $this->cli->arguments->defined($name, $this->arguments);
    }
}


1		<?php
2		namespace Finder\Console\External\Explorer;
3
4		use League\CLImate\CLImate;
5		use Finder\Logic\Output\AbstractOutput;
6		use Finder\Logic\Output\Filter\DiffOutputFilter;
7		use ReflectionMethod;
8		use SebastianBergmann\Diff\Parser;
9		use SebastianBergmann\Git\Git;
10		use UnexpectedValueException;
11		use Finder\Spider\SpiderLinuxCommand;
12
13		/**
14		* Command line tool that run all script analyzers.
15		*/
16		class DirectoryExplorer
17		{
18		/**
19		* CLI tool.
20		*
21		* @var CLImate CLImate instance.
22		*/
23		protected $cli;
24
25		/**
26		* Analyser.
27		*
28		* @var SpiderLinuxCommand analyser instance.
29		*/
30		protected $analyser;
31
32		/**
33		* Command line arguments.
34		*
35		* @var array list of arguments.
36		*/
37		protected $arguments;
38
39		/**
40		* Analysis targets paths.
41		*
42		* @var array list of files and directories paths.
43		*/
44		protected $analysedPaths;
45
46		/**
47		* Composer binaries directory path.
48		*
49		* @var string directory path.
50		*/
51		protected $binariesPath;
52
53		/**
54		* Set dependencies and initialize CLI.
55		*
56		* @param CLImate $climate CLImate instance.
57		* @param string $binariesPath Composer binaries path.
58		* @param array $arguments command line arguments.
59		*/
60	View Code Duplication	public function __construct(CLImate $climate, $binariesPath, array $arguments)
		0 ignored issues – show Duplication introduced 2020-07-23 06:23 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
61		{
62		$this->cli = $climate;
63		$this->cli->description($this->getDescription());
64		$this->cli->arguments->add($this->getArguments());
65		$this->cli->arguments->parse($arguments);
66
67		$this->arguments = $arguments;
68		$this->binariesPath = $binariesPath;
69		$this->setAnalysedPathsFromString($this->getArgumentValue('path'));
70		}
71
72		/**
73		* Run Code-Analyser command.
74		*
75		* @return boolean true if it didn't find code issues or ran successfully.
76		*/
77	View Code Duplication	public function run()
		0 ignored issues – show Duplication introduced 2020-07-23 06:23 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
78		{
79		if ($this->hasArgumentValue('help')) {
80		$this->cli->usage();
81		return true;
82		}
83
84		if ($this->hasArgumentValue('version')) {
85		$this->cli->out($this->getDescription());
86		return true;
87		}
88
89		if ($this->hasArgumentValue('git-diff')) {
90		$gitDiff = $this->getArgumentValue('git-diff');
91		$filter = $this->getGitDiffFilter($gitDiff);
92		$analysedFiles = $filter->getFilesWithAddedCode();
93		$this->setAnalysedPaths($analysedFiles);
94		$this->getAnalyser()->setResultsFilter($filter);
95		$this->getAnalyser()->setAnalysedPaths($analysedFiles);
96		}
97
98		return $this->getAnalyser()->run();
99		}
100
101		/**
102		* Create a DiffOutputFilter based on a git-diff param.
103		*
104		* @param string $gitDiff git diff arguments.
105		* @return DiffOutputFilter filter instance.
106		*/
107	View Code Duplication	protected function getGitDiffFilter($gitDiff)
		0 ignored issues – show Duplication introduced 2020-07-23 06:23 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
108		{
109		$analysedPaths = $this->getAnalysedPaths();
110		$gitPath = array_shift($analysedPaths);
111		if (!is_dir($gitPath)) {
112		$gitPath = dirname($gitPath);
113		}
114		$git = new Git($gitPath);
115		$executeMethod = new ReflectionMethod($git, 'execute');
116		$executeMethod->setAccessible(true);
117		$gitRoot = trim(implode("\n", $executeMethod->invoke($git, 'git rev-parse --show-toplevel')));
118		list($base, $changed) = explode('..', $gitDiff);
119		$diff = $git->getDiff($base, $changed);
120		$diffParser = new Parser;
121		return new DiffOutputFilter($gitRoot, $diffParser->parse($diff));
		0 ignored issues – show Documentation introduced 2020-07-23 06:23 UTC by Report Bug Copy Issue Report `$diffParser->parse($diff)` is of type `array<integer,object<Seb...ianBergmann\Diff\Diff>>`, but the function expects a `array<integer,object<Fin...ianBergmann\Diff\Diff>>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
122		}
123
124		/**
125		* Initialize output.
126		*
127		* @throws UnexpectedValueException on invalid format value.
128		* @return AbstractOutput
129		*/
130	View Code Duplication	protected function getOutput()
		0 ignored issues – show Duplication introduced 2020-07-23 06:23 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
131		{
132		$format = $this->getOutputFormat();
133		$formatClasses = $this->getOutputFormatClasses();
134
135		if (!isset($formatClasses[$format])) {
136		throw new UnexpectedValueException(
137		'Invalid format: "' . $format . '"'
138		);
139		}
140
141		$outputClassName = $formatClasses[$format];
142
143		return new $outputClassName(
144		$this->cli,
145		$this->getWorkingDirectory()
146		);
147		}
148
149		/**
150		* Command line arguments list for CLImate.
151		*
152		* @return array CLI list of arguments.
153		*/
154	View Code Duplication	protected function getArguments()
		0 ignored issues – show Duplication introduced 2020-07-23 06:23 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
155		{
156		return [
157		'help' => [
158		'prefix' => 'h',
159		'longPrefix' => 'help',
160		'description' => 'Prints a usage statement',
161		'noValue' => true,
162		],
163		'version' => [
164		'prefix' => 'v',
165		'longPrefix' => 'version',
166		'description' => 'Prints installed version',
167		'noValue' => true,
168		],
169		'ignore' => [
170		'prefix' => 'i',
171		'longPrefix' => 'ignore',
172		'description' => 'Ignore a comma-separated list of directories',
173		'castTo' => 'string',
174		'defaultValue' => 'vendor,tests,features,spec',
175		],
176		'format' => [
177		'prefix' => 'f',
178		'longPrefix' => 'format',
179		'description' => 'Output format',
180		'castTo' => 'string',
181		'defaultValue' => 'text',
182		],
183		'git-diff' => [
184		'prefix' => 'g',
185		'longPrefix' => 'git-diff',
186		'description' => 'Limit to files and lines changed between two '
187		. 'commits or branches, e.g., "master..other".',
188		'castTo' => 'string',
189		],
190		'path' => [
191		'description' => 'File or directory path to analyze',
192		'defaultValue' => '.',
193		],
194		];
195		}
196
197		/**
198		* Get a list of paths to be ignored by the analysis.
199		*
200		* @return string[] a list of file and/or directory paths.
201		*/
202		public function getIgnoredPaths()
203		{
204		$ignoredArgument = $this->getArgumentValue('ignore');
205		$ignoredPaths = explode(',', $ignoredArgument);
206		return array_filter($ignoredPaths);
207		}
208
209		/**
210		* Parse a string of comma separated files and/or directories to be analysed.
211		*
212		* @param string $pathsString the path argument value.
213		* @return void
214		*/
215		protected function setAnalysedPathsFromString($pathsString)
216		{
217		$rawAnalysedPaths = explode(',', $pathsString);
218		$analysedPaths = array_filter($rawAnalysedPaths);
		0 ignored issues – show Unused Code introduced 2020-07-23 06:23 UTC by Report Bug Copy Issue Report `$analysedPaths` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
219		$this->setAnalysedPaths(array_filter($rawAnalysedPaths));
220		}
221
222		/**
223		* Set target files and/or directories to be analysed. Fix relative paths.
224		*
225		* @param string[] $paths target paths.
226		* @return void
227		*/
228	View Code Duplication	protected function setAnalysedPaths(array $paths)
		0 ignored issues – show Duplication introduced 2020-07-23 06:23 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
229		{
230		foreach ($paths as &$path) {
231		if (0 === strpos($path, DIRECTORY_SEPARATOR)) {
232		continue;
233		}
234		$path = $this->getWorkingDirectory() . DIRECTORY_SEPARATOR . $path;
235		}
236		$this->analysedPaths = $paths;
237		}
238
239		/**
240		* Analysis target paths.
241		*
242		* @return string[] a list of analysed paths (usually just one).
243		*/
244		public function getAnalysedPaths()
245		{
246		return $this->analysedPaths;
247		}
248
249		/**
250		* Running script path.
251		*
252		* @return string current script directory.
253		*/
254		public function getWorkingDirectory()
255		{
256		return getcwd();
257		}
258
259		/**
260		* Output format.
261		*
262		* @return string format type.
263		*/
264		public function getOutputFormat()
265		{
266		return $this->getArgumentValue('format');
267		}
268
269		/**
270		* CLI output description.
271		*
272		* @return string description.
273		*/
274		public function getDescription()
275		{
276		return 'BOSS SPIDER ' . SpiderLinuxCommand::VERSION;
277		}
278
279		/**
280		* SpiderLinuxCommand instance.
281		*
282		* @return SpiderLinuxCommand instance.
283		*/
284		public function getAnalyser()
285		{
286		$paths = $this->getAnalysedPaths();
287		// $pipeline = \Finder\Pipelines\Finder\Directory::pipeline();
288		foreach ($paths as $path) {
289		$spider = new \Finder\Spider\Directory($path);
290		dd('GetAnaliser',$spider->run());
291		// $spider = new \Finder\Pipelines\Finder\Directory($path);
292		// $pipeline->process(
293		// \Fabrica\Entities\DirectoryEntity::make($path)
294		// );
295		}
296
297	View Code Duplication	if (null === $this->analyser) {
		0 ignored issues – show Duplication introduced 2020-07-23 06:23 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
298		$this->analyser = new SpiderLinuxCommand(
299		$this->getOutput(),
300		$this->binariesPath,
301		$this->getAnalysedPaths(),
302		$this->getIgnoredPaths()
303		);
304		}
305		return $this->analyser;
306		}
307
308		/**
309		* List of output format classes.
310		*
311		* @return array array where the key is a format and its value the class.
312		*/
313	View Code Duplication	protected function getOutputFormatClasses()
		0 ignored issues – show Duplication introduced 2021-05-27 22:55 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
314		{
315		return [
316		'text' => 'Finder\Logic\Output\TextOutput',
317		'json' => 'Finder\Logic\Output\JsonOutput',
318		'xml' => 'Finder\Logic\Output\XmlOutput',
319		'csv' => 'Finder\Logic\Output\CsvOutput',
320		'html' => 'Finder\Logic\Output\HtmlOutput',
321		];
322		}
323
324		/**
325		* Get argument value from user informed arguments.
326		*
327		* @param string $name argument name.
328		* @return Mixed argument value.
329		*/
330		protected function getArgumentValue($name)
331		{
332		return $this->cli->arguments->get($name);
333		}
334
335		/**
336		* Check if the user supplied an argument.
337		*
338		* @param string $name argument name.
339		* @return boolean if the argument has informed or not.
340		*/
341		protected function hasArgumentValue($name)
342		{
343		return $this->cli->arguments->defined($name, $this->arguments);
344		}
345		}
346

SierraTecnologia / Finder

DirectoryExplorer::getIgnoredPaths() A last analyzed 2021-05-27 22:55 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

DirectoryExplorer::getIgnoredPaths() A
last analyzed 2021-05-27 22:55 UTC