Config - Code Metrics - Inspection of "[TASK] add Config" - netz98/n98-magerun2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( c5b022...56acec )

by Tom

created 2016-01-07 00:18 UTC

Config B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	258
Duplicated Lines	9.3 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
wmc	40
c	1
b	0
f	1
lcom	1
cbo	10
dl	24
loc	258
rs	8.2609

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
B	checkConfigCommandAlias()	0	27	6
B	registerConfigCommandAlias()	0	20	5
A	hasConfigCommandAliases()	0	4	2
B	registerCustomCommands()	0	26	6
D	registerCustomAutoloaders()	24	30	9
A	setConfig()	0	4	1
A	getConfig()	0	4	1
A	setConfigurationLoader()	0	4	1
A	getLoader()	0	9	2
A	load()	0	4	1
A	loadPartialConfig()	0	5	1
A	getDetectSubFolders()	0	8	2
A	createLoader()	0	8	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Config often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Config, and based on these observations, apply Extract Interface, too.

<?php
/*
 * @author Tom Klingenberg <[email protected]>
 */

namespace N98\Magento\Application;

use Composer\Autoload\ClassLoader;
use N98\Magento\Application;
use N98\Magento\Application\ConfigurationLoader;
use N98\Util\ArrayFunctions;
use N98\Util\BinaryString;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\ArgvInput;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\NullOutput;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * Class Config
 *
 * Class representing the application configuration. Created to factor out configuration related application
 * functionality from @see N98\Magento\Application
 *
 * @package N98\Magento\Application
 */
class Config
{
    /**
     * @var array config data
     */
    private $config = array();

    /**
     * @var array
     */
    private $partialConfig = array();

    /**
     * @var ConfigurationLoader
     */
    private $loader;

    /**
     * @var array
     */
    private $initConfig;

    /**
     * @var boolean
     */
    private $isPharMode;

    /**
     * @var OutputInterface
     */
    private $output;


    /**
     * Config constructor.
     * @param array $initConfig
     * @param bool $isPharMode
     * @param OutputInterface $output [optional]

     */
    public function __construct(array $initConfig = array(), $isPharMode = false, OutputInterface $output = null)
    {
        $this->initConfig = $initConfig;
        $this->isPharMode = (bool) $isPharMode;
        $this->output = $output ?: new NullOutput();
    }

    /**
     * alias magerun command in input from config
     *
     * @param InputInterface $input
     * @return ArgvInput|InputInterface
     */
    public function checkConfigCommandAlias(InputInterface $input)
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if ($this->hasConfigCommandAliases()) {
            foreach ($this->config['commands']['aliases'] as $alias) {
                if (is_array($alias)) {
                    $aliasCommandName = key($alias);
                    if ($input->getFirstArgument() == $aliasCommandName) {
                        $aliasCommandParams = array_slice(BinaryString::trimExplodeEmpty(' ',
                            $alias[$aliasCommandName]), 1);
                        if (count($aliasCommandParams) > 0) {
                            // replace with aliased data
                            $mergedParams = array_merge(
                                array_slice($_SERVER['argv'], 0, 2),
                                $aliasCommandParams,
                                array_slice($_SERVER['argv'], 2)
                            );
                            $input = new ArgvInput($mergedParams);
                        }
                    }
                }
            }

            return $input;
        }

        return $input;
    }

    /**
     * @param Command $command
     */
    public function registerConfigCommandAlias(Command $command)
    {
        if ($this->hasConfigCommandAliases()) {
            foreach ($this->config['commands']['aliases'] as $alias) {
                if (!is_array($alias)) {
                    continue;
                }

                $aliasCommandName = key($alias);
                $commandString    = $alias[$aliasCommandName];

                list($originalCommand) = explode(' ', $commandString);
                if ($command->getName() == $originalCommand) {
                    $currentCommandAliases   = $command->getAliases();
                    $currentCommandAliases[] = $aliasCommandName;
                    $command->setAliases($currentCommandAliases);
                }
            }
        }
    }

    /**
     * @return bool
     */
    private function hasConfigCommandAliases()
    {
        return isset($this->config['commands']['aliases']) && is_array($this->config['commands']['aliases']);
    }

    /**
     * @param Application $application
     */
    public function registerCustomCommands(Application $application)
    {
        if (isset($this->config['commands']['customCommands'])
            && is_array($this->config['commands']['customCommands'])
        ) {
            foreach ($this->config['commands']['customCommands'] as $commandClass) {
                if (is_array($commandClass)) { // Support for key => value (name -> class)
                    $resolvedCommandClass = current($commandClass);
                    /** @var Command $command */
                    $command = new $resolvedCommandClass();
                    $command->setName(key($commandClass));
                } else {
                    /** @var Command $command */
                    $command = new $commandClass();
                }
                $application->add($command);

                $output = $this->output;
                if (OutputInterface::VERBOSITY_DEBUG <= $output->getVerbosity()) {
                    $output->writeln(
                        '<debug>Added command </debug><comment>' . get_class($command) . '</comment>'
                    );
                }
            }
        }
    }

    /**
     * Adds autoloader prefixes from user's config
     *
     * @param ClassLoader $autoloader
     */
    public function registerCustomAutoloaders(ClassLoader $autoloader)
    {
        $output = $this->output;

        if (isset($this->config['autoloaders']) && is_array($this->config['autoloaders'])) {

            foreach ($this->config['autoloaders'] as $prefix => $path) {
                $autoloader->add($prefix, $path);

                if (OutputInterface::VERBOSITY_DEBUG <= $output->getVerbosity()) {
                    $output->writeln(
                        '<debug>Registrered PSR-2 autoloader </debug> <info>'
                        . $prefix . '</info> -> <comment>' . $path . '</comment>'
                    );
                }
            }
        }

        if (isset($this->config['autoloaders_psr4']) && is_array($this->config['autoloaders_psr4'])) {

            foreach ($this->config['autoloaders_psr4'] as $prefix => $path) {
                $autoloader->addPsr4($prefix, $path);

                if (OutputInterface::VERBOSITY_DEBUG <= $output->getVerbosity()) {
                    $output->writeln(
                        '<debug>Registrered PSR-4 autoloader </debug> <info>'
                        . $prefix . ' </info> -> <comment>' . $path . '</comment>'
                    );
                }
            }
        }
    }

    /**
     * @param array $config
     */
    public function setConfig(array $config)
    {
        $this->config = $config;
    }

    /**
     * @return array
     */
    public function getConfig()
    {
        return $this->config;
    }

    /**
     * @param ConfigurationLoader $configurationLoader
     */
    public function setConfigurationLoader(ConfigurationLoader $configurationLoader)
    {
        $this->loader = $configurationLoader;
    }

    /**
     * @return ConfigurationLoader
     */
    public function getLoader()
    {
        if (!$this->loader) {
            $this->loader = $this->createLoader($this->initConfig, $this->isPharMode, $this->output);
            $this->initConfig = null;

        }

        return $this->loader;
    }

    public function load()
    {
        $this->config = $this->getLoader()->toArray();
    }

    /**
     * @param bool $loadExternalConfig
     */
    public function loadPartialConfig($loadExternalConfig)
    {
        $loader              = $this->getLoader();
        $this->partialConfig = $loader->getPartialConfig($loadExternalConfig);
    }

    /**
     * Get names of sub-folders to be scanned during Magento detection
     * @return array
     */
    public function getDetectSubFolders()
    {
        if (isset($this->partialConfig['detect']['subFolders'])) {
            return $this->partialConfig['detect']['subFolders'];
        }

        return array();
    }

    /**
     * @param array $initConfig
     * @param bool $isPharMode
     * @param OutputInterface $output
     *
     * @return ConfigurationLoader
     */
    public function createLoader(array $initConfig, $isPharMode, OutputInterface $output)
    {
        $config = ArrayFunctions::mergeArrays($this->config, $initConfig);

        $loader = new ConfigurationLoader($config, $isPharMode, $output);

        return $loader;
    }
}


1		<?php
2		/*
3		* @author Tom Klingenberg <[email protected]>
4		*/
5
6		namespace N98\Magento\Application;
7
8		use Composer\Autoload\ClassLoader;
9		use N98\Magento\Application;
10		use N98\Magento\Application\ConfigurationLoader;
11		use N98\Util\ArrayFunctions;
12		use N98\Util\BinaryString;
13		use Symfony\Component\Console\Command\Command;
14		use Symfony\Component\Console\Input\ArgvInput;
15		use Symfony\Component\Console\Input\InputInterface;
16		use Symfony\Component\Console\Output\NullOutput;
17		use Symfony\Component\Console\Output\OutputInterface;
18
19		/**
20		* Class Config
21		*
22		* Class representing the application configuration. Created to factor out configuration related application
23		* functionality from @see N98\Magento\Application
24		*
25		* @package N98\Magento\Application
26		*/
27		class Config
28		{
29		/**
30		* @var array config data
31		*/
32		private $config = array();
33
34		/**
35		* @var array
36		*/
37		private $partialConfig = array();
38
39		/**
40		* @var ConfigurationLoader
41		*/
42		private $loader;
43
44		/**
45		* @var array
46		*/
47		private $initConfig;
48
49		/**
50		* @var boolean
51		*/
52		private $isPharMode;
53
54		/**
55		* @var OutputInterface
56		*/
57		private $output;
58
59
60		/**
61		* Config constructor.
62		* @param array $initConfig
63		* @param bool $isPharMode
64		* @param OutputInterface $output [optional]
		0 ignored issues – show Documentation introduced 2016-01-07 00:23 UTC by Report Bug Copy Issue Report Should the type for parameter `$output` not be `null\|OutputInterface`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
65		*/
66		public function __construct(array $initConfig = array(), $isPharMode = false, OutputInterface $output = null)
67		{
68		$this->initConfig = $initConfig;
69		$this->isPharMode = (bool) $isPharMode;
70		$this->output = $output ?: new NullOutput();
71		}
72
73		/**
74		* alias magerun command in input from config
75		*
76		* @param InputInterface $input
77		* @return ArgvInput\|InputInterface
78		*/
79		public function checkConfigCommandAlias(InputInterface $input)
		0 ignored issues – show Coding Style introduced 2016-01-07 00:24 UTC by Report Bug Copy Issue Report `checkConfigCommandAlias` uses the super-global variable `$_SERVER` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
80		{
81		if ($this->hasConfigCommandAliases()) {
82		foreach ($this->config['commands']['aliases'] as $alias) {
83		if (is_array($alias)) {
84		$aliasCommandName = key($alias);
85		if ($input->getFirstArgument() == $aliasCommandName) {
86		$aliasCommandParams = array_slice(BinaryString::trimExplodeEmpty(' ',
87		$alias[$aliasCommandName]), 1);
88		if (count($aliasCommandParams) > 0) {
89		// replace with aliased data
90		$mergedParams = array_merge(
91		array_slice($_SERVER['argv'], 0, 2),
92		$aliasCommandParams,
93		array_slice($_SERVER['argv'], 2)
94		);
95		$input = new ArgvInput($mergedParams);
96		}
97		}
98		}
99		}
100
101		return $input;
102		}
103
104		return $input;
105		}
106
107		/**
108		* @param Command $command
109		*/
110		public function registerConfigCommandAlias(Command $command)
111		{
112		if ($this->hasConfigCommandAliases()) {
113		foreach ($this->config['commands']['aliases'] as $alias) {
114		if (!is_array($alias)) {
115		continue;
116		}
117
118		$aliasCommandName = key($alias);
119		$commandString = $alias[$aliasCommandName];
120
121		list($originalCommand) = explode(' ', $commandString);
122		if ($command->getName() == $originalCommand) {
123		$currentCommandAliases = $command->getAliases();
124		$currentCommandAliases[] = $aliasCommandName;
125		$command->setAliases($currentCommandAliases);
126		}
127		}
128		}
129		}
130
131		/**
132		* @return bool
133		*/
134		private function hasConfigCommandAliases()
135		{
136		return isset($this->config['commands']['aliases']) && is_array($this->config['commands']['aliases']);
137		}
138
139		/**
140		* @param Application $application
141		*/
142		public function registerCustomCommands(Application $application)
143		{
144		if (isset($this->config['commands']['customCommands'])
145		&& is_array($this->config['commands']['customCommands'])
146		) {
147		foreach ($this->config['commands']['customCommands'] as $commandClass) {
148		if (is_array($commandClass)) { // Support for key => value (name -> class)
149		$resolvedCommandClass = current($commandClass);
150		/** @var Command $command */
151		$command = new $resolvedCommandClass();
152		$command->setName(key($commandClass));
153		} else {
154		/** @var Command $command */
155		$command = new $commandClass();
156		}
157		$application->add($command);
158
159		$output = $this->output;
160		if (OutputInterface::VERBOSITY_DEBUG <= $output->getVerbosity()) {
161		$output->writeln(
162		'<debug>Added command </debug><comment>' . get_class($command) . '</comment>'
163		);
164		}
165		}
166		}
167		}
168
169		/**
170		* Adds autoloader prefixes from user's config
171		*
172		* @param ClassLoader $autoloader
173		*/
174		public function registerCustomAutoloaders(ClassLoader $autoloader)
175		{
176		$output = $this->output;
177
178	View Code Duplication	if (isset($this->config['autoloaders']) && is_array($this->config['autoloaders'])) {
		0 ignored issues – show Duplication introduced 2016-01-07 00:24 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...
179		foreach ($this->config['autoloaders'] as $prefix => $path) {
180		$autoloader->add($prefix, $path);
181
182		if (OutputInterface::VERBOSITY_DEBUG <= $output->getVerbosity()) {
183		$output->writeln(
184		'<debug>Registrered PSR-2 autoloader </debug> <info>'
185		. $prefix . '</info> -> <comment>' . $path . '</comment>'
186		);
187		}
188		}
189		}
190
191	View Code Duplication	if (isset($this->config['autoloaders_psr4']) && is_array($this->config['autoloaders_psr4'])) {
		0 ignored issues – show Duplication introduced 2016-01-07 00:24 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...
192		foreach ($this->config['autoloaders_psr4'] as $prefix => $path) {
193		$autoloader->addPsr4($prefix, $path);
194
195		if (OutputInterface::VERBOSITY_DEBUG <= $output->getVerbosity()) {
196		$output->writeln(
197		'<debug>Registrered PSR-4 autoloader </debug> <info>'
198		. $prefix . ' </info> -> <comment>' . $path . '</comment>'
199		);
200		}
201		}
202		}
203		}
204
205		/**
206		* @param array $config
207		*/
208		public function setConfig(array $config)
209		{
210		$this->config = $config;
211		}
212
213		/**
214		* @return array
215		*/
216		public function getConfig()
217		{
218		return $this->config;
219		}
220
221		/**
222		* @param ConfigurationLoader $configurationLoader
223		*/
224		public function setConfigurationLoader(ConfigurationLoader $configurationLoader)
225		{
226		$this->loader = $configurationLoader;
227		}
228
229		/**
230		* @return ConfigurationLoader
231		*/
232		public function getLoader()
233		{
234		if (!$this->loader) {
235		$this->loader = $this->createLoader($this->initConfig, $this->isPharMode, $this->output);
236		$this->initConfig = null;
		0 ignored issues – show Documentation Bug introduced 2016-01-07 00:23 UTC by Report Bug Copy Issue Report It seems like `null` of type `null` is incompatible with the declared type `array` of property `$initConfig`. 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...
237		}
238
239		return $this->loader;
240		}
241
242		public function load()
243		{
244		$this->config = $this->getLoader()->toArray();
245		}
246
247		/**
248		* @param bool $loadExternalConfig
249		*/
250		public function loadPartialConfig($loadExternalConfig)
251		{
252		$loader = $this->getLoader();
253		$this->partialConfig = $loader->getPartialConfig($loadExternalConfig);
254		}
255
256		/**
257		* Get names of sub-folders to be scanned during Magento detection
258		* @return array
259		*/
260		public function getDetectSubFolders()
261		{
262		if (isset($this->partialConfig['detect']['subFolders'])) {
263		return $this->partialConfig['detect']['subFolders'];
264		}
265
266		return array();
267		}
268
269		/**
270		* @param array $initConfig
271		* @param bool $isPharMode
272		* @param OutputInterface $output
273		*
274		* @return ConfigurationLoader
275		*/
276		public function createLoader(array $initConfig, $isPharMode, OutputInterface $output)
277		{
278		$config = ArrayFunctions::mergeArrays($this->config, $initConfig);
279
280		$loader = new ConfigurationLoader($config, $isPharMode, $output);
281
282		return $loader;
283		}
284		}
285

netz98 / n98-magerun2