Field - Code Metrics - Inspection of "complete all validation" - harryosmar/plugin-validation - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( eae2ea...251e76 )

unknown

created 2018-02-17 05:03 UTC

Field A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	339
Duplicated Lines	4.72 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

46.88%

Importance

Changes

Metric	Value
dl	16
loc	339
ccs	45
cts	96
cp	0.4688
rs	9.2
c	0
b	0
f	0
wmc	34
lcom	1
cbo	2

31 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	addRules()	0	5	1
A	isValid()	16	16	4
A	getName()	0	4	1
A	getValue()	0	4	1
A	getRules()	0	4	1
A	getErrors()	0	4	1
A	required()	0	5	1
A	validEmail()	0	5	1
A	equal()	0	5	1
A	isTrue()	0	5	1
A	isNumber()	0	5	1
A	isAlpha()	0	5	1
A	isAlphaOrNumeric()	0	5	1
A	isDecimal()	0	5	1
A	isInteger()	0	5	1
A	isNatural()	0	5	1
A	isNaturalNoZero()	0	5	1
A	lessThan()	0	5	1
A	greaterThan()	0	5	1
A	lessOrEqualThan()	0	5	1
A	greaterOrEqualThan()	0	5	1
A	between()	0	5	1
A	betweenOrEqual()	0	5	1
A	length()	0	5	1
A	lengthLessThan()	0	5	1
A	lengthGreaterThan()	0	5	1
A	lengthLessOrEqualThan()	0	5	1
A	lengthGreaterOrEqualThan()	0	5	1
A	lengthBetween()	0	5	1
A	lengthBetweenOrEqual()	0	5	1

How to fix Duplicated Code

<?php

namespace PluginSimpleValidate;

use PluginSimpleValidate\Libraries\Language;
use PluginSimpleValidate\BaseAbstract\RuleMapping as AbstractRuleMapping;

class Field extends \PluginSimpleValidate\BaseAbstract\Field
{
    /**
     * @var string
     */
    private $name;

    /**
     * @var string
     */
    private $value;

    /**
     * @var array
     */
    private $errors;

    /**
     * @var array
     * array of Rule
     */
    private $rules = [];

    /**
     * @var bool
     */
    private $status;

    /**
     * Field constructor.
     * @param string $name
     * @param mixed $value
     */
    public function __construct(string $name, $value)
    {
        $this->name = $name;
        $this->value = $value;
        $this->errors = [];
    }

    /**
     * @param string $rulesMethod
     * @param array $args
     * @return $this
     */
    protected function addRules(string $rulesMethod, array $args = [])
    {
        $this->rules[$rulesMethod] = RuleMapping::getRule($rulesMethod, $args);
        return $this;
    }

    /**
     * @param Language $language
     * @return bool
     */
    public function isValid(Language $language) : bool

    {
        /** @var \PluginSimpleValidate\Contracts\Rule $rule */
        foreach ($this->rules as $ruleName => $rule) {
            if (!$rule->isValid($language, $this->value)) {
                $this->status = false;
                $this->errors[] = $rule->getError();
            }
        }

        if (empty($this->errors)) {
            $this->status = true;
        }

        return $this->status;
    }

    /**
     * @return string
     */
    public function getName(): string
    {
        return $this->name;
    }

    /**
     * @return mixed
     */
    public function getValue()
    {
        return $this->value;
    }

    /**
     * @return array
     */
    public function getRules(): array
    {
        return $this->rules;
    }

    /**
     * @return array
     */
    public function getErrors(): array
    {
        return $this->errors;
    }

    /**
     * @return $this
     */
    public function required()
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_REQUIRED);
        return $this;
    }

    /**
     * @return $this
     */
    public function validEmail()
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_EMAIL);
        return $this;
    }

    /**
     * @param int|float|double|string $match
     * @return $this
     */
    public function equal($match)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_EQUAL, [static::VAR_MATCH => $match]);
        return $this;
    }

    /**
     * @param string $message
     * @return $this
     */
    public function isTrue(string $message = '')
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_IS_TRUE, [static::VAR_MESSAGE => $message]);
        return $this;
    }

    /**
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function isNumber()
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_NUMBER);
        return $this;
    }

    /**
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function isAlpha()
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_ALPHA);
        return $this;
    }

    /**
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function isAlphaOrNumeric()
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_ALPHA_OR_NUMERIC);
        return $this;
    }

    /**
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function isDecimal()
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_DECIMAL);
        return $this;
    }

    /**
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function isInteger()
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_INTEGER);
        return $this;
    }

    /**
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function isNatural()
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_NATURAL_NUMBER);
        return $this;
    }

    /**
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function isNaturalNoZero()
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_NATURAL_NO_ZERO_NUMBER);
        return $this;
    }

    /**
     * @param int|float|double $limit
     * @return $this
     */
    public function lessThan($limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LESS_THAN, [static::VAR_LIMIT => $limit]);
        return $this;
    }

    /**
     * @param int|float|double $limit
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function greaterThan($limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_GREATER_THAN, [static::VAR_LIMIT => $limit]);
        return $this;
    }

    /**
     * @param int|float|double $limit
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function lessOrEqualThan($limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LESS_OR_EQUAL_THAN, [static::VAR_LIMIT => $limit]);
        return $this;
    }

    /**
     * @param int|float|double $limit
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function greaterOrEqualThan($limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_GREATER_OR_EQUAL_THAN, [static::VAR_LIMIT => $limit]);
        return $this;
    }

    /**
     * @param int|float|double $lower
     * @param int|float|double $upper
     * @return $this
     */
    public function between($lower, $upper)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_BETWEEN, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
        return $this;
    }

    /**
     * @param int|float|double $lower
     * @param int|float|double $upper
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function betweenOrEqual($lower, $upper)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_BETWEEN_OR_EQUAL_THAN, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
        return $this;
    }

    /**
     * @param int|float|double $limit
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function length($limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LENGTH);
        return $this;
    }

    /**
     * @param int|float|double $limit
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function lengthLessThan($limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_LESS_THAN, [static::VAR_LIMIT => $limit]);
        return $this;
    }

    /**
     * @param int|float|double $limit
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function lengthGreaterThan($limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_GREATER_THAN, [static::VAR_LIMIT => $limit]);
        return $this;
    }

    /**
     * @param int|float|double $limit
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function lengthLessOrEqualThan($limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_LESS_OR_EQUAL_THAN, [static::VAR_LIMIT => $limit]);
        return $this;
    }

    /**
     * @param int|float|double $limit
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function lengthGreaterOrEqualThan($limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_GREATER_OR_EQUAL_THAN, [static::VAR_LIMIT => $limit]);
        return $this;
    }

    /**
     * @param int|float|double $lower
     * @param int|float|double $upper
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function lengthBetween($lower, $upper)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_BETWEEN, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
        return $this;
    }

    /**
     * @param int|float|double $lower
     * @param int|float|double $upper
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function lengthBetweenOrEqual($lower, $upper)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_BETWEEN_OR_EQUAL_THAN, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
        return $this;
    }
}

1			<?php
2
3			namespace PluginSimpleValidate;
4
5			use PluginSimpleValidate\Libraries\Language;
6			use PluginSimpleValidate\BaseAbstract\RuleMapping as AbstractRuleMapping;
7
8			class Field extends \PluginSimpleValidate\BaseAbstract\Field
9			{
10			/**
11			* @var string
12			*/
13			private $name;
14
15			/**
16			* @var string
17			*/
18			private $value;
19
20			/**
21			* @var array
22			*/
23			private $errors;
24
25			/**
26			* @var array
27			* array of Rule
28			*/
29			private $rules = [];
30
31			/**
32			* @var bool
33			*/
34			private $status;
35
36			/**
37			* Field constructor.
38			* @param string $name
39			* @param mixed $value
40			*/
41	9		public function __construct(string $name, $value)
42			{
43	9		$this->name = $name;
44	9		$this->value = $value;
45	9		$this->errors = [];
46	9		}
47
48			/**
49			* @param string $rulesMethod
50			* @param array $args
51			* @return $this
52			*/
53	8		protected function addRules(string $rulesMethod, array $args = [])
54			{
55	8		$this->rules[$rulesMethod] = RuleMapping::getRule($rulesMethod, $args);
56	8		return $this;
57			}
58
59			/**
60			* @param Language $language
61			* @return bool
62			*/
63	8	View Code Duplication	public function isValid(Language $language) : bool
			0 ignored issues – show Duplication introduced 2018-02-17 05:05 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
64			{
65			/** @var \PluginSimpleValidate\Contracts\Rule $rule */
66	8		foreach ($this->rules as $ruleName => $rule) {
67	8		if (!$rule->isValid($language, $this->value)) {
68	8		$this->status = false;
69	8		$this->errors[] = $rule->getError();
70			}
71			}
72
73	8		if (empty($this->errors)) {
74			$this->status = true;
75			}
76
77	8		return $this->status;
78			}
79
80			/**
81			* @return string
82			*/
83	3		public function getName(): string
84			{
85	3		return $this->name;
86			}
87
88			/**
89			* @return mixed
90			*/
91	1		public function getValue()
92			{
93	1		return $this->value;
94			}
95
96			/**
97			* @return array
98			*/
99			public function getRules(): array
100			{
101			return $this->rules;
102			}
103
104			/**
105			* @return array
106			*/
107	8		public function getErrors(): array
108			{
109	8		return $this->errors;
110			}
111
112			/**
113			* @return $this
114			*/
115	4		public function required()
116			{
117	4		$this->addRules(AbstractRuleMapping::VALIDATE_REQUIRED);
118	4		return $this;
119			}
120
121			/**
122			* @return $this
123			*/
124	3		public function validEmail()
125			{
126	3		$this->addRules(AbstractRuleMapping::VALIDATE_EMAIL);
127	3		return $this;
128			}
129
130			/**
131			* @param int\|float\|double\|string $match
132			* @return $this
133			*/
134	1		public function equal($match)
135			{
136	1		$this->addRules(AbstractRuleMapping::VALIDATE_EQUAL, [static::VAR_MATCH => $match]);
137	1		return $this;
138			}
139
140			/**
141			* @param string $message
142			* @return $this
143			*/
144	1		public function isTrue(string $message = '')
145			{
146	1		$this->addRules(AbstractRuleMapping::VALIDATE_IS_TRUE, [static::VAR_MESSAGE => $message]);
147	1		return $this;
148			}
149
150			/**
151			* @return \PluginSimpleValidate\Contracts\Field
152			*/
153			public function isNumber()
154			{
155			$this->addRules(AbstractRuleMapping::VALIDATE_NUMBER);
156			return $this;
157			}
158
159			/**
160			* @return \PluginSimpleValidate\Contracts\Field
161			*/
162			public function isAlpha()
163			{
164			$this->addRules(AbstractRuleMapping::VALIDATE_ALPHA);
165			return $this;
166			}
167
168			/**
169			* @return \PluginSimpleValidate\Contracts\Field
170			*/
171	2		public function isAlphaOrNumeric()
172			{
173	2		$this->addRules(AbstractRuleMapping::VALIDATE_ALPHA_OR_NUMERIC);
174	2		return $this;
175			}
176
177			/**
178			* @return \PluginSimpleValidate\Contracts\Field
179			*/
180			public function isDecimal()
181			{
182			$this->addRules(AbstractRuleMapping::VALIDATE_DECIMAL);
183			return $this;
184			}
185
186			/**
187			* @return \PluginSimpleValidate\Contracts\Field
188			*/
189			public function isInteger()
190			{
191			$this->addRules(AbstractRuleMapping::VALIDATE_INTEGER);
192			return $this;
193			}
194
195			/**
196			* @return \PluginSimpleValidate\Contracts\Field
197			*/
198			public function isNatural()
199			{
200			$this->addRules(AbstractRuleMapping::VALIDATE_NATURAL_NUMBER);
201			return $this;
202			}
203
204			/**
205			* @return \PluginSimpleValidate\Contracts\Field
206			*/
207			public function isNaturalNoZero()
208			{
209			$this->addRules(AbstractRuleMapping::VALIDATE_NATURAL_NO_ZERO_NUMBER);
210			return $this;
211			}
212
213			/**
214			* @param int\|float\|double $limit
215			* @return $this
216			*/
217	1		public function lessThan($limit)
218			{
219	1		$this->addRules(AbstractRuleMapping::VALIDATE_LESS_THAN, [static::VAR_LIMIT => $limit]);
220	1		return $this;
221			}
222
223			/**
224			* @param int\|float\|double $limit
225			* @return \PluginSimpleValidate\Contracts\Field
226			*/
227			public function greaterThan($limit)
228			{
229			$this->addRules(AbstractRuleMapping::VALIDATE_GREATER_THAN, [static::VAR_LIMIT => $limit]);
230			return $this;
231			}
232
233			/**
234			* @param int\|float\|double $limit
235			* @return \PluginSimpleValidate\Contracts\Field
236			*/
237			public function lessOrEqualThan($limit)
238			{
239			$this->addRules(AbstractRuleMapping::VALIDATE_LESS_OR_EQUAL_THAN, [static::VAR_LIMIT => $limit]);
240			return $this;
241			}
242
243			/**
244			* @param int\|float\|double $limit
245			* @return \PluginSimpleValidate\Contracts\Field
246			*/
247			public function greaterOrEqualThan($limit)
248			{
249			$this->addRules(AbstractRuleMapping::VALIDATE_GREATER_OR_EQUAL_THAN, [static::VAR_LIMIT => $limit]);
250			return $this;
251			}
252
253			/**
254			* @param int\|float\|double $lower
255			* @param int\|float\|double $upper
256			* @return $this
257			*/
258	1		public function between($lower, $upper)
259			{
260	1		$this->addRules(AbstractRuleMapping::VALIDATE_BETWEEN, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
261	1		return $this;
262			}
263
264			/**
265			* @param int\|float\|double $lower
266			* @param int\|float\|double $upper
267			* @return \PluginSimpleValidate\Contracts\Field
268			*/
269			public function betweenOrEqual($lower, $upper)
270			{
271			$this->addRules(AbstractRuleMapping::VALIDATE_BETWEEN_OR_EQUAL_THAN, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
272			return $this;
273			}
274
275			/**
276			* @param int\|float\|double $limit
277			* @return \PluginSimpleValidate\Contracts\Field
278			*/
279			public function length($limit)
280			{
281			$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH);
282			return $this;
283			}
284
285			/**
286			* @param int\|float\|double $limit
287			* @return \PluginSimpleValidate\Contracts\Field
288			*/
289			public function lengthLessThan($limit)
290			{
291			$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_LESS_THAN, [static::VAR_LIMIT => $limit]);
292			return $this;
293			}
294
295			/**
296			* @param int\|float\|double $limit
297			* @return \PluginSimpleValidate\Contracts\Field
298			*/
299	2		public function lengthGreaterThan($limit)
300			{
301	2		$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_GREATER_THAN, [static::VAR_LIMIT => $limit]);
302	2		return $this;
303			}
304
305			/**
306			* @param int\|float\|double $limit
307			* @return \PluginSimpleValidate\Contracts\Field
308			*/
309			public function lengthLessOrEqualThan($limit)
310			{
311			$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_LESS_OR_EQUAL_THAN, [static::VAR_LIMIT => $limit]);
312			return $this;
313			}
314
315			/**
316			* @param int\|float\|double $limit
317			* @return \PluginSimpleValidate\Contracts\Field
318			*/
319			public function lengthGreaterOrEqualThan($limit)
320			{
321			$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_GREATER_OR_EQUAL_THAN, [static::VAR_LIMIT => $limit]);
322			return $this;
323			}
324
325			/**
326			* @param int\|float\|double $lower
327			* @param int\|float\|double $upper
328			* @return \PluginSimpleValidate\Contracts\Field
329			*/
330			public function lengthBetween($lower, $upper)
331			{
332			$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_BETWEEN, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
333			return $this;
334			}
335
336			/**
337			* @param int\|float\|double $lower
338			* @param int\|float\|double $upper
339			* @return \PluginSimpleValidate\Contracts\Field
340			*/
341			public function lengthBetweenOrEqual($lower, $upper)
342			{
343			$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_BETWEEN_OR_EQUAL_THAN, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
344			return $this;
345			}
346			}

harryosmar / plugin-validation

Push — master ( eae2ea...251e76 )

Field A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

31 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like