Config - Code Metrics - Inspection of "Improve build scripts" - netz98/n98-magerun2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 272892...d423fe )

by Tom

created 2016-07-17 23:07 UTC

Config B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	304
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	8
Bugs	1	Features	2

Metric	Value
wmc	40
c	8
b	1
f	2
lcom	1
cbo	6
dl	0
loc	304
rs	8.2608

18 Methods

Rating	Name	Size	Complexity
A	load()	4	1
A	loadPartialConfig()	5	1
A	__construct()	6	2
B	checkConfigCommandAlias()	27	5
A	registerConfigCommandAlias()	17	4
A	registerCustomCommands()	20	3
A	newCommand()	16	4
A	setConfig()	4	1
A	getConfig()	4	1
A	registerCustomAutoloaders()	14	3
A	setConfigurationLoader()	6	1
A	setLoader()	4	1
A	getLoader()	9	2
A	getDetectSubFolders()	8	2
A	createLoader()	8	1
A	debugWriteln()	7	2
A	getArray()	9	2
A	traverse()	16	4

How to fix Complexity

<?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
{
    /**
     * @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);
    }
}
    {
        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 (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;
    }

    /**
     * @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);
            }
            $command = $this->newCommand($commandClass, $commandName);
            $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))
            );
        }

        $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 => $path) {
            $autoloader->add($prefix, $path);
            $this->debugWriteln(sprintf($mask, 'PSR-2', $prefix, $path));
        }

        foreach ($this->getArray('autoloaders_psr4') as $prefix => $path) {
            $autoloader->addPsr4($prefix, $path);
            $this->debugWriteln(sprintf($mask, 'PSR-4', OutputFormatter::escape($prefix), $path));
        }
    }

    /**
     * @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)
    {
        trigger_error(__METHOD__ . ' use setLoader() instead', E_USER_DEPRECATED);

        $this->setLoader($configurationLoader);
    }

    /**
     * @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 = 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;
    }

    /**
     * @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			/**
31			* @var array config data
32			*/
33			private $config = array();
34
35			/**
36			* @var array
37			*/
38			private $partialConfig = array();
39
40			/**
41			* @var ConfigurationLoader
42			*/
43			private $loader;
44
45			/**
46			* @var array
47			*/
48			private $initConfig;
49
50			/**
51			* @var boolean
52			*/
53			private $isPharMode;
54
55			/**
56			* @var OutputInterface
57			*/
58			private $output;
59
60			/**
61			* Config constructor.
62			*
63			* @param array $initConfig
64			* @param bool $isPharMode
65			* @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...
66			*/
67			public function __construct(array $initConfig = array(), $isPharMode = false, OutputInterface $output = null)
68			{
69			$this->initConfig = $initConfig;
70			$this->isPharMode = (bool) $isPharMode;
71			$this->output = $output ?: new NullOutput();
72			}
73
74			/**
75			* alias magerun command in input from config
76			*
77			* @param InputInterface $input
78			* @return ArgvInput\|InputInterface
79			*/
80			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...
81			{
82			foreach ($this->getArray(array('commands', 'aliases')) as $alias) {
83			if (!is_array($alias)) {
84			continue;
85			}
86			$aliasCommandName = key($alias);
87			if ($input->getFirstArgument() !== $aliasCommandName) {
88			continue;
89			}
90			$aliasCommandParams = array_slice(
91			BinaryString::trimExplodeEmpty(' ', $alias[$aliasCommandName]),
92			1
93			);
94			if (count($aliasCommandParams) > 0) {
95			// replace with aliased data
96			$mergedParams = array_merge(
97			array_slice($_SERVER['argv'], 0, 2),
98			$aliasCommandParams,
99			array_slice($_SERVER['argv'], 2)
100			);
101			$input = new ArgvInput($mergedParams);
102			}
103			}
104
105			return $input;
106			}
107
108			/**
109			* @param Command $command
110			*/
111			public function registerConfigCommandAlias(Command $command)
112			{
113			foreach ($this->getArray(array('commands', 'aliases')) as $alias) {
114			if (!is_array($alias)) {
115			continue;
116			}
117
118			$aliasCommandName = key($alias);
119			$commandString = $alias[$aliasCommandName];
120			list($originalCommand) = explode(' ', $commandString, 2);
121			if ($command->getName() !== $originalCommand) {
122			continue;
123			}
124
125			$command->setAliases(array_merge($command->getAliases(), array($aliasCommandName)));
126			}
127			}
128
129			/**
130			* @param Application $application
131			*/
132			public function registerCustomCommands(Application $application)
133			{
134			foreach ($this->getArray(array('commands', 'customCommands')) as $commandClass) {
135			$commandName = null;
136			if (is_array($commandClass)) {
137			// Support for key => value (name -> class)
138			$commandName = key($commandClass);
139			$commandClass = current($commandClass);
140			}
141			$command = $this->newCommand($commandClass, $commandName);
142			$this->debugWriteln(
143			sprintf(
144			'<debug>Add command </debug> <info>%s</info> -> <comment>%s</comment>',
145			$command->getName(),
146			get_class($command)
147			)
148			);
149			$application->add($command);
150			}
151			}
152
153			/**
154			* @param string $className
155			* @param string\|null $commandName
156			* @return Command
157			* @throws InvalidArgumentException
158			*/
159			private function newCommand($className, $commandName)
160			{
161			/** @var Command $command */
162			if (!(is_string($className) \|\| is_object($className))) {
163			throw new InvalidArgumentException(
164			sprintf('Command classname must be string, %s given', gettype($className))
165			);
166			}
167
168			$command = new $className();
169			if (null !== $commandName) {
170			$command->setName($commandName);
171			}
172
173			return $command;
174			}
175
176			/**
177			* Adds autoloader prefixes from user's config
178			*
179			* @param ClassLoader $autoloader
180			*/
181			public function registerCustomAutoloaders(ClassLoader $autoloader)
182			{
183			$mask = '<debug>Registered %s autoloader </debug> <info>%s</info> -> <comment>%s</comment>';
184
185			foreach ($this->getArray('autoloaders') as $prefix => $path) {
186			$autoloader->add($prefix, $path);
187			$this->debugWriteln(sprintf($mask, 'PSR-2', $prefix, $path));
188			}
189
190			foreach ($this->getArray('autoloaders_psr4') as $prefix => $path) {
191			$autoloader->addPsr4($prefix, $path);
192			$this->debugWriteln(sprintf($mask, 'PSR-4', OutputFormatter::escape($prefix), $path));
193			}
194			}
195
196			/**
197			* @param array $config
198			*/
199			public function setConfig(array $config)
200			{
201			$this->config = $config;
202			}
203
204			/**
205			* @return array
206			*/
207			public function getConfig()
208			{
209			return $this->config;
210			}
211
212			/**
213			* @param ConfigurationLoader $configurationLoader
214			*/
215			public function setConfigurationLoader(ConfigurationLoader $configurationLoader)
216			{
217			trigger_error(__METHOD__ . ' use setLoader() instead', E_USER_DEPRECATED);
218
219			$this->setLoader($configurationLoader);
220			}
221
222			/**
223			* @param ConfigurationLoader $configurationLoader
224			*/
225			public function setLoader(ConfigurationLoader $configurationLoader)
226			{
227			$this->loader = $configurationLoader;
228			}
229
230			/**
231			* @return ConfigurationLoader
232			*/
233			public function getLoader()
234			{
235			if (!$this->loader) {
236			$this->loader = $this->createLoader($this->initConfig, $this->isPharMode, $this->output);
237			$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...
238			}
239
240			return $this->loader;
241			}
242
243			public function load()
244			{
245			$this->config = $this->getLoader()->toArray();
246			}
247
248			/**
249			* @param bool $loadExternalConfig
250			*/
251			public function loadPartialConfig($loadExternalConfig)
252			{
253			$loader = $this->getLoader();
254			$this->partialConfig = $loader->getPartialConfig($loadExternalConfig);
255			}
256
257			/**
258			* Get names of sub-folders to be scanned during Magento detection
259			*
260			* @return array
261			*/
262			public function getDetectSubFolders()
263			{
264			if (isset($this->partialConfig['detect']['subFolders'])) {
265			return $this->partialConfig['detect']['subFolders'];
266			}
267
268			return array();
269			}
270
271			/**
272			* @param array $initConfig
273			* @param bool $isPharMode
274			* @param OutputInterface $output
275			*
276			* @return ConfigurationLoader
277			*/
278			public function createLoader(array $initConfig, $isPharMode, OutputInterface $output)
279			{
280			$config = ArrayFunctions::mergeArrays($this->config, $initConfig);
281
282			$loader = new ConfigurationLoader($config, $isPharMode, $output);
283
284			return $loader;
285			}
286
287			/**
288			* @param string $message
289			*/
290			private function debugWriteln($message)
291			{
292			$output = $this->output;
293			if (OutputInterface::VERBOSITY_DEBUG <= $output->getVerbosity()) {
294			$output->writeln($message);
295			}
296			}
297
298			/**
299			* Get array from config, default to an empty array if not set
300			*
301			* @param string\|array $key
302			* @param array $default [optional]
303			* @return array
304			*/
305			private function getArray($key, $default = array())
306			{
307			$result = $this->traverse((array) $key);
308			if (null === $result) {
309			return $default;
310			}
311
312			return $result;
313			}
314
315			private function traverse(array $keys)
			0 ignored issues – show Documentation introduced 2016-07-17 23:11 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
316			{
317			$anchor = &$this->config;
318			foreach ($keys as $key) {
319			if (!is_array($anchor)) {
320			return;
321			}
322
323			if (!isset($anchor[$key])) {
324			return;
325			}
326			$anchor = &$anchor[$key];
327			}
328
329			return $anchor;
330			}
331			}
332

netz98 / n98-magerun2

Push — develop ( 272892...d423fe )

Config B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

18 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like