Command::hasArgumentValue() - Code Metrics - alanwillms/php-hound - Measure and Improve Code Quality continuously with Scrutinizer

Command::hasArgumentValue() A
last analyzed 2016-10-25 18:40 UTC

↳ Parent: Command

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1

<?php
namespace phphound;

use League\CLImate\CLImate;
use phphound\output\AbstractOutput;
use phphound\output\filter\DiffOutputFilter;
use ReflectionMethod;
use SebastianBergmann\Diff\Parser;
use SebastianBergmann\Git\Git;
use UnexpectedValueException;

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

    /**
     * Analyser.
     * @var Analyser 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 PHP-Hound 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 'PHP Hound ' . Analyser::VERSION;
    }

    /**
     * Analyser instance.
     * @return Analyser instance.
     */
    public function getAnalyser()
    {
        if (null === $this->analyser) {
            $this->analyser = new Analyser(
                $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' => 'phphound\output\TextOutput',
            'json' => 'phphound\output\JsonOutput',
            'xml' => 'phphound\output\XmlOutput',
            'csv' => 'phphound\output\CsvOutput',
            'html' => 'phphound\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 phphound;
3
4			use League\CLImate\CLImate;
5			use phphound\output\AbstractOutput;
6			use phphound\output\filter\DiffOutputFilter;
7			use ReflectionMethod;
8			use SebastianBergmann\Diff\Parser;
9			use SebastianBergmann\Git\Git;
10			use UnexpectedValueException;
11
12			/**
13			* Command line tool that run all script analyzers.
14			*/
15			class Command
16			{
17			/**
18			* CLI tool.
19			* @var CLImate CLImate instance.
20			*/
21			protected $cli;
22
23			/**
24			* Analyser.
25			* @var Analyser analyser instance.
26			*/
27			protected $analyser;
28
29			/**
30			* Command line arguments.
31			* @var array list of arguments.
32			*/
33			protected $arguments;
34
35			/**
36			* Analysis targets paths.
37			* @var array list of files and directories paths.
38			*/
39			protected $analysedPaths;
40
41			/**
42			* Composer binaries directory path.
43			* @var string directory path.
44			*/
45			protected $binariesPath;
46
47			/**
48			* Set dependencies and initialize CLI.
49			* @param CLImate $climate CLImate instance.
50			* @param string $binariesPath Composer binaries path.
51			* @param array $arguments command line arguments.
52			*/
53			public function __construct(CLImate $climate, $binariesPath, array $arguments)
54			{
55			$this->cli = $climate;
56			$this->cli->description($this->getDescription());
57			$this->cli->arguments->add($this->getArguments());
58			$this->cli->arguments->parse($arguments);
59
60			$this->arguments = $arguments;
61			$this->binariesPath = $binariesPath;
62			$this->setAnalysedPathsFromString($this->getArgumentValue('path'));
63			}
64
65			/**
66			* Run PHP-Hound command.
67			* @return boolean true if it didn't find code issues or ran successfully.
68			*/
69			public function run()
70			{
71			if ($this->hasArgumentValue('help')) {
72			$this->cli->usage();
73			return true;
74			}
75
76			if ($this->hasArgumentValue('version')) {
77			$this->cli->out($this->getDescription());
78			return true;
79			}
80
81			if ($this->hasArgumentValue('git-diff')) {
82			$gitDiff = $this->getArgumentValue('git-diff');
83			$filter = $this->getGitDiffFilter($gitDiff);
84			$analysedFiles = $filter->getFilesWithAddedCode();
85			$this->setAnalysedPaths($analysedFiles);
86			$this->getAnalyser()->setResultsFilter($filter);
87			$this->getAnalyser()->setAnalysedPaths($analysedFiles);
88			}
89
90			return $this->getAnalyser()->run();
91			}
92
93			/**
94			* Create a DiffOutputFilter based on a git-diff param.
95			* @param string $gitDiff git diff arguments.
96			* @return DiffOutputFilter filter instance.
97			*/
98			protected function getGitDiffFilter($gitDiff)
99			{
100			$analysedPaths = $this->getAnalysedPaths();
101			$gitPath = array_shift($analysedPaths);
102			if (!is_dir($gitPath)) {
103			$gitPath = dirname($gitPath);
104			}
105			$git = new Git($gitPath);
106			$executeMethod = new ReflectionMethod($git, 'execute');
107			$executeMethod->setAccessible(true);
108			$gitRoot = trim(implode("\n", $executeMethod->invoke($git, 'git rev-parse --show-toplevel')));
109			list($base, $changed) = explode('..', $gitDiff);
110			$diff = $git->getDiff($base, $changed);
111			$diffParser = new Parser;
112			return new DiffOutputFilter($gitRoot, $diffParser->parse($diff));
			0 ignored issues – show Documentation introduced 2016-10-17 17:46 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<php...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...
113			}
114
115			/**
116			* Initialize output.
117			* @throws UnexpectedValueException on invalid format value.
118			* @return AbstractOutput
119			*/
120			protected function getOutput()
121			{
122			$format = $this->getOutputFormat();
123			$formatClasses = $this->getOutputFormatClasses();
124
125			if (!isset($formatClasses[$format])) {
126			throw new UnexpectedValueException(
127			'Invalid format: "' . $format . '"'
128			);
129			}
130
131			$outputClassName = $formatClasses[$format];
132
133			return new $outputClassName(
134			$this->cli,
135			$this->getWorkingDirectory()
136			);
137			}
138
139			/**
140			* Command line arguments list for CLImate.
141			* @return array CLI list of arguments.
142			*/
143			protected function getArguments()
144			{
145			return [
146			'help' => [
147			'prefix' => 'h',
148			'longPrefix' => 'help',
149			'description' => 'Prints a usage statement',
150			'noValue' => true,
151			],
152			'version' => [
153			'prefix' => 'v',
154			'longPrefix' => 'version',
155			'description' => 'Prints installed version',
156			'noValue' => true,
157			],
158			'ignore' => [
159			'prefix' => 'i',
160			'longPrefix' => 'ignore',
161			'description' => 'Ignore a comma-separated list of directories',
162			'castTo' => 'string',
163			'defaultValue' => 'vendor,tests,features,spec',
164			],
165			'format' => [
166			'prefix' => 'f',
167			'longPrefix' => 'format',
168			'description' => 'Output format',
169			'castTo' => 'string',
170			'defaultValue' => 'text',
171			],
172			'git-diff' => [
173			'prefix' => 'g',
174			'longPrefix' => 'git-diff',
175			'description' => 'Limit to files and lines changed between two '
176			. 'commits or branches, e.g., "master..other".',
177			'castTo' => 'string',
178			],
179			'path' => [
180			'description' => 'File or directory path to analyze',
181			'defaultValue' => '.',
182			],
183			];
184			}
185
186			/**
187			* Get a list of paths to be ignored by the analysis.
188			* @return string[] a list of file and/or directory paths.
189			*/
190			public function getIgnoredPaths()
191			{
192			$ignoredArgument = $this->getArgumentValue('ignore');
193			$ignoredPaths = explode(',', $ignoredArgument);
194			return array_filter($ignoredPaths);
195			}
196
197			/**
198			* Parse a string of comma separated files and/or directories to be analysed.
199			* @param string $pathsString the path argument value.
200			* @return void
201			*/
202			protected function setAnalysedPathsFromString($pathsString)
203			{
204			$rawAnalysedPaths = explode(',', $pathsString);
205			$analysedPaths = array_filter($rawAnalysedPaths);
			0 ignored issues – show Unused Code introduced 2016-10-17 17:46 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...
206			$this->setAnalysedPaths(array_filter($rawAnalysedPaths));
207			}
208
209			/**
210			* Set target files and/or directories to be analysed. Fix relative paths.
211			* @param string[] $paths target paths.
212			* @return void
213			*/
214			protected function setAnalysedPaths(array $paths)
215			{
216			foreach ($paths as &$path) {
217			if (0 === strpos($path, DIRECTORY_SEPARATOR)) {
218			continue;
219			}
220			$path = $this->getWorkingDirectory() . DIRECTORY_SEPARATOR . $path;
221			}
222			$this->analysedPaths = $paths;
223			}
224
225			/**
226			* Analysis target paths.
227			* @return string[] a list of analysed paths (usually just one).
228			*/
229			public function getAnalysedPaths()
230			{
231			return $this->analysedPaths;
232			}
233
234			/**
235			* Running script path.
236			* @return string current script directory.
237			*/
238			public function getWorkingDirectory()
239			{
240			return getcwd();
241			}
242
243			/**
244			* Output format.
245			* @return string format type.
246			*/
247			public function getOutputFormat()
248			{
249			return $this->getArgumentValue('format');
250			}
251
252			/**
253			* CLI output description.
254			* @return string description.
255			*/
256			public function getDescription()
257			{
258			return 'PHP Hound ' . Analyser::VERSION;
259			}
260
261			/**
262			* Analyser instance.
263			* @return Analyser instance.
264			*/
265			public function getAnalyser()
266			{
267			if (null === $this->analyser) {
268			$this->analyser = new Analyser(
269			$this->getOutput(),
270			$this->binariesPath,
271			$this->getAnalysedPaths(),
272			$this->getIgnoredPaths()
273			);
274			}
275			return $this->analyser;
276			}
277
278			/**
279			* List of output format classes.
280			* @return array array where the key is a format and its value the class.
281			*/
282			protected function getOutputFormatClasses()
283			{
284			return [
285			'text' => 'phphound\output\TextOutput',
286			'json' => 'phphound\output\JsonOutput',
287			'xml' => 'phphound\output\XmlOutput',
288			'csv' => 'phphound\output\CsvOutput',
289			'html' => 'phphound\output\HtmlOutput',
290			];
291			}
292
293			/**
294			* Get argument value from user informed arguments.
295			* @param string $name argument name.
296			* @return Mixed argument value.
297			*/
298			protected function getArgumentValue($name)
299			{
300			return $this->cli->arguments->get($name);
301			}
302
303			/**
304			* Check if the user supplied an argument.
305			* @param string $name argument name.
306			* @return boolean if the argument has informed or not.
307			*/
308			protected function hasArgumentValue($name)
309			{
310			return $this->cli->arguments->defined($name, $this->arguments);
311			}
312			}
313

alanwillms / php-hound

Command::hasArgumentValue() A last analyzed 2016-10-25 18:40 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Command::hasArgumentValue() A
last analyzed 2016-10-25 18:40 UTC