PHP_CodeCoverage_Report_Clover::process() - Code Metrics - Inspection of "readme" - p6naveen/project-1 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 95acd7...e70d94 )

by Naveen

created 2016-02-13 10:58 UTC

PHP_CodeCoverage_Report_Clover::process() F

↳ Parent: Project

Complexity

Conditions	26
Paths	> 20000

Size

Total Lines	260
Code Lines	169

Duplication

Lines	33
Ratio	12.69 %

Metric	Value
dl	33
loc	260
rs	2
cc	26
eloc	169
nc	69402
nop	3

How to fix Long Method Complexity

<?php
/*
 * This file is part of the PHP_CodeCoverage package.
 *
 * (c) Sebastian Bergmann <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

/**
 * Generates a Clover XML logfile from an PHP_CodeCoverage object.
 *
 * @since Class available since Release 1.0.0
 */
class PHP_CodeCoverage_Report_Clover
{
    /**
     * @param  PHP_CodeCoverage $coverage
     * @param  string           $target
     * @param  string           $name
     * @return string
     */
    public function process(PHP_CodeCoverage $coverage, $target = null, $name = null)
    {
        $xmlDocument               = new DOMDocument('1.0', 'UTF-8');
        $xmlDocument->formatOutput = true;

        $xmlCoverage = $xmlDocument->createElement('coverage');
        $xmlCoverage->setAttribute('generated', (int) $_SERVER['REQUEST_TIME']);
        $xmlDocument->appendChild($xmlCoverage);

        $xmlProject = $xmlDocument->createElement('project');
        $xmlProject->setAttribute('timestamp', (int) $_SERVER['REQUEST_TIME']);

        if (is_string($name)) {
            $xmlProject->setAttribute('name', $name);
        }

        $xmlCoverage->appendChild($xmlProject);

        $packages = array();
        $report   = $coverage->getReport();
        unset($coverage);

        foreach ($report as $item) {
            $namespace = 'global';

            if (!$item instanceof PHP_CodeCoverage_Report_Node_File) {
                continue;
            }

            $xmlFile = $xmlDocument->createElement('file');
            $xmlFile->setAttribute('name', $item->getPath());

            $classes  = $item->getClassesAndTraits();
            $coverage = $item->getCoverageData();
            $lines    = array();

            foreach ($classes as $className => $class) {
                $classStatements        = 0;
                $coveredClassStatements = 0;
                $coveredMethods         = 0;
                $classMethods           = 0;

                foreach ($class['methods'] as $methodName => $method) {
                    if ($method['executableLines']  == 0) {
                        continue;
                    }

                    $classMethods++;
                    $classStatements        += $method['executableLines'];
                    $coveredClassStatements += $method['executedLines'];
                    if ($method['coverage'] == 100) {
                        $coveredMethods++;
                    }

                    $methodCount = 0;
                    for ($i  = $method['startLine'];
                         $i <= $method['endLine'];
                         $i++) {
                        if (isset($coverage[$i]) && ($coverage[$i] !== null)) {
                            $methodCount = max($methodCount, count($coverage[$i]));
                        }
                    }

                    $lines[$method['startLine']] = array(
                        'count' => $methodCount,
                        'crap'  => $method['crap'],
                        'type'  => 'method',
                        'name'  => $methodName
                    );
                }

                if (!empty($class['package']['namespace'])) {
                    $namespace = $class['package']['namespace'];
                }

                $xmlClass = $xmlDocument->createElement('class');
                $xmlClass->setAttribute('name', $className);
                $xmlClass->setAttribute('namespace', $namespace);

                if (!empty($class['package']['fullPackage'])) {
                    $xmlClass->setAttribute(
                        'fullPackage',
                        $class['package']['fullPackage']
                    );
                }

                if (!empty($class['package']['category'])) {
                    $xmlClass->setAttribute(
                        'category',
                        $class['package']['category']
                    );
                }

                if (!empty($class['package']['package'])) {
                    $xmlClass->setAttribute(
                        'package',
                        $class['package']['package']
                    );
                }

                if (!empty($class['package']['subpackage'])) {
                    $xmlClass->setAttribute(
                        'subpackage',
                        $class['package']['subpackage']
                    );
                }

                $xmlFile->appendChild($xmlClass);

                $xmlMetrics = $xmlDocument->createElement('metrics');
                $xmlMetrics->setAttribute('methods', $classMethods);
                $xmlMetrics->setAttribute('coveredmethods', $coveredMethods);
                $xmlMetrics->setAttribute('conditionals', 0);
                $xmlMetrics->setAttribute('coveredconditionals', 0);
                $xmlMetrics->setAttribute('statements', $classStatements);
                $xmlMetrics->setAttribute(
                    'coveredstatements',
                    $coveredClassStatements
                );
                $xmlMetrics->setAttribute(
                    'elements',
                    $classMethods +
                    $classStatements
                    /* + conditionals */
                );
                $xmlMetrics->setAttribute(
                    'coveredelements',
                    $coveredMethods +
                    $coveredClassStatements
                    /* + coveredconditionals */
                );
                $xmlClass->appendChild($xmlMetrics);
            }

            foreach ($coverage as $line => $data) {
                if ($data === null || isset($lines[$line])) {
                    continue;
                }

                $lines[$line] = array(
                    'count' => count($data), 'type' => 'stmt'
                );
            }

            ksort($lines);

            foreach ($lines as $line => $data) {
                $xmlLine = $xmlDocument->createElement('line');
                $xmlLine->setAttribute('num', $line);
                $xmlLine->setAttribute('type', $data['type']);

                if (isset($data['name'])) {
                    $xmlLine->setAttribute('name', $data['name']);
                }

                if (isset($data['crap'])) {
                    $xmlLine->setAttribute('crap', $data['crap']);
                }

                $xmlLine->setAttribute('count', $data['count']);
                $xmlFile->appendChild($xmlLine);
            }

            $linesOfCode = $item->getLinesOfCode();

            $xmlMetrics = $xmlDocument->createElement('metrics');
            $xmlMetrics->setAttribute('loc', $linesOfCode['loc']);
            $xmlMetrics->setAttribute('ncloc', $linesOfCode['ncloc']);
            $xmlMetrics->setAttribute('classes', $item->getNumClassesAndTraits());
            $xmlMetrics->setAttribute('methods', $item->getNumMethods());
            $xmlMetrics->setAttribute(
                'coveredmethods',
                $item->getNumTestedMethods()
            );
            $xmlMetrics->setAttribute('conditionals', 0);
            $xmlMetrics->setAttribute('coveredconditionals', 0);
            $xmlMetrics->setAttribute(
                'statements',
                $item->getNumExecutableLines()
            );
            $xmlMetrics->setAttribute(
                'coveredstatements',
                $item->getNumExecutedLines()
            );
            $xmlMetrics->setAttribute(
                'elements',
                $item->getNumMethods() + $item->getNumExecutableLines()
                /* + conditionals */
            );
            $xmlMetrics->setAttribute(
                'coveredelements',
                $item->getNumTestedMethods() + $item->getNumExecutedLines()
                /* + coveredconditionals */
            );
            $xmlFile->appendChild($xmlMetrics);

            if ($namespace == 'global') {
                $xmlProject->appendChild($xmlFile);
            } else {
                if (!isset($packages[$namespace])) {
                    $packages[$namespace] = $xmlDocument->createElement(
                        'package'
                    );

                    $packages[$namespace]->setAttribute('name', $namespace);
                    $xmlProject->appendChild($packages[$namespace]);
                }

                $packages[$namespace]->appendChild($xmlFile);
            }
        }

        $linesOfCode = $report->getLinesOfCode();

        $xmlMetrics = $xmlDocument->createElement('metrics');
        $xmlMetrics->setAttribute('files', count($report));
        $xmlMetrics->setAttribute('loc', $linesOfCode['loc']);
        $xmlMetrics->setAttribute('ncloc', $linesOfCode['ncloc']);
        $xmlMetrics->setAttribute(
            'classes',
            $report->getNumClassesAndTraits()
        );
        $xmlMetrics->setAttribute('methods', $report->getNumMethods());
        $xmlMetrics->setAttribute(
            'coveredmethods',
            $report->getNumTestedMethods()
        );
        $xmlMetrics->setAttribute('conditionals', 0);
        $xmlMetrics->setAttribute('coveredconditionals', 0);
        $xmlMetrics->setAttribute(
            'statements',
            $report->getNumExecutableLines()
        );
        $xmlMetrics->setAttribute(
            'coveredstatements',
            $report->getNumExecutedLines()
        );
        $xmlMetrics->setAttribute(
            'elements',
            $report->getNumMethods() + $report->getNumExecutableLines()
            /* + conditionals */
        );
        $xmlMetrics->setAttribute(
            'coveredelements',
            $report->getNumTestedMethods() + $report->getNumExecutedLines()
            /* + coveredconditionals */
        );

        $xmlProject->appendChild($xmlMetrics);

        if ($target !== null) {
            if (!is_dir(dirname($target))) {
                mkdir(dirname($target), 0777, true);
            }

            return $xmlDocument->save($target);
        } else {
            return $xmlDocument->saveXML();
        }
    }
}


1			<?php
2			/*
3			* This file is part of the PHP_CodeCoverage package.
4			*
5			* (c) Sebastian Bergmann <[email protected]>
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10
11			/**
12			* Generates a Clover XML logfile from an PHP_CodeCoverage object.
13			*
14			* @since Class available since Release 1.0.0
15			*/
16			class PHP_CodeCoverage_Report_Clover
17			{
18			/**
19			* @param PHP_CodeCoverage $coverage
20			* @param string $target
21			* @param string $name
22			* @return string
23			*/
24			public function process(PHP_CodeCoverage $coverage, $target = null, $name = null)
25			{
26			$xmlDocument = new DOMDocument('1.0', 'UTF-8');
27			$xmlDocument->formatOutput = true;
28
29			$xmlCoverage = $xmlDocument->createElement('coverage');
30			$xmlCoverage->setAttribute('generated', (int) $_SERVER['REQUEST_TIME']);
31			$xmlDocument->appendChild($xmlCoverage);
32
33			$xmlProject = $xmlDocument->createElement('project');
34			$xmlProject->setAttribute('timestamp', (int) $_SERVER['REQUEST_TIME']);
35
36			if (is_string($name)) {
37			$xmlProject->setAttribute('name', $name);
38			}
39
40			$xmlCoverage->appendChild($xmlProject);
41
42			$packages = array();
43			$report = $coverage->getReport();
44			unset($coverage);
45
46			foreach ($report as $item) {
47			$namespace = 'global';
48
49			if (!$item instanceof PHP_CodeCoverage_Report_Node_File) {
50			continue;
51			}
52
53			$xmlFile = $xmlDocument->createElement('file');
54			$xmlFile->setAttribute('name', $item->getPath());
55
56			$classes = $item->getClassesAndTraits();
57			$coverage = $item->getCoverageData();
58			$lines = array();
59
60			foreach ($classes as $className => $class) {
61			$classStatements = 0;
62			$coveredClassStatements = 0;
63			$coveredMethods = 0;
64			$classMethods = 0;
65
66			foreach ($class['methods'] as $methodName => $method) {
67			if ($method['executableLines'] == 0) {
68			continue;
69			}
70
71			$classMethods++;
72			$classStatements += $method['executableLines'];
73			$coveredClassStatements += $method['executedLines'];
74			if ($method['coverage'] == 100) {
75			$coveredMethods++;
76			}
77
78			$methodCount = 0;
79			for ($i = $method['startLine'];
80			$i <= $method['endLine'];
81			$i++) {
82			if (isset($coverage[$i]) && ($coverage[$i] !== null)) {
83			$methodCount = max($methodCount, count($coverage[$i]));
84			}
85			}
86
87			$lines[$method['startLine']] = array(
88			'count' => $methodCount,
89			'crap' => $method['crap'],
90			'type' => 'method',
91			'name' => $methodName
92			);
93			}
94
95			if (!empty($class['package']['namespace'])) {
96			$namespace = $class['package']['namespace'];
97			}
98
99			$xmlClass = $xmlDocument->createElement('class');
100			$xmlClass->setAttribute('name', $className);
101			$xmlClass->setAttribute('namespace', $namespace);
102
103			if (!empty($class['package']['fullPackage'])) {
104			$xmlClass->setAttribute(
105			'fullPackage',
106			$class['package']['fullPackage']
107			);
108			}
109
110			if (!empty($class['package']['category'])) {
111			$xmlClass->setAttribute(
112			'category',
113			$class['package']['category']
114			);
115			}
116
117			if (!empty($class['package']['package'])) {
118			$xmlClass->setAttribute(
119			'package',
120			$class['package']['package']
121			);
122			}
123
124			if (!empty($class['package']['subpackage'])) {
125			$xmlClass->setAttribute(
126			'subpackage',
127			$class['package']['subpackage']
128			);
129			}
130
131			$xmlFile->appendChild($xmlClass);
132
133			$xmlMetrics = $xmlDocument->createElement('metrics');
134			$xmlMetrics->setAttribute('methods', $classMethods);
135			$xmlMetrics->setAttribute('coveredmethods', $coveredMethods);
136			$xmlMetrics->setAttribute('conditionals', 0);
137			$xmlMetrics->setAttribute('coveredconditionals', 0);
138			$xmlMetrics->setAttribute('statements', $classStatements);
139			$xmlMetrics->setAttribute(
140			'coveredstatements',
141			$coveredClassStatements
142			);
143			$xmlMetrics->setAttribute(
144			'elements',
145			$classMethods +
146			$classStatements
147			/* + conditionals */
148			);
149			$xmlMetrics->setAttribute(
150			'coveredelements',
151			$coveredMethods +
152			$coveredClassStatements
153			/* + coveredconditionals */
154			);
155			$xmlClass->appendChild($xmlMetrics);
156			}
157
158			foreach ($coverage as $line => $data) {
159			if ($data === null \|\| isset($lines[$line])) {
160			continue;
161			}
162
163			$lines[$line] = array(
164			'count' => count($data), 'type' => 'stmt'
165			);
166			}
167
168			ksort($lines);
169
170			foreach ($lines as $line => $data) {
171			$xmlLine = $xmlDocument->createElement('line');
172			$xmlLine->setAttribute('num', $line);
173			$xmlLine->setAttribute('type', $data['type']);
174
175			if (isset($data['name'])) {
176			$xmlLine->setAttribute('name', $data['name']);
177			}
178
179			if (isset($data['crap'])) {
180			$xmlLine->setAttribute('crap', $data['crap']);
181			}
182
183			$xmlLine->setAttribute('count', $data['count']);
184			$xmlFile->appendChild($xmlLine);
185			}
186
187			$linesOfCode = $item->getLinesOfCode();
188
189			$xmlMetrics = $xmlDocument->createElement('metrics');
190			$xmlMetrics->setAttribute('loc', $linesOfCode['loc']);
191			$xmlMetrics->setAttribute('ncloc', $linesOfCode['ncloc']);
192			$xmlMetrics->setAttribute('classes', $item->getNumClassesAndTraits());
193			$xmlMetrics->setAttribute('methods', $item->getNumMethods());
194			$xmlMetrics->setAttribute(
195			'coveredmethods',
196			$item->getNumTestedMethods()
197			);
198			$xmlMetrics->setAttribute('conditionals', 0);
199			$xmlMetrics->setAttribute('coveredconditionals', 0);
200			$xmlMetrics->setAttribute(
201			'statements',
202			$item->getNumExecutableLines()
203			);
204			$xmlMetrics->setAttribute(
205			'coveredstatements',
206			$item->getNumExecutedLines()
207			);
208			$xmlMetrics->setAttribute(
209			'elements',
210			$item->getNumMethods() + $item->getNumExecutableLines()
211			/* + conditionals */
212			);
213			$xmlMetrics->setAttribute(
214			'coveredelements',
215			$item->getNumTestedMethods() + $item->getNumExecutedLines()
216			/* + coveredconditionals */
217			);
218			$xmlFile->appendChild($xmlMetrics);
219
220			if ($namespace == 'global') {
221			$xmlProject->appendChild($xmlFile);
222			} else {
223			if (!isset($packages[$namespace])) {
224			$packages[$namespace] = $xmlDocument->createElement(
225			'package'
226			);
227
228			$packages[$namespace]->setAttribute('name', $namespace);
229			$xmlProject->appendChild($packages[$namespace]);
230			}
231
232			$packages[$namespace]->appendChild($xmlFile);
233			}
234			}
235
236			$linesOfCode = $report->getLinesOfCode();
237
238			$xmlMetrics = $xmlDocument->createElement('metrics');
239			$xmlMetrics->setAttribute('files', count($report));
240			$xmlMetrics->setAttribute('loc', $linesOfCode['loc']);
241			$xmlMetrics->setAttribute('ncloc', $linesOfCode['ncloc']);
242			$xmlMetrics->setAttribute(
243			'classes',
244			$report->getNumClassesAndTraits()
245			);
246			$xmlMetrics->setAttribute('methods', $report->getNumMethods());
247			$xmlMetrics->setAttribute(
248			'coveredmethods',
249			$report->getNumTestedMethods()
250			);
251			$xmlMetrics->setAttribute('conditionals', 0);
252			$xmlMetrics->setAttribute('coveredconditionals', 0);
253			$xmlMetrics->setAttribute(
254			'statements',
255			$report->getNumExecutableLines()
256			);
257			$xmlMetrics->setAttribute(
258			'coveredstatements',
259			$report->getNumExecutedLines()
260			);
261			$xmlMetrics->setAttribute(
262			'elements',
263			$report->getNumMethods() + $report->getNumExecutableLines()
264			/* + conditionals */
265			);
266			$xmlMetrics->setAttribute(
267			'coveredelements',
268			$report->getNumTestedMethods() + $report->getNumExecutedLines()
269			/* + coveredconditionals */
270			);
271
272			$xmlProject->appendChild($xmlMetrics);
273
274			if ($target !== null) {
275			if (!is_dir(dirname($target))) {
276			mkdir(dirname($target), 0777, true);
277			}
278
279			return $xmlDocument->save($target);
280			} else {
281			return $xmlDocument->saveXML();
282			}
283			}
284			}
285

p6naveen / project-1

Push — master ( 95acd7...e70d94 )

PHP_CodeCoverage_Report_Clover::process() F

Complexity

Size

Duplication

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like