Field::getRules() - Code Metrics - Inspection of "Merge pull request #4 from harryosmar/implement-ph..." - harryosmar/plugin-validation - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 121fac...aa6513 )

by Harry Osmar

created 2018-02-21 10:10 UTC

Field::getRules() A

↳ Parent: Field

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	4
ccs	0
cts	2
cp	0
crap	2
rs	10
c	0
b	0
f	0

<?php

namespace PluginSimpleValidate;

use PluginSimpleValidate\BaseAbstract\RuleMapping as AbstractRuleMapping;

class Field extends \PluginSimpleValidate\BaseAbstract\Field
{
    /**
     * @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;
    }

    /**
     * @param string $region
     * @return \PluginSimpleValidate\Contracts\Field
     */
    public function isValidPhone(string $region)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_PHONE_NUMBER, [static::VAR_REGION => $region]);
        return $this;
    }
}

1		<?php
2
3		namespace PluginSimpleValidate;
4
5		use PluginSimpleValidate\BaseAbstract\RuleMapping as AbstractRuleMapping;
6
7		class Field extends \PluginSimpleValidate\BaseAbstract\Field
8		{
9		/**
10		* @return $this
11		*/
12	4	public function required()
13		{
14	4	$this->addRules(AbstractRuleMapping::VALIDATE_REQUIRED);
15	4	return $this;
16		}
17
18		/**
19		* @return $this
20		*/
21	3	public function validEmail()
22		{
23	3	$this->addRules(AbstractRuleMapping::VALIDATE_EMAIL);
24	3	return $this;
25		}
26
27		/**
28		* @param int\|float\|double\|string $match
29		* @return $this
30		*/
31	1	public function equal($match)
32		{
33	1	$this->addRules(AbstractRuleMapping::VALIDATE_EQUAL, [static::VAR_MATCH => $match]);
34	1	return $this;
35		}
36
37		/**
38		* @param string $message
39		* @return $this
40		*/
41	1	public function isTrue(string $message = '')
42		{
43	1	$this->addRules(AbstractRuleMapping::VALIDATE_IS_TRUE, [static::VAR_MESSAGE => $message]);
44	1	return $this;
45		}
46
47		/**
48		* @return \PluginSimpleValidate\Contracts\Field
49		*/
50		public function isNumber()
51		{
52		$this->addRules(AbstractRuleMapping::VALIDATE_NUMBER);
53		return $this;
54		}
55
56		/**
57		* @return \PluginSimpleValidate\Contracts\Field
58		*/
59		public function isAlpha()
60		{
61		$this->addRules(AbstractRuleMapping::VALIDATE_ALPHA);
62		return $this;
63		}
64
65		/**
66		* @return \PluginSimpleValidate\Contracts\Field
67		*/
68	2	public function isAlphaOrNumeric()
69		{
70	2	$this->addRules(AbstractRuleMapping::VALIDATE_ALPHA_OR_NUMERIC);
71	2	return $this;
72		}
73
74		/**
75		* @return \PluginSimpleValidate\Contracts\Field
76		*/
77		public function isDecimal()
78		{
79		$this->addRules(AbstractRuleMapping::VALIDATE_DECIMAL);
80		return $this;
81		}
82
83		/**
84		* @return \PluginSimpleValidate\Contracts\Field
85		*/
86		public function isInteger()
87		{
88		$this->addRules(AbstractRuleMapping::VALIDATE_INTEGER);
89		return $this;
90		}
91
92		/**
93		* @return \PluginSimpleValidate\Contracts\Field
94		*/
95		public function isNatural()
96		{
97		$this->addRules(AbstractRuleMapping::VALIDATE_NATURAL_NUMBER);
98		return $this;
99		}
100
101		/**
102		* @return \PluginSimpleValidate\Contracts\Field
103		*/
104		public function isNaturalNoZero()
105		{
106		$this->addRules(AbstractRuleMapping::VALIDATE_NATURAL_NO_ZERO_NUMBER);
107		return $this;
108		}
109
110		/**
111		* @param int\|float\|double $limit
112		* @return $this
113		*/
114	1	public function lessThan($limit)
115		{
116	1	$this->addRules(AbstractRuleMapping::VALIDATE_LESS_THAN, [static::VAR_LIMIT => $limit]);
117	1	return $this;
118		}
119
120		/**
121		* @param int\|float\|double $limit
122		* @return \PluginSimpleValidate\Contracts\Field
123		*/
124		public function greaterThan($limit)
125		{
126		$this->addRules(AbstractRuleMapping::VALIDATE_GREATER_THAN, [static::VAR_LIMIT => $limit]);
127		return $this;
128		}
129
130		/**
131		* @param int\|float\|double $limit
132		* @return \PluginSimpleValidate\Contracts\Field
133		*/
134		public function lessOrEqualThan($limit)
135		{
136		$this->addRules(AbstractRuleMapping::VALIDATE_LESS_OR_EQUAL_THAN, [static::VAR_LIMIT => $limit]);
137		return $this;
138		}
139
140		/**
141		* @param int\|float\|double $limit
142		* @return \PluginSimpleValidate\Contracts\Field
143		*/
144		public function greaterOrEqualThan($limit)
145		{
146		$this->addRules(AbstractRuleMapping::VALIDATE_GREATER_OR_EQUAL_THAN, [static::VAR_LIMIT => $limit]);
147		return $this;
148		}
149
150		/**
151		* @param int\|float\|double $lower
152		* @param int\|float\|double $upper
153		* @return $this
154		*/
155	1	public function between($lower, $upper)
156		{
157	1	$this->addRules(AbstractRuleMapping::VALIDATE_BETWEEN, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
158	1	return $this;
159		}
160
161		/**
162		* @param int\|float\|double $lower
163		* @param int\|float\|double $upper
164		* @return \PluginSimpleValidate\Contracts\Field
165		*/
166		public function betweenOrEqual($lower, $upper)
167		{
168		$this->addRules(AbstractRuleMapping::VALIDATE_BETWEEN_OR_EQUAL_THAN, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
169		return $this;
170		}
171
172		/**
173		* @param int\|float\|double $limit
174		* @return \PluginSimpleValidate\Contracts\Field
175		*/
176		public function length($limit)
177		{
178		$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH);
179		return $this;
180		}
181
182		/**
183		* @param int\|float\|double $limit
184		* @return \PluginSimpleValidate\Contracts\Field
185		*/
186		public function lengthLessThan($limit)
187		{
188		$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_LESS_THAN, [static::VAR_LIMIT => $limit]);
189		return $this;
190		}
191
192		/**
193		* @param int\|float\|double $limit
194		* @return \PluginSimpleValidate\Contracts\Field
195		*/
196	2	public function lengthGreaterThan($limit)
197		{
198	2	$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_GREATER_THAN, [static::VAR_LIMIT => $limit]);
199	2	return $this;
200		}
201
202		/**
203		* @param int\|float\|double $limit
204		* @return \PluginSimpleValidate\Contracts\Field
205		*/
206		public function lengthLessOrEqualThan($limit)
207		{
208		$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_LESS_OR_EQUAL_THAN, [static::VAR_LIMIT => $limit]);
209		return $this;
210		}
211
212		/**
213		* @param int\|float\|double $limit
214		* @return \PluginSimpleValidate\Contracts\Field
215		*/
216		public function lengthGreaterOrEqualThan($limit)
217		{
218		$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_GREATER_OR_EQUAL_THAN, [static::VAR_LIMIT => $limit]);
219		return $this;
220		}
221
222		/**
223		* @param int\|float\|double $lower
224		* @param int\|float\|double $upper
225		* @return \PluginSimpleValidate\Contracts\Field
226		*/
227		public function lengthBetween($lower, $upper)
228		{
229		$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_BETWEEN, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
230		return $this;
231		}
232
233		/**
234		* @param int\|float\|double $lower
235		* @param int\|float\|double $upper
236		* @return \PluginSimpleValidate\Contracts\Field
237		*/
238		public function lengthBetweenOrEqual($lower, $upper)
239		{
240		$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_BETWEEN_OR_EQUAL_THAN, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
241		return $this;
242		}
243
244		/**
245		* @param string $region
246		* @return \PluginSimpleValidate\Contracts\Field
247		*/
248	1	public function isValidPhone(string $region)
249		{
250	1	$this->addRules(AbstractRuleMapping::VALIDATE_PHONE_NUMBER, [static::VAR_REGION => $region]);
251	1	return $this;
252		}
253		}

harryosmar / plugin-validation

Push — master ( 121fac...aa6513 )

Field::getRules() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like