Option::checkNaming() - Code Metrics - Inspection of "Check for named constants" - povils/phpmnd - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#86)

by Scott

created 2019-04-09 11:44 UTC

Option::checkNaming() A

↳ Parent: Option

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace Povils\PHPMND\Console;

use Povils\PHPMND\Extension\Extension;
use Povils\PHPMND\GenericLanguage;
use Povils\PHPMND\Language;

/**
 * @package Povils\PHPMND\Console
 */
class Option
{
    /**
     * @var Extension[]
     */
    private $extensions = [];

    /**
     * @var array
     */
    private $ignoreNumbers = [0, 0., 1];

    /**
     * @var array
     */
    private $ignoreFuncs = [
        'intval',
        'floatval',
        'strval',
    ];

    /**
     * @var array
     */
    private $ignoreStrings = ['', '0', '1'];

    /**
     * @var bool
     */
    private $includeStrings = false;

    /**
     * @var bool
     */
    private $giveHint = false;

    /**
     * @var bool
     */
    private $includeNumericStrings = false;

    /**
     * @var bool
     */
    private $allowArrayMapping = false;

    /**
     * @var array
     */
    private $checkNaming = [];

    public function setExtensions(array $extensions)
    {
        $this->extensions = $extensions;
    }

    public function getExtensions(): array
    {
        return $this->extensions;
    }

    public function setIgnoreNumbers(array $ignoreNumbers)
    {
        $this->ignoreNumbers = array_merge($this->ignoreNumbers, $ignoreNumbers);
    }

    public function getIgnoreNumbers(): array
    {
        return $this->ignoreNumbers;
    }

    public function setIgnoreFuncs(array $ignoreFuncs)
    {
        $this->ignoreFuncs = $ignoreFuncs;
    }

    public function getIgnoreFuncs(): array
    {
        return $this->ignoreFuncs;
    }

    public function includeStrings(): ?bool
    {
        return $this->includeStrings;
    }

    public function setIncludeStrings(?bool $includeStrings)
    {
        $this->includeStrings = $includeStrings;
    }

    public function getIgnoreStrings(): array
    {
        return $this->ignoreStrings;
    }

    public function setIgnoreStrings(array $ignoreStrings)
    {
        $this->ignoreStrings = array_merge($this->ignoreStrings, $ignoreStrings);
    }

    public function giveHint(): bool
    {
        return $this->giveHint;
    }

    public function setGiveHint(bool $giveHint)
    {
        $this->giveHint = $giveHint;
    }

    public function includeNumericStrings(): ?bool
    {
        return $this->includeNumericStrings;
    }

    public function setIncludeNumericStrings(?bool $includeNumericStrings)
    {
        $this->includeNumericStrings = $includeNumericStrings;
    }

    public function allowArrayMapping(): ?bool
    {
        return $this->allowArrayMapping;
    }

    public function setAllowArrayMapping(?bool $allowArrayMapping)
    {
        $this->allowArrayMapping = $allowArrayMapping;
    }

    /**
     * @return Language[]
     */
    public function checkNaming(): array
    {
        return $this->checkNaming;
    }

    public function setCheckNaming(array $checkNaming)
    {
        $languages = [];
        foreach ($checkNaming as $language) {
            $languages[] = $this->findLanguage($language);
        }
        $this->checkNaming = $languages;
    }

    protected function findLanguage($language): Language
    {
        foreach (scandir(__DIR__ . '/../Languages/') as $class) {
            $class = basename($class, '.php');
            $class = "Povils\PHPMND\Languages\\$class";
            if ((
                class_exists($class) &&
                is_subclass_of($class, Language::class) &&

                in_array($language, $class::providesLanguages())
            )) {
                return new $class($language);
            }
        }

        return new GenericLanguage($language);
    }
}


1			<?php
2
3			namespace Povils\PHPMND\Console;
4
5			use Povils\PHPMND\Extension\Extension;
6			use Povils\PHPMND\GenericLanguage;
7			use Povils\PHPMND\Language;
8
9			/**
10			* @package Povils\PHPMND\Console
11			*/
12			class Option
13			{
14			/**
15			* @var Extension[]
16			*/
17			private $extensions = [];
18
19			/**
20			* @var array
21			*/
22			private $ignoreNumbers = [0, 0., 1];
23
24			/**
25			* @var array
26			*/
27			private $ignoreFuncs = [
28			'intval',
29			'floatval',
30			'strval',
31			];
32
33			/**
34			* @var array
35			*/
36			private $ignoreStrings = ['', '0', '1'];
37
38			/**
39			* @var bool
40			*/
41			private $includeStrings = false;
42
43			/**
44			* @var bool
45			*/
46			private $giveHint = false;
47
48			/**
49			* @var bool
50			*/
51			private $includeNumericStrings = false;
52
53			/**
54			* @var bool
55			*/
56			private $allowArrayMapping = false;
57
58			/**
59			* @var array
60			*/
61			private $checkNaming = [];
62
63			public function setExtensions(array $extensions)
64			{
65			$this->extensions = $extensions;
66			}
67
68			public function getExtensions(): array
69			{
70			return $this->extensions;
71			}
72
73			public function setIgnoreNumbers(array $ignoreNumbers)
74			{
75			$this->ignoreNumbers = array_merge($this->ignoreNumbers, $ignoreNumbers);
76			}
77
78			public function getIgnoreNumbers(): array
79			{
80			return $this->ignoreNumbers;
81			}
82
83			public function setIgnoreFuncs(array $ignoreFuncs)
84			{
85			$this->ignoreFuncs = $ignoreFuncs;
86			}
87
88			public function getIgnoreFuncs(): array
89			{
90			return $this->ignoreFuncs;
91			}
92
93			public function includeStrings(): ?bool
94			{
95			return $this->includeStrings;
96			}
97
98			public function setIncludeStrings(?bool $includeStrings)
99			{
100			$this->includeStrings = $includeStrings;
101			}
102
103			public function getIgnoreStrings(): array
104			{
105			return $this->ignoreStrings;
106			}
107
108			public function setIgnoreStrings(array $ignoreStrings)
109			{
110			$this->ignoreStrings = array_merge($this->ignoreStrings, $ignoreStrings);
111			}
112
113			public function giveHint(): bool
114			{
115			return $this->giveHint;
116			}
117
118			public function setGiveHint(bool $giveHint)
119			{
120			$this->giveHint = $giveHint;
121			}
122
123			public function includeNumericStrings(): ?bool
124			{
125			return $this->includeNumericStrings;
126			}
127
128			public function setIncludeNumericStrings(?bool $includeNumericStrings)
129			{
130			$this->includeNumericStrings = $includeNumericStrings;
131			}
132
133			public function allowArrayMapping(): ?bool
134			{
135			return $this->allowArrayMapping;
136			}
137
138			public function setAllowArrayMapping(?bool $allowArrayMapping)
139			{
140			$this->allowArrayMapping = $allowArrayMapping;
141			}
142
143			/**
144			* @return Language[]
145			*/
146			public function checkNaming(): array
147			{
148			return $this->checkNaming;
149			}
150
151			public function setCheckNaming(array $checkNaming)
152			{
153			$languages = [];
154			foreach ($checkNaming as $language) {
155			$languages[] = $this->findLanguage($language);
156			}
157			$this->checkNaming = $languages;
158			}
159
160			protected function findLanguage($language): Language
161			{
162			foreach (scandir(__DIR__ . '/../Languages/') as $class) {
163			$class = basename($class, '.php');
164			$class = "Povils\PHPMND\Languages\\$class";
165			if ((
166			class_exists($class) &&
167			is_subclass_of($class, Language::class) &&
			0 ignored issues – show Bug introduced 2019-04-07 19:28 UTC by Report Bug Copy Issue Report Due to PHP Bug #53727, `is_subclass_of` might return inconsistent results on some PHP versions if `\Povils\PHPMND\Language::class` can be an interface. If so, you could instead use `ReflectionClass::implementsInterface`. Loading history...
168			in_array($language, $class::providesLanguages())
169			)) {
170			return new $class($language);
171			}
172			}
173
174			return new GenericLanguage($language);
175			}
176			}
177

povils / phpmnd

Pull Request — master (#86)

Option::checkNaming() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like