Config - Code Metrics - Inspection of "Merge branch 'release/1.97.27'" - netz98/n98-magerun - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( bb289e...4630f9 )

by Tom

created 2016-12-11 22:15 UTC

Config B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	327
Duplicated Lines	3.06 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

Metric	Value
wmc	42
lcom	1
cbo	6
dl	10
loc	327
rs	8.295
c	0
b	0
f	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
B	checkConfigCommandAlias()	0	30	5
A	registerConfigCommandAlias()	0	17	4
B	registerCustomCommands()	0	33	4
B	newCommand()	0	26	6
A	registerCustomAutoloaders()	10	16	3
A	setConfig()	0	4	1
A	getConfig()	0	4	1
A	setLoader()	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
A	debugWriteln()	0	7	2
A	getArray()	0	9	2
A	traverse()	0	16	4

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 <https://github.com/ktomk>
 */

namespace N98\Magento\Application;

use Composer\Autoload\ClassLoader;
use InvalidArgumentException;
use N98\Magento\Application;
use N98\Util\ArrayFunctions;
use N98\Util\BinaryString;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Formatter\OutputFormatter;
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
{
    const PSR_0 = 'PSR-0';
    const PSR_4 = 'PSR-4';

    const COMMAND_CLASS = 'Symfony\Component\Console\Command\Command';

    /**
     * @var array config data
     */
    private $config = array();

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

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

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

    /**
     * @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);
    }
}
    {
        foreach ($this->getArray(array('commands', 'aliases')) as $alias) {
            if (!is_array($alias)) {
                continue;
            }
            $aliasCommandName = key($alias);
            if ($input->getFirstArgument() !== $aliasCommandName) {
                continue;
            }
            $aliasCommandParams = array_slice(
                BinaryString::trimExplodeEmpty(' ', $alias[$aliasCommandName]),
                1
            );
            if (0 === count($aliasCommandParams)) {
                continue;
            }

            // replace command (?) with aliased data
            $oldArgv = $_SERVER['argv'];
            $newArgv = array_merge(
                array_slice($oldArgv, 0, 2),
                $aliasCommandParams,
                array_slice($oldArgv, 2)
            );
            $input = new ArgvInput($newArgv);
        }

        return $input;
    }

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

            $aliasCommandName = key($alias);
            $commandString = $alias[$aliasCommandName];
            list($originalCommand) = explode(' ', $commandString, 2);
            if ($command->getName() !== $originalCommand) {
                continue;
            }

            $command->setAliases(array_merge($command->getAliases(), array($aliasCommandName)));
        }
    }

    /**
     * @param Application $application
     */
    public function registerCustomCommands(Application $application)
    {
        foreach ($this->getArray(array('commands', 'customCommands')) as $commandClass) {
            $commandName = null;
            if (is_array($commandClass)) {
                // Support for key => value (name -> class)
                $commandName = key($commandClass);
                $commandClass = current($commandClass);
            }
            if (null === $command = $this->newCommand($commandClass, $commandName)) {
                $this->output->writeln(
                    sprintf(
                        '<error>Can not add nonexistent command class "%s" as command to the application</error>',
                        $commandClass,
                        $commandName
                    )
                );
                $this->debugWriteln(
                    'Please check the configuration files contain the correct class-name. If the ' .
                    'class-name is correct, check autoloader configurations.'
                );
            } else {
                $this->debugWriteln(
                    sprintf(
                        '<debug>Add command </debug> <info>%s</info> -> <comment>%s</comment>',
                        $command->getName(),
                        get_class($command)
                    )
                );
                $application->add($command);
            }
        }
    }

    /**
     * @param string $className
     * @param string|null $commandName
     * @return Command
     * @throws InvalidArgumentException
     */
    private function newCommand($className, $commandName)
    {
        /** @var Command $command */
        if (!(is_string($className) || is_object($className))) {
            throw new InvalidArgumentException(
                sprintf('Command classname must be string, %s given', gettype($className))
            );
        }

        if (!class_exists($className)) {
            return null;
        }

        if (false === is_subclass_of($className, self::COMMAND_CLASS, true)) {
            throw new InvalidArgumentException(
                sprintf('Class "%s" is not a Command (subclass of "%s")', $className, self::COMMAND_CLASS)
            );
        }

        $command = new $className();
        if (null !== $commandName) {
            $command->setName($commandName);
        }

        return $command;
    }

    /**
     * Adds autoloader prefixes from user's config
     *
     * @param ClassLoader $autoloader
     */
    public function registerCustomAutoloaders(ClassLoader $autoloader)
    {
        $mask = '<debug>Registered %s autoloader </debug> <info>%s</info> -> <comment>%s</comment>';

        foreach ($this->getArray('autoloaders') as $prefix => $paths) {

            $paths = (array) $paths;
            $this->debugWriteln(sprintf($mask, self::PSR_0, OutputFormatter::escape($prefix), implode(",", $paths)));
            $autoloader->add($prefix, $paths);
        }

        foreach ($this->getArray('autoloaders_psr4') as $prefix => $paths) {

            $paths = (array) $paths;
            $this->debugWriteln(sprintf($mask, self::PSR_4, OutputFormatter::escape($prefix), implode(",", $paths)));
            $autoloader->addPsr4($prefix, $paths);
        }
    }

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

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

    /**
     * @param ConfigurationLoader $configurationLoader
     */
    public function setLoader(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 = array();
        }

        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;
    }

    /**
     * @param string $message
     */
    private function debugWriteln($message)
    {
        $output = $this->output;
        if (OutputInterface::VERBOSITY_DEBUG <= $output->getVerbosity()) {
            $output->writeln($message);
        }
    }

    /**
     * Get array from config, default to an empty array if not set
     *
     * @param string|array $key
     * @param array $default [optional]
     * @return array
     */
    private function getArray($key, $default = array())
    {
        $result = $this->traverse((array) $key);
        if (null === $result) {
            return $default;
        }

        return $result;
    }

    private function traverse(array $keys)
    {
        $anchor = &$this->config;
        foreach ($keys as $key) {
            if (!is_array($anchor)) {
                return;
            }

            if (!isset($anchor[$key])) {
                return;
            }
            $anchor = &$anchor[$key];
        }

        return $anchor;
    }
}


1		<?php
2		/*
3		* @author Tom Klingenberg <https://github.com/ktomk>
4		*/
5
6		namespace N98\Magento\Application;
7
8		use Composer\Autoload\ClassLoader;
9		use InvalidArgumentException;
10		use N98\Magento\Application;
11		use N98\Util\ArrayFunctions;
12		use N98\Util\BinaryString;
13		use Symfony\Component\Console\Command\Command;
14		use Symfony\Component\Console\Formatter\OutputFormatter;
15		use Symfony\Component\Console\Input\ArgvInput;
16		use Symfony\Component\Console\Input\InputInterface;
17		use Symfony\Component\Console\Output\NullOutput;
18		use Symfony\Component\Console\Output\OutputInterface;
19
20		/**
21		* Class Config
22		*
23		* Class representing the application configuration. Created to factor out configuration related application
24		* functionality from @see \N98\Magento\Application
25		*
26		* @package N98\Magento\Application
27		*/
28		class Config
29		{
30		const PSR_0 = 'PSR-0';
31		const PSR_4 = 'PSR-4';
32
33		const COMMAND_CLASS = 'Symfony\Component\Console\Command\Command';
34
35		/**
36		* @var array config data
37		*/
38		private $config = array();
39
40		/**
41		* @var array
42		*/
43		private $partialConfig = array();
44
45		/**
46		* @var ConfigurationLoader
47		*/
48		private $loader;
49
50		/**
51		* @var array
52		*/
53		private $initConfig = array();
54
55		/**
56		* @var boolean
57		*/
58		private $isPharMode;
59
60		/**
61		* @var OutputInterface
62		*/
63		private $output;
64
65		/**
66		* Config constructor.
67		*
68		* @param array $initConfig
69		* @param bool $isPharMode
70		* @param OutputInterface $output [optional]
71		*/
72		public function __construct(array $initConfig = array(), $isPharMode = false, OutputInterface $output = null)
73		{
74		$this->initConfig = $initConfig;
75		$this->isPharMode = (bool) $isPharMode;
76		$this->output = $output ?: new NullOutput();
77		}
78
79		/**
80		* alias magerun command in input from config
81		*
82		* @param InputInterface $input
83		* @return ArgvInput\|InputInterface
84		*/
85		public function checkConfigCommandAlias(InputInterface $input)
		0 ignored issues – show Coding Style introduced 2016-07-17 22:26 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...
86		{
87		foreach ($this->getArray(array('commands', 'aliases')) as $alias) {
88		if (!is_array($alias)) {
89		continue;
90		}
91		$aliasCommandName = key($alias);
92		if ($input->getFirstArgument() !== $aliasCommandName) {
93		continue;
94		}
95		$aliasCommandParams = array_slice(
96		BinaryString::trimExplodeEmpty(' ', $alias[$aliasCommandName]),
97		1
98		);
99		if (0 === count($aliasCommandParams)) {
100		continue;
101		}
102
103		// replace command (?) with aliased data
104		$oldArgv = $_SERVER['argv'];
105		$newArgv = array_merge(
106		array_slice($oldArgv, 0, 2),
107		$aliasCommandParams,
108		array_slice($oldArgv, 2)
109		);
110		$input = new ArgvInput($newArgv);
111		}
112
113		return $input;
114		}
115
116		/**
117		* @param Command $command
118		*/
119		public function registerConfigCommandAlias(Command $command)
120		{
121		foreach ($this->getArray(array('commands', 'aliases')) as $alias) {
122		if (!is_array($alias)) {
123		continue;
124		}
125
126		$aliasCommandName = key($alias);
127		$commandString = $alias[$aliasCommandName];
128		list($originalCommand) = explode(' ', $commandString, 2);
129		if ($command->getName() !== $originalCommand) {
130		continue;
131		}
132
133		$command->setAliases(array_merge($command->getAliases(), array($aliasCommandName)));
134		}
135		}
136
137		/**
138		* @param Application $application
139		*/
140		public function registerCustomCommands(Application $application)
141		{
142		foreach ($this->getArray(array('commands', 'customCommands')) as $commandClass) {
143		$commandName = null;
144		if (is_array($commandClass)) {
145		// Support for key => value (name -> class)
146		$commandName = key($commandClass);
147		$commandClass = current($commandClass);
148		}
149		if (null === $command = $this->newCommand($commandClass, $commandName)) {
150		$this->output->writeln(
151		sprintf(
152		'<error>Can not add nonexistent command class "%s" as command to the application</error>',
153		$commandClass,
154		$commandName
155		)
156		);
157		$this->debugWriteln(
158		'Please check the configuration files contain the correct class-name. If the ' .
159		'class-name is correct, check autoloader configurations.'
160		);
161		} else {
162		$this->debugWriteln(
163		sprintf(
164		'<debug>Add command </debug> <info>%s</info> -> <comment>%s</comment>',
165		$command->getName(),
166		get_class($command)
167		)
168		);
169		$application->add($command);
170		}
171		}
172		}
173
174		/**
175		* @param string $className
176		* @param string\|null $commandName
177		* @return Command
178		* @throws InvalidArgumentException
179		*/
180		private function newCommand($className, $commandName)
181		{
182		/** @var Command $command */
183		if (!(is_string($className) \|\| is_object($className))) {
184		throw new InvalidArgumentException(
185		sprintf('Command classname must be string, %s given', gettype($className))
186		);
187		}
188
189		if (!class_exists($className)) {
190		return null;
191		}
192
193		if (false === is_subclass_of($className, self::COMMAND_CLASS, true)) {
194		throw new InvalidArgumentException(
195		sprintf('Class "%s" is not a Command (subclass of "%s")', $className, self::COMMAND_CLASS)
196		);
197		}
198
199		$command = new $className();
200		if (null !== $commandName) {
201		$command->setName($commandName);
202		}
203
204		return $command;
205		}
206
207		/**
208		* Adds autoloader prefixes from user's config
209		*
210		* @param ClassLoader $autoloader
211		*/
212		public function registerCustomAutoloaders(ClassLoader $autoloader)
213		{
214		$mask = '<debug>Registered %s autoloader </debug> <info>%s</info> -> <comment>%s</comment>';
215
216	View Code Duplication	foreach ($this->getArray('autoloaders') as $prefix => $paths) {
		0 ignored issues – show Duplication introduced 2016-12-07 20:18 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...
217		$paths = (array) $paths;
218		$this->debugWriteln(sprintf($mask, self::PSR_0, OutputFormatter::escape($prefix), implode(",", $paths)));
219		$autoloader->add($prefix, $paths);
220		}
221
222	View Code Duplication	foreach ($this->getArray('autoloaders_psr4') as $prefix => $paths) {
		0 ignored issues – show Duplication introduced 2016-12-07 20:18 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...
223		$paths = (array) $paths;
224		$this->debugWriteln(sprintf($mask, self::PSR_4, OutputFormatter::escape($prefix), implode(",", $paths)));
225		$autoloader->addPsr4($prefix, $paths);
226		}
227		}
228
229		/**
230		* @param array $config
231		*/
232		public function setConfig(array $config)
233		{
234		$this->config = $config;
235		}
236
237		/**
238		* @return array
239		*/
240		public function getConfig()
241		{
242		return $this->config;
243		}
244
245		/**
246		* @param ConfigurationLoader $configurationLoader
247		*/
248		public function setLoader(ConfigurationLoader $configurationLoader)
249		{
250		$this->loader = $configurationLoader;
251		}
252
253		/**
254		* @return ConfigurationLoader
255		*/
256		public function getLoader()
257		{
258		if (!$this->loader) {
259		$this->loader = $this->createLoader($this->initConfig, $this->isPharMode, $this->output);
260		$this->initConfig = array();
261		}
262
263		return $this->loader;
264		}
265
266		public function load()
267		{
268		$this->config = $this->getLoader()->toArray();
269		}
270
271		/**
272		* @param bool $loadExternalConfig
273		*/
274		public function loadPartialConfig($loadExternalConfig)
275		{
276		$loader = $this->getLoader();
277		$this->partialConfig = $loader->getPartialConfig($loadExternalConfig);
278		}
279
280		/**
281		* Get names of sub-folders to be scanned during Magento detection
282		*
283		* @return array
284		*/
285		public function getDetectSubFolders()
286		{
287		if (isset($this->partialConfig['detect']['subFolders'])) {
288		return $this->partialConfig['detect']['subFolders'];
289		}
290
291		return array();
292		}
293
294		/**
295		* @param array $initConfig
296		* @param bool $isPharMode
297		* @param OutputInterface $output
298		*
299		* @return ConfigurationLoader
300		*/
301		public function createLoader(array $initConfig, $isPharMode, OutputInterface $output)
302		{
303		$config = ArrayFunctions::mergeArrays($this->config, $initConfig);
304
305		$loader = new ConfigurationLoader($config, $isPharMode, $output);
306
307		return $loader;
308		}
309
310		/**
311		* @param string $message
312		*/
313		private function debugWriteln($message)
314		{
315		$output = $this->output;
316		if (OutputInterface::VERBOSITY_DEBUG <= $output->getVerbosity()) {
317		$output->writeln($message);
318		}
319		}
320
321		/**
322		* Get array from config, default to an empty array if not set
323		*
324		* @param string\|array $key
325		* @param array $default [optional]
326		* @return array
327		*/
328		private function getArray($key, $default = array())
329		{
330		$result = $this->traverse((array) $key);
331		if (null === $result) {
332		return $default;
333		}
334
335		return $result;
336		}
337
338		private function traverse(array $keys)
339		{
340		$anchor = &$this->config;
341		foreach ($keys as $key) {
342		if (!is_array($anchor)) {
343		return;
344		}
345
346		if (!isset($anchor[$key])) {
347		return;
348		}
349		$anchor = &$anchor[$key];
350		}
351
352		return $anchor;
353		}
354		}
355

netz98 / n98-magerun