ChurnCommand::setupProcessor() - Code Metrics - Inspection of "Introduce -c option custom churn.yml file" - bmitch/churn-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#109)

unknown

created 2017-10-01 20:16 UTC

ChurnCommand::setupProcessor() A

↳ Parent: ChurnCommand

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	5
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	3
nc	1
nop	1

<?php declare(strict_types = 1);

namespace Churn\Commands;

use Churn\Results\ResultCollection;
use Illuminate\Support\Collection;
use Churn\Factories\ProcessFactory;
use Churn\Managers\FileManager;
use Churn\Results\ResultsParser;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Churn\Configuration\Config;
use Symfony\Component\Yaml\Yaml;

class ChurnCommand extends Command
{
    /**
     * The config values.
     * @var Config
     */
    private $config;

    /**
     * The process factory.
     * @var ProcessFactory
     */
    private $processFactory;

    /**
     * Th results parser.
     * @var ResultsParser
     */
    private $resultsParser;

    /**
     * Collection of files to run the processes on.
     * @var FileCollection
     */
    private $filesCollection;

    /**
     * Collection of processes currently running.
     * @var Collection
     */
    private $runningProcesses;

    /**
     * Array of completed processes.
     * @var array
     */
    private $completedProcessesArray;

    /**
     * The start time.
     * @var float
     */
    private $startTime;

    /**
     * Keeps track of how many files were processed.
     * @var integer
     */
    private $filesCount;

    /**
     * ChurnCommand constructor.
     */
    public function __construct()
    {
        parent::__construct();

        $this->resultsParser = new ResultsParser();
    }

    /**
     * Configure the command
     * @return void
     */
    protected function configure()
    {
        $this->setName('run')
            ->addArgument('paths', InputArgument::IS_ARRAY, 'Path to source to check.')
            ->addOption('configuration', 'c', InputOption::VALUE_OPTIONAL, 'Path to the configuration file', 'churn.yml')  // @codingStandardsIgnoreLine
            ->setDescription('Check files')
            ->setHelp('Checks the churn on the provided path argument(s).');
    }

    /**
     * Execute the command
     * @param  InputInterface  $input  Input.
     * @param  OutputInterface $output Output.
     * @return void
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->startTime = microtime(true);
        $this->setupProcessor($input->getOption('configuration'));

        $this->filesCollection = $this->createFileManager()->getPhpFiles($input->getArgument('paths'));

        $this->filesCount = $this->filesCollection->count();
        $this->runningProcesses = new Collection;
        $this->completedProcessesArray = [];
        while ($this->filesCollection->hasFiles() || $this->runningProcesses->count()) {
            $this->getProcessResults();
        }
        $completedProcesses = new Collection($this->completedProcessesArray);

        $results = $this->resultsParser
            ->parse($completedProcesses)
            ->normalizeAgainst($this->config);
        $this->displayResults($output, $results);
    }

    /**
     * Gets the output from processes and stores them in the completedProcessArray member.
     * @return void
     */
    private function getProcessResults()
    {
        for ($index = $this->runningProcesses->count(); $this->filesCollection->hasFiles() > 0 && $index < $this->config->getParallelJobs(); $index++) {
            $file = $this->filesCollection->getNextFile();

            $process = $this->processFactory->createGitCommitProcess($file);
            $process->start();
            $this->runningProcesses->put($process->getKey(), $process);

            $process = $this->processFactory->createCyclomaticComplexityProcess($file);
            $process->start();
            $this->runningProcesses->put($process->getKey(), $process);
        }

        foreach ($this->runningProcesses as $file => $process) {
            if ($process->isSuccessful()) {
                $this->runningProcesses->forget($process->getKey());
                $this->completedProcessesArray[$process->getFileName()][$process->getType()] = $process;
            }
        }
    }

    /**
     * Displays the results in a table.
     * @param  OutputInterface  $output  Output.
     * @param  ResultCollection $results Results Collection.
     * @return void
     */
    protected function displayResults(OutputInterface $output, ResultCollection $results)
    {
        $totalTime = microtime(true) - $this->startTime;
        echo "\n
    ___  _   _  __  __  ____  _  _     ____  _   _  ____
   / __)( )_( )(  )(  )(  _ \( \( )___(  _ \( )_( )(  _ \
  ( (__  ) _ (  )(__)(  )   / )  ((___))___/ ) _ (  )___/
   \___)(_) (_)(______)(_)\_)(_)\_)   (__)  (_) (_)(__)      https://github.com/bmitch/churn-php\n\n";

        $table = new Table($output);
        $table->setHeaders(['File', 'Times Changed', 'Complexity', 'Score']);
        $table->addRows($results->toArray());

        $table->render();

        echo "  "
            . $this->filesCount
            . " files analysed in {$totalTime} seconds using "
            . $this->config->getParallelJobs()
            . " parallel jobs.\n\n";
    }

    /**
     * @param string $configFile
     * @return void
     */
    private function setupProcessor(string $configFile)
    {
        $this->config = Config::create(Yaml::parse(@file_get_contents($configFile)) ?? []);
        $this->processFactory = new ProcessFactory($this->config);
    }

    /**
     * @return FileManager
     */
    private function createFileManager() : FileManager
    {
        return new FileManager($this->config->getFileExtensions(), $this->config->getFilesToIgnore());
    }
}


1			<?php declare(strict_types = 1);
2
3			namespace Churn\Commands;
4
5			use Churn\Results\ResultCollection;
6			use Illuminate\Support\Collection;
7			use Churn\Factories\ProcessFactory;
8			use Churn\Managers\FileManager;
9			use Churn\Results\ResultsParser;
10			use Symfony\Component\Console\Command\Command;
11			use Symfony\Component\Console\Helper\Table;
12			use Symfony\Component\Console\Input\InputArgument;
13			use Symfony\Component\Console\Input\InputInterface;
14			use Symfony\Component\Console\Input\InputOption;
15			use Symfony\Component\Console\Output\OutputInterface;
16			use Churn\Configuration\Config;
17			use Symfony\Component\Yaml\Yaml;
18
19			class ChurnCommand extends Command
20			{
21			/**
22			* The config values.
23			* @var Config
24			*/
25			private $config;
26
27			/**
28			* The process factory.
29			* @var ProcessFactory
30			*/
31			private $processFactory;
32
33			/**
34			* Th results parser.
35			* @var ResultsParser
36			*/
37			private $resultsParser;
38
39			/**
40			* Collection of files to run the processes on.
41			* @var FileCollection
42			*/
43			private $filesCollection;
44
45			/**
46			* Collection of processes currently running.
47			* @var Collection
48			*/
49			private $runningProcesses;
50
51			/**
52			* Array of completed processes.
53			* @var array
54			*/
55			private $completedProcessesArray;
56
57			/**
58			* The start time.
59			* @var float
60			*/
61			private $startTime;
62
63			/**
64			* Keeps track of how many files were processed.
65			* @var integer
66			*/
67			private $filesCount;
68
69			/**
70			* ChurnCommand constructor.
71			*/
72			public function __construct()
73			{
74			parent::__construct();
75
76			$this->resultsParser = new ResultsParser();
77			}
78
79			/**
80			* Configure the command
81			* @return void
82			*/
83			protected function configure()
84			{
85			$this->setName('run')
86			->addArgument('paths', InputArgument::IS_ARRAY, 'Path to source to check.')
87			->addOption('configuration', 'c', InputOption::VALUE_OPTIONAL, 'Path to the configuration file', 'churn.yml') // @codingStandardsIgnoreLine
88			->setDescription('Check files')
89			->setHelp('Checks the churn on the provided path argument(s).');
90			}
91
92			/**
93			* Execute the command
94			* @param InputInterface $input Input.
95			* @param OutputInterface $output Output.
96			* @return void
97			*/
98			protected function execute(InputInterface $input, OutputInterface $output)
99			{
100			$this->startTime = microtime(true);
101			$this->setupProcessor($input->getOption('configuration'));
102
103			$this->filesCollection = $this->createFileManager()->getPhpFiles($input->getArgument('paths'));
			0 ignored issues – show Documentation Bug introduced 2017-10-01 20:12 UTC by Report Bug Copy Issue Report It seems like `$this->createFileManager...->getArgument('paths'))` of type `object<Churn\Collections\FileCollection>` is incompatible with the declared type `object<Churn\Commands\FileCollection>` of property `$filesCollection`. 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...
104			$this->filesCount = $this->filesCollection->count();
105			$this->runningProcesses = new Collection;
106			$this->completedProcessesArray = [];
107			while ($this->filesCollection->hasFiles() \|\| $this->runningProcesses->count()) {
108			$this->getProcessResults();
109			}
110			$completedProcesses = new Collection($this->completedProcessesArray);
111
112			$results = $this->resultsParser
113			->parse($completedProcesses)
114			->normalizeAgainst($this->config);
115			$this->displayResults($output, $results);
116			}
117
118			/**
119			* Gets the output from processes and stores them in the completedProcessArray member.
120			* @return void
121			*/
122			private function getProcessResults()
123			{
124			for ($index = $this->runningProcesses->count(); $this->filesCollection->hasFiles() > 0 && $index < $this->config->getParallelJobs(); $index++) {
125			$file = $this->filesCollection->getNextFile();
126
127			$process = $this->processFactory->createGitCommitProcess($file);
128			$process->start();
129			$this->runningProcesses->put($process->getKey(), $process);
130
131			$process = $this->processFactory->createCyclomaticComplexityProcess($file);
132			$process->start();
133			$this->runningProcesses->put($process->getKey(), $process);
134			}
135
136			foreach ($this->runningProcesses as $file => $process) {
137			if ($process->isSuccessful()) {
138			$this->runningProcesses->forget($process->getKey());
139			$this->completedProcessesArray[$process->getFileName()][$process->getType()] = $process;
140			}
141			}
142			}
143
144			/**
145			* Displays the results in a table.
146			* @param OutputInterface $output Output.
147			* @param ResultCollection $results Results Collection.
148			* @return void
149			*/
150			protected function displayResults(OutputInterface $output, ResultCollection $results)
151			{
152			$totalTime = microtime(true) - $this->startTime;
153			echo "\n
154			___ _ _ __ __ ____ _ _ ____ _ _ ____
155			/ __)( )_( )( )( )( _ \( \( )___( _ \( )_( )( _ \
156			( (__ ) _ ( )(__)( ) / ) ((___))___/ ) _ ( )___/
157			\___)(_) (_)(______)(_)\_)(_)\_) (__) (_) (_)(__) https://github.com/bmitch/churn-php\n\n";
158
159			$table = new Table($output);
160			$table->setHeaders(['File', 'Times Changed', 'Complexity', 'Score']);
161			$table->addRows($results->toArray());
162
163			$table->render();
164
165			echo " "
166			. $this->filesCount
167			. " files analysed in {$totalTime} seconds using "
168			. $this->config->getParallelJobs()
169			. " parallel jobs.\n\n";
170			}
171
172			/**
173			* @param string $configFile
174			* @return void
175			*/
176			private function setupProcessor(string $configFile)
177			{
178			$this->config = Config::create(Yaml::parse(@file_get_contents($configFile)) ?? []);
179			$this->processFactory = new ProcessFactory($this->config);
180			}
181
182			/**
183			* @return FileManager
184			*/
185			private function createFileManager() : FileManager
186			{
187			return new FileManager($this->config->getFileExtensions(), $this->config->getFilesToIgnore());
188			}
189			}
190

bmitch / churn-php

Pull Request — master (#109)

ChurnCommand::setupProcessor() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like