RulesetXmlToSniffsFactory - Code Metrics - Inspection of "Merge pull request #11 from Symplify/ruleset" - Symplify/PHP7_CodeSniffer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 393329...74ff7b )

by Tomáš

created 2016-08-19 09:32 UTC

RulesetXmlToSniffsFactory A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	113
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

92.5%

Importance

Changes

Metric	Value
wmc	14
lcom	1
cbo	8
dl	0
loc	113
ccs	37
cts	40
cp	0.925
rs	10
c	0
b	0
f	0

6 Methods

Rating	Name	Size	Complexity
A	__construct()	11	1
A	isMatch()	4	1
A	create()	18	3
A	setSniffSetFactory()	4	1
A	isRuleXmlElementSkipped()	16	4
A	createSniffsFromOwnRuleset()	19	4

<?php

/*
 * This file is part of Symplify
 * Copyright (c) 2016 Tomas Votruba (http://tomasvotruba.cz).
 */

namespace Symplify\PHP7_CodeSniffer\Sniff\Factory;

use Nette\Utils\Strings;
use PHP_CodeSniffer\Sniffs\Sniff;
use SimpleXMLElement;
use Symplify\PHP7_CodeSniffer\Contract\Sniff\Factory\SniffFactoryInterface;
use Symplify\PHP7_CodeSniffer\Contract\Sniff\SniffSetFactoryAwareInterface;
use Symplify\PHP7_CodeSniffer\Sniff\Finder\SniffFinder;
use Symplify\PHP7_CodeSniffer\Sniff\Naming\SniffNaming;
use Symplify\PHP7_CodeSniffer\Sniff\SniffSetFactory;
use Symplify\PHP7_CodeSniffer\Sniff\Sorter\SniffSorter;
use Symplify\PHP7_CodeSniffer\Sniff\Xml\DataCollector\SniffPropertyValueDataCollector;
use Symplify\PHP7_CodeSniffer\Sniff\Xml\DataCollector\ExcludedSniffDataCollector;

final class RulesetXmlToSniffsFactory implements
    SniffFactoryInterface,
    SniffSetFactoryAwareInterface
{
    /**
     * @var ExcludedSniffDataCollector
     */
    private $excludedSniffDataCollector;

    /**
     * @var SniffPropertyValueDataCollector
     */
    private $customSniffPropertyDataCollector;

    /**
     * @var SniffSetFactory
     */
    private $sniffSetFactory;

    /**
     * @var SniffFinder
     */
    private $sniffFinder;

    /**
     * @var SingleSniffFactory
     */
    private $singleSniffFactory;

    public function __construct(
        SniffFinder $sniffFinder,
        ExcludedSniffDataCollector $excludedSniffDataCollector,
        SniffPropertyValueDataCollector $customSniffPropertyDataCollector,
        SingleSniffFactory $singleSniffFactory
    ) {
        $this->sniffFinder = $sniffFinder;
        $this->customSniffPropertyDataCollector = $customSniffPropertyDataCollector;
        $this->excludedSniffDataCollector = $excludedSniffDataCollector;
        $this->singleSniffFactory = $singleSniffFactory;
    }

    public function isMatch(string $reference) : bool
    {
        return Strings::endsWith($reference, 'ruleset.xml');
    }

    /**
     * @return Sniff[]
     */
    public function create(string $rulesetXmlFile) : array
    {
        $sniffs = $this->createSniffsFromOwnRuleset($rulesetXmlFile);

        $rulesetXml = simplexml_load_file($rulesetXmlFile);
        foreach ($rulesetXml->rule as $ruleXmlElement) {
            if ($this->isRuleXmlElementSkipped($ruleXmlElement)) {
                continue;
            }

            $this->excludedSniffDataCollector->collectFromRuleXmlElement($ruleXmlElement);
            $this->customSniffPropertyDataCollector->collectFromRuleXmlElement($ruleXmlElement);

            $sniffs = array_merge($sniffs, $this->sniffSetFactory->create($ruleXmlElement['ref']));
        }

        return SniffSorter::sort($sniffs);
    }

    public function setSniffSetFactory(SniffSetFactory $sniffSetFactory)
    {
        $this->sniffSetFactory = $sniffSetFactory;
    }

    private function isRuleXmlElementSkipped(SimpleXMLElement $ruleXmlElement) : bool
    {
        if (!isset($ruleXmlElement['ref'])) {
            return true;
        }

        if (isset($ruleXmlElement->severity)) {
            if (SniffNaming::isSniffCode($ruleXmlElement['ref'])) {
                return true;
            }

            return false;
        }

        return false;
    }

    /**
     * @return Sniff[]
     */
    private function createSniffsFromOwnRuleset(string $rulesetXmlFile) : array
    {
        $rulesetDir = dirname($rulesetXmlFile);
        $sniffDir = $rulesetDir.DIRECTORY_SEPARATOR.'Sniffs';
        if (!is_dir($sniffDir)) {
            return [];
        }

        $sniffClassNames = $this->sniffFinder->findAllSniffClassesInDirectory($sniffDir);

        $sniffs = [];
        foreach ($sniffClassNames as $sniffClassName) {
            if ($sniff = $this->singleSniffFactory->create($sniffClassName)) {
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
                $sniffs[] = $sniff;
            }
        }

        return $sniffs;
    }
}


1		<?php
2
3		/*
4		* This file is part of Symplify
5		* Copyright (c) 2016 Tomas Votruba (http://tomasvotruba.cz).
6		*/
7
8		namespace Symplify\PHP7_CodeSniffer\Sniff\Factory;
9
10		use Nette\Utils\Strings;
11		use PHP_CodeSniffer\Sniffs\Sniff;
12		use SimpleXMLElement;
13		use Symplify\PHP7_CodeSniffer\Contract\Sniff\Factory\SniffFactoryInterface;
14		use Symplify\PHP7_CodeSniffer\Contract\Sniff\SniffSetFactoryAwareInterface;
15		use Symplify\PHP7_CodeSniffer\Sniff\Finder\SniffFinder;
16		use Symplify\PHP7_CodeSniffer\Sniff\Naming\SniffNaming;
17		use Symplify\PHP7_CodeSniffer\Sniff\SniffSetFactory;
18		use Symplify\PHP7_CodeSniffer\Sniff\Sorter\SniffSorter;
19		use Symplify\PHP7_CodeSniffer\Sniff\Xml\DataCollector\SniffPropertyValueDataCollector;
20		use Symplify\PHP7_CodeSniffer\Sniff\Xml\DataCollector\ExcludedSniffDataCollector;
21
22		final class RulesetXmlToSniffsFactory implements
23		SniffFactoryInterface,
24		SniffSetFactoryAwareInterface
25		{
26		/**
27		* @var ExcludedSniffDataCollector
28		*/
29		private $excludedSniffDataCollector;
30
31		/**
32		* @var SniffPropertyValueDataCollector
33		*/
34		private $customSniffPropertyDataCollector;
35
36		/**
37		* @var SniffSetFactory
38		*/
39		private $sniffSetFactory;
40
41		/**
42		* @var SniffFinder
43		*/
44		private $sniffFinder;
45
46		/**
47		* @var SingleSniffFactory
48		*/
49		private $singleSniffFactory;
50
51	1	public function __construct(
52		SniffFinder $sniffFinder,
53		ExcludedSniffDataCollector $excludedSniffDataCollector,
54		SniffPropertyValueDataCollector $customSniffPropertyDataCollector,
55		SingleSniffFactory $singleSniffFactory
56		) {
57	1	$this->sniffFinder = $sniffFinder;
58	1	$this->customSniffPropertyDataCollector = $customSniffPropertyDataCollector;
59	1	$this->excludedSniffDataCollector = $excludedSniffDataCollector;
60	1	$this->singleSniffFactory = $singleSniffFactory;
61	1	}
62
63	7	public function isMatch(string $reference) : bool
64		{
65	7	return Strings::endsWith($reference, 'ruleset.xml');
66		}
67
68		/**
69		* @return Sniff[]
70		*/
71	6	public function create(string $rulesetXmlFile) : array
72		{
73	6	$sniffs = $this->createSniffsFromOwnRuleset($rulesetXmlFile);
74
75	6	$rulesetXml = simplexml_load_file($rulesetXmlFile);
76	6	foreach ($rulesetXml->rule as $ruleXmlElement) {
77	6	if ($this->isRuleXmlElementSkipped($ruleXmlElement)) {
78		continue;
79		}
80
81	6	$this->excludedSniffDataCollector->collectFromRuleXmlElement($ruleXmlElement);
82	6	$this->customSniffPropertyDataCollector->collectFromRuleXmlElement($ruleXmlElement);
83
84	6	$sniffs = array_merge($sniffs, $this->sniffSetFactory->create($ruleXmlElement['ref']));
85		}
86
87	6	return SniffSorter::sort($sniffs);
88		}
89
90	10	public function setSniffSetFactory(SniffSetFactory $sniffSetFactory)
91		{
92	10	$this->sniffSetFactory = $sniffSetFactory;
93	10	}
94
95	6	private function isRuleXmlElementSkipped(SimpleXMLElement $ruleXmlElement) : bool
96		{
97	6	if (!isset($ruleXmlElement['ref'])) {
98		return true;
99		}
100
101	6	if (isset($ruleXmlElement->severity)) {
102	6	if (SniffNaming::isSniffCode($ruleXmlElement['ref'])) {
103		return true;
104		}
105
106	6	return false;
107		}
108
109	6	return false;
110		}
111
112		/**
113		* @return Sniff[]
114		*/
115	6	private function createSniffsFromOwnRuleset(string $rulesetXmlFile) : array
116		{
117	6	$rulesetDir = dirname($rulesetXmlFile);
118	6	$sniffDir = $rulesetDir.DIRECTORY_SEPARATOR.'Sniffs';
119	6	if (!is_dir($sniffDir)) {
120	1	return [];
121		}
122
123	6	$sniffClassNames = $this->sniffFinder->findAllSniffClassesInDirectory($sniffDir);
124
125	6	$sniffs = [];
126	6	foreach ($sniffClassNames as $sniffClassName) {
127	6	if ($sniff = $this->singleSniffFactory->create($sniffClassName)) {
		0 ignored issues – show Bug introduced 2016-08-19 09:42 UTC by Report Bug Copy Issue Report Are you sure the assignment to `$sniff` is correct as `$this->singleSniffFactor...create($sniffClassName)` (which targets `Symplify\PHP7_CodeSniffe...eSniffFactory::create()`) seems to always return null. This check looks for function or method calls that always return null and whose return value is assigned to a variable. class A { function getObject() { return null; } } $a = new A(); $object = $a->getObject(); The method `getObject()` can return nothing but null, so it makes no sense to assign that value to a variable. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
128	6	$sniffs[] = $sniff;
129		}
130		}
131
132	6	return $sniffs;
133		}
134		}
135

Symplify / PHP7_CodeSniffer

Push — master ( 393329...74ff7b )

RulesetXmlToSniffsFactory A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

6 Methods

Duplication Side-by-Side

Filter issues like