ConflictsCommand::execute() - Code Metrics - Inspection of "Resolves #523" - netz98/n98-magerun - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — develop (#528)

by Steve

created 2016-01-08 09:22 UTC

ConflictsCommand::execute() C

↳ Parent: ConflictsCommand

Complexity

Conditions	12
Paths	20

Size

Total Lines	48
Code Lines	34

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	48
rs	5.1267
cc	12
eloc	34
nc	20
nop	2

How to fix Complexity

<?php

namespace N98\Magento\Command\Developer\Module\Rewrite;

use Exception;
use N98\JUnitXml\Document as JUnitXmlDocument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

class ConflictsCommand extends AbstractRewriteCommand
{
    protected function configure()
    {
        $this
            ->setName('dev:module:rewrite:conflicts')
            ->addOption('log-junit', null, InputOption::VALUE_REQUIRED, 'Log conflicts in JUnit XML format to defined file.')

            ->setDescription('Lists all magento rewrite conflicts')
        ;

        $help = <<<HELP
Lists all duplicated rewrites and tells you which class is loaded by Magento.
The command checks class inheritance in order of your module dependencies.

* If a filename with `--log-junit` option is set the tool generates an XML file and no output to *stdout*.
HELP;
        $this->setHelp($help);
    }

    /**
     * @param InputInterface  $input
     * @param OutputInterface $output
     *
     * @return int|void
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->detectMagento($output, true);
        if ($this->initMagento()) {
            $table = new \Zend_Text_Table(array('columnWidths' => array(8, 30, 60, 60)));
            $tableData = array();
            if ($this->initMagento()) {
                $time = microtime(true);
                $rewrites = $this->loadRewrites();
                $conflictCounter = 0;
                foreach ($rewrites as $type => $data) {
                    if (count($data) > 0 && is_array($data)) {
                        foreach ($data as $class => $rewriteClass) {
                            if (count($rewriteClass) > 1) {
                                if ($this->_isInheritanceConflict($rewriteClass)) {
                                    $tableData[] = array(
                                        'Type'         => $type,
                                        'Class'        => $class,
                                        'Rewrites'     => implode(', ', $rewriteClass),
                                        'Loaded Class' => $this->_getLoadedClass($type, $class),
                                    );
                                    $conflictCounter++;
                                }
                            }
                        }
                    }
                }

                if ($input->getOption('log-junit')) {
                    $this->logJUnit($tableData, $input->getOption('log-junit'), microtime($time) - $time);
                } else {
                    if ($conflictCounter > 0) {
                        array_map(array($table, 'appendRow'), $tableData);
                        $output->write($table->render());
                        $message = sprintf(
                            '%d %s found!',
                            $conflictCounter,
                            $conflictCounter == 1 ? 'conflict was' : 'conflicts were'
                        );
                        $output->writeln('<error>' . $message . '</error>');
                        return 1;
                    } else {
                        $output->writeln('<info>No rewrite conflicts were found.</info>');
                    }
                }
            }
        }
    }

    /**
     * Returns loaded class by type like models or blocks
     *
     * @param string $type
     * @param string $class
     * @return string
     */
    protected function _getLoadedClass($type, $class)
    {
        switch ($type) {
            case 'blocks':
                return \Mage::getConfig()->getBlockClassName($class);

            case 'helpers':
                return \Mage::getConfig()->getHelperClassName($class);

            default:
            case 'models':
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
                return \Mage::getConfig()->getModelClassName($class);
                break;
        }
    }

    /**
     * @param array $conflicts
     * @param string $filename
     * @param float $duration
     */
    protected function logJUnit(array $conflicts, $filename, $duration)
    {
        $document = new JUnitXmlDocument();
        $suite = $document->addTestSuite();
        $suite->setName('n98-magerun: ' . $this->getName());
        $suite->setTimestamp(new \DateTime());
        $suite->setTime($duration);

        $testCase = $suite->addTestCase();
        $testCase->setName('Magento Rewrite Conflict Test');
        $testCase->setClassname('ConflictsCommand');
        if (count($conflicts) > 0) {
            foreach ($conflicts as $conflictRow) {
                $testCase->addFailure(
                    sprintf(
                        'Rewrite conflict: Type %s | Class: %s, Rewrites: %s | Loaded class: %s',
                        $conflictRow['Type'],
                        $conflictRow['Class'],
                        $conflictRow['Rewrites'],
                        $conflictRow['Loaded Class']
                    ),
                    'MagentoRewriteConflictException'
                );
            }
        }

        $document->save($filename);
    }

    /**
     * Check if rewritten class has inherited the parent class.
     * If yes we have no conflict. The top class can extend every core class.
     * So we cannot check this.
     *
     * @param  array $classes
     * @return bool
     */
    protected function _isInheritanceConflict(array $classes)
    {
        $classes = array_reverse($classes);
        $count   = count($classes) - 1;
        for ($i = 0; $i < $count; $i++) {
            try {
                if (class_exists($classes[$i])
                    && class_exists($classes[$i + 1])
                ) {
                    return !$this->_isClassInstanceOf(
                        $classes[$i],
                        $classes[$i + 1]
                    );
                }
            } catch (Exception $e) {
                return true;
            }
        }

        return false;
    }

    /**
     * Check if a classA is an instance of classB
     *
     * @param  object|string  $classA
     * @param  object|string  $classB
     * @return boolean
     */
    private function _isClassInstanceOf($classA, $classB)
    {
        if (is_string($classA)) {
            $classA = new $classA;
        }
        $reflectionB = new \ReflectionClass($classB);
        return $reflectionB->isInstance($classA);
    }
}


1			<?php
2
3			namespace N98\Magento\Command\Developer\Module\Rewrite;
4
5			use Exception;
6			use N98\JUnitXml\Document as JUnitXmlDocument;
7			use Symfony\Component\Console\Input\InputInterface;
8			use Symfony\Component\Console\Input\InputOption;
9			use Symfony\Component\Console\Output\OutputInterface;
10
11			class ConflictsCommand extends AbstractRewriteCommand
12			{
13			protected function configure()
14			{
15			$this
16			->setName('dev:module:rewrite:conflicts')
17			->addOption('log-junit', null, InputOption::VALUE_REQUIRED, 'Log conflicts in JUnit XML format to defined file.')
			0 ignored issues – show Coding Style introduced 2015-11-25 15:21 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 120 characters; contains 125 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
18			->setDescription('Lists all magento rewrite conflicts')
19			;
20
21			$help = <<<HELP
22			Lists all duplicated rewrites and tells you which class is loaded by Magento.
23			The command checks class inheritance in order of your module dependencies.
24
25			* If a filename with `--log-junit` option is set the tool generates an XML file and no output to stdout.
26			HELP;
27			$this->setHelp($help);
28			}
29
30			/**
31			* @param InputInterface $input
32			* @param OutputInterface $output
33			*
34			* @return int\|void
35			*/
36			protected function execute(InputInterface $input, OutputInterface $output)
37			{
38			$this->detectMagento($output, true);
39			if ($this->initMagento()) {
40			$table = new \Zend_Text_Table(array('columnWidths' => array(8, 30, 60, 60)));
41			$tableData = array();
42			if ($this->initMagento()) {
43			$time = microtime(true);
44			$rewrites = $this->loadRewrites();
45			$conflictCounter = 0;
46			foreach ($rewrites as $type => $data) {
47			if (count($data) > 0 && is_array($data)) {
48			foreach ($data as $class => $rewriteClass) {
49			if (count($rewriteClass) > 1) {
50			if ($this->_isInheritanceConflict($rewriteClass)) {
51			$tableData[] = array(
52			'Type' => $type,
53			'Class' => $class,
54			'Rewrites' => implode(', ', $rewriteClass),
55			'Loaded Class' => $this->_getLoadedClass($type, $class),
56			);
57			$conflictCounter++;
58			}
59			}
60			}
61			}
62			}
63
64			if ($input->getOption('log-junit')) {
65			$this->logJUnit($tableData, $input->getOption('log-junit'), microtime($time) - $time);
66			} else {
67			if ($conflictCounter > 0) {
68			array_map(array($table, 'appendRow'), $tableData);
69			$output->write($table->render());
70			$message = sprintf(
71			'%d %s found!',
72			$conflictCounter,
73			$conflictCounter == 1 ? 'conflict was' : 'conflicts were'
74			);
75			$output->writeln('<error>' . $message . '</error>');
76			return 1;
77			} else {
78			$output->writeln('<info>No rewrite conflicts were found.</info>');
79			}
80			}
81			}
82			}
83			}
84
85			/**
86			* Returns loaded class by type like models or blocks
87			*
88			* @param string $type
89			* @param string $class
90			* @return string
91			*/
92			protected function _getLoadedClass($type, $class)
93			{
94			switch ($type) {
95			case 'blocks':
96			return \Mage::getConfig()->getBlockClassName($class);
97
98			case 'helpers':
99			return \Mage::getConfig()->getHelperClassName($class);
100
101			default:
102			case 'models':
			0 ignored issues – show Unused Code introduced 2015-11-25 15:20 UTC by Report Bug Copy Issue Report `case 'models': retur...ame($class); break;` does not seem to be reachable. This check looks for unreachable code. It uses sophisticated control flow analysis techniques to find statements which will never be executed. Unreachable code is most often the result of `return`, `die` or `exit` statements that have been added for debug purposes. function fx() { try { doSomething(); return true; } catch (\Exception $e) { return false; } return false; } In the above example, the last `return false` will never be executed, because a return statement has already been met in every possible execution path. Loading history...
103			return \Mage::getConfig()->getModelClassName($class);
104			break;
105			}
106			}
107
108			/**
109			* @param array $conflicts
110			* @param string $filename
111			* @param float $duration
112			*/
113			protected function logJUnit(array $conflicts, $filename, $duration)
114			{
115			$document = new JUnitXmlDocument();
116			$suite = $document->addTestSuite();
117			$suite->setName('n98-magerun: ' . $this->getName());
118			$suite->setTimestamp(new \DateTime());
119			$suite->setTime($duration);
120
121			$testCase = $suite->addTestCase();
122			$testCase->setName('Magento Rewrite Conflict Test');
123			$testCase->setClassname('ConflictsCommand');
124			if (count($conflicts) > 0) {
125			foreach ($conflicts as $conflictRow) {
126			$testCase->addFailure(
127			sprintf(
128			'Rewrite conflict: Type %s \| Class: %s, Rewrites: %s \| Loaded class: %s',
129			$conflictRow['Type'],
130			$conflictRow['Class'],
131			$conflictRow['Rewrites'],
132			$conflictRow['Loaded Class']
133			),
134			'MagentoRewriteConflictException'
135			);
136			}
137			}
138
139			$document->save($filename);
140			}
141
142			/**
143			* Check if rewritten class has inherited the parent class.
144			* If yes we have no conflict. The top class can extend every core class.
145			* So we cannot check this.
146			*
147			* @param array $classes
148			* @return bool
149			*/
150			protected function _isInheritanceConflict(array $classes)
151			{
152			$classes = array_reverse($classes);
153			$count = count($classes) - 1;
154			for ($i = 0; $i < $count; $i++) {
155			try {
156			if (class_exists($classes[$i])
157			&& class_exists($classes[$i + 1])
158			) {
159			return !$this->_isClassInstanceOf(
160			$classes[$i],
161			$classes[$i + 1]
162			);
163			}
164			} catch (Exception $e) {
165			return true;
166			}
167			}
168
169			return false;
170			}
171
172			/**
173			* Check if a classA is an instance of classB
174			*
175			* @param object\|string $classA
176			* @param object\|string $classB
177			* @return boolean
178			*/
179			private function _isClassInstanceOf($classA, $classB)
180			{
181			if (is_string($classA)) {
182			$classA = new $classA;
183			}
184			$reflectionB = new \ReflectionClass($classB);
185			return $reflectionB->isInstance($classA);
186			}
187			}
188

netz98 / n98-magerun

Pull Request — develop (#528)

ConflictsCommand::execute() C

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like