Field::greaterThan() - Code Metrics - Inspection of "Merge pull request #8 from harryosmar/rule-not-emp..." - harryosmar/plugin-validation - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 70e1be...590085 )

by Harry Osmar

created 2018-02-26 09:00 UTC

Field::greaterThan() A

↳ Parent: Field

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

harryosmar / plugin-validation

Push — master ( 70e1be...590085 )

Field::greaterThan() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like