Validator::validateSpecialCharacters() - Code Metrics - Inspection of "Fixes missed refactored validator property." - allebb/plexity - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 92def2...897125 )

by Bobby

created 2016-12-04 18:06 UTC

Validator::validateSpecialCharacters() A

↳ Parent: Validator

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes

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

<?php
namespace Ballen\Plexity\Support;

use \Ballen\Plexity\Plexity;

/**
 * Plexity
 *
 * Plexity (Password Complexity) is a password complexity library that
 * enables you to set "rules" for a password (or any other kind of string) that
 * you can then check against in your application.
 *
 * @author Bobby Allen <[email protected]>
 * @license http://opensource.org/licenses/MIT
 * @link https://github.com/allebb/passplexity
 * @link http://bobbyallen.me
 *
 */
class Validator
{

    /**
     * The Plexity object (contains the validation configuration)
     * @var \Ballen\Plexity\Plexity
     */
    private $configuration;

    /**
     * Numeric values list
     * @var array
     */
    protected $numbers = [
        1, 2, 3, 4, 5, 6, 7, 8, 9, 0
    ];

    /**
     * Special Character list
     * @see https://www.owasp.org/index.php/Password_special_characters
     * @var array
     */
    protected $specialCharacters = [
        ' ', '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '.',
        '/', ':', ';', '<', '=', '>', '?', '@', '[', ']', '\\', '^', '_', '`',
        '{', '|', '}', '~',
    ];

    /**
     * Validates all the configured rules and responds as requested.
     * @return boolean
     * @throws \Ballen\Plexity\Exceptions\ValidationException
     */
    public function validate(Plexity $configuration)
    {
        $this->configuration = $configuration;
        $this->checkMinimumLength();
        $this->checkMaximumLength();
        $this->checkLowerCase();
        $this->checkUpperCase();
        $this->checkNumericCharacters();
        $this->checkSpecialCharacters();
        $this->checkNotIn();
        return true;
    }

    /**
     * Checks the minimum length requirement.
     * @throws \Ballen\Plexity\Exceptions\ValidationException
     */
    public function checkMinimumLength()
    {
        if ($this->configuration->rules()->get(Plexity::RULE_LENGTH_MIN) > 0) {
            if (!$this->validateLengthMin()) {
                throw new \Ballen\Plexity\Exceptions\ValidationException('The length does not meet the minimum length requirements.');
            }
        }
    }

    /**
     * Checks the minimum maximum length requirement.
     * @throws \Ballen\Plexity\Exceptions\ValidationException
     */
    public function checkMaximumLength()
    {
        if ($this->configuration->rules()->get(Plexity::RULE_LENGTH_MAX) > 0) {
            if (!$this->validateLengthMax()) {
                throw new \Ballen\Plexity\Exceptions\ValidationException('The length exceeds the maximum length requirements.');
            }
        }
    }

    /**
     * Checks the lowercase character(s) requirement.
     * @throws \Ballen\Plexity\Exceptions\ValidationException
     */
    public function checkLowerCase()
    {
        if ($this->configuration->rules()->get(Plexity::RULE_LOWER)) {
            if (!$this->validateLowerCase()) {
                throw new \Ballen\Plexity\Exceptions\ValidationException('The string failed to meet the lower case requirements.');
            }
        }
    }

    /**
     * Checks the upper case character(s) requirement.
     * @throws \Ballen\Plexity\Exceptions\ValidationException
     */
    public function checkUpperCase()
    {
        if ($this->configuration->rules()->get(Plexity::RULE_UPPER)) {
            if (!$this->validateUpperCase()) {
                throw new \Ballen\Plexity\Exceptions\ValidationException('The string failed to meet the upper case requirements.');
            }
        }
    }

    /**
     * Checks the numeric character(s) requirement.
     * @throws \Ballen\Plexity\Exceptions\ValidationException
     */
    public function checkNumericCharacters()
    {
        if ($this->configuration->rules()->get(Plexity::RULE_NUMERIC) > 0) {
            if (!$this->validateNumericCharacters()) {
                throw new \Ballen\Plexity\Exceptions\ValidationException('The string failed to meet the numeric character requirements.');
            }
        }
    }

    /**
     * Checks the special character(s) requirement.
     * @throws \Ballen\Plexity\Exceptions\ValidationException
     */
    public function checkSpecialCharacters()
    {
        if ($this->configuration->rules()->get(Plexity::RULE_SPECIAL) > 0) {
            if (!$this->validateSpecialCharacters()) {
                throw new \Ballen\Plexity\Exceptions\ValidationException('The string failed to meet the special character requirements.');
            }
        }
    }

    public function checkNotIn()
    {
        if (count($this->configuration->rules()->get(Plexity::RULE_NOT_IN)) > 0) {
            if (!$this->validateNotIn()) {
                throw new \Ballen\Plexity\Exceptions\ValidationException('The string exists in the list of disallowed values requirements.');
            }
        }
    }

    /**
     * Validates the upper case requirements.
     * @return boolean
     */
    private function validateUpperCase()
    {
        return (bool) preg_match("/[A-Z]/", $this->configuration->checkString());
    }

    /**
     * Validates the lower case requirements.
     * @return boolean
     */
    private function validateLowerCase()
    {
        return (bool) preg_match("/[a-z]/", $this->configuration->checkString());
    }

    /**
     * Validates the special character requirements.
     * @return boolean
     */
    private function validateSpecialCharacters()
    {
        if ($this->countOccurences($this->specialCharacters, $this->configuration->checkString()) >= $this->configuration->rules()->get(Plexity::RULE_SPECIAL)) {
            return true;
        }
        return false;
    }

    /**
     * Validates the numeric case requirements.
     * @return boolean
     */
    private function validateNumericCharacters()
    {
        if ($this->countOccurences($this->numbers, $this->configuration->checkString()) >= $this->configuration->rules()->get(Plexity::RULE_NUMERIC)) {
            return true;
        }
        return false;
    }

    /**
     * Validates the minimum string length requirements.
     * @return boolean
     */
    private function validateLengthMin()
    {
        if (strlen($this->configuration->checkString()) >= $this->configuration->rules()->get(Plexity::RULE_LENGTH_MIN)) {
            return true;
        }
        return false;
    }

    /**
     * Validates the maximum string length requirements.
     * @return boolean
     */
    private function validateLengthMax()
    {
        if (strlen($this->configuration->checkString()) <= $this->configuration->rules()->get(Plexity::RULE_LENGTH_MAX)) {
            return true;
        }
        return false;
    }

    /**
     * Validates the not_in requirements.
     * @return boolean
     */
    private function validateNotIn()
    {
        if (in_array($this->configuration->checkString(), $this->configuration->rules()->get(Plexity::RULE_NOT_IN))) {
            return false;
        }
        return true;
    }

    /**
     * Count the number of occurences of a character or string in a string.
     * @param array $needles The character/string to count occurences of.
     * @param string $haystack The string to check against.
     * @return int The number of occurences.
     */
    private function countOccurences(array $needles, $haystack)
    {
        $count = 0;
        foreach ($needles as $char) {
            $count += substr_count($haystack, $char);
        }
        return $count;
    }
}


1			<?php
2			namespace Ballen\Plexity\Support;
3
4			use \Ballen\Plexity\Plexity;
5
6			/**
7			* Plexity
8			*
9			* Plexity (Password Complexity) is a password complexity library that
10			* enables you to set "rules" for a password (or any other kind of string) that
11			* you can then check against in your application.
12			*
13			* @author Bobby Allen <[email protected]>
14			* @license http://opensource.org/licenses/MIT
15			* @link https://github.com/allebb/passplexity
16			* @link http://bobbyallen.me
17			*
18			*/
19			class Validator
20			{
21
22			/**
23			* The Plexity object (contains the validation configuration)
24			* @var \Ballen\Plexity\Plexity
25			*/
26			private $configuration;
27
28			/**
29			* Numeric values list
30			* @var array
31			*/
32			protected $numbers = [
33			1, 2, 3, 4, 5, 6, 7, 8, 9, 0
34			];
35
36			/**
37			* Special Character list
38			* @see https://www.owasp.org/index.php/Password_special_characters
39			* @var array
40			*/
41			protected $specialCharacters = [
42			' ', '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '.',
43			'/', ':', ';', '<', '=', '>', '?', '@', '[', ']', '\\', '^', '_', '`',
44			'{', '\|', '}', '~',
45			];
46
47			/**
48			* Validates all the configured rules and responds as requested.
49			* @return boolean
50			* @throws \Ballen\Plexity\Exceptions\ValidationException
51			*/
52	22		public function validate(Plexity $configuration)
53			{
54	22		$this->configuration = $configuration;
55	22		$this->checkMinimumLength();
56	20		$this->checkMaximumLength();
57	18		$this->checkLowerCase();
58	17		$this->checkUpperCase();
59	16		$this->checkNumericCharacters();
60	14		$this->checkSpecialCharacters();
61	12		$this->checkNotIn();
62	11		return true;
63			}
64
65			/**
66			* Checks the minimum length requirement.
67			* @throws \Ballen\Plexity\Exceptions\ValidationException
68			*/
69	22	View Code Duplication	public function checkMinimumLength()
70			{
71	22		if ($this->configuration->rules()->get(Plexity::RULE_LENGTH_MIN) > 0) {
72	6		if (!$this->validateLengthMin()) {
73	2		throw new \Ballen\Plexity\Exceptions\ValidationException('The length does not meet the minimum length requirements.');
74			}
75	4		}
76	20		}
77
78			/**
79			* Checks the minimum maximum length requirement.
80			* @throws \Ballen\Plexity\Exceptions\ValidationException
81			*/
82	20	View Code Duplication	public function checkMaximumLength()
83			{
84	20		if ($this->configuration->rules()->get(Plexity::RULE_LENGTH_MAX) > 0) {
85	5		if (!$this->validateLengthMax()) {
86	2		throw new \Ballen\Plexity\Exceptions\ValidationException('The length exceeds the maximum length requirements.');
87			}
88	3		}
89	18		}
90
91			/**
92			* Checks the lowercase character(s) requirement.
93			* @throws \Ballen\Plexity\Exceptions\ValidationException
94			*/
95	18		public function checkLowerCase()
96			{
97	18		if ($this->configuration->rules()->get(Plexity::RULE_LOWER)) {
98	2		if (!$this->validateLowerCase()) {
99	1		throw new \Ballen\Plexity\Exceptions\ValidationException('The string failed to meet the lower case requirements.');
100			}
101	1		}
102	17		}
103
104			/**
105			* Checks the upper case character(s) requirement.
106			* @throws \Ballen\Plexity\Exceptions\ValidationException
107			*/
108	17		public function checkUpperCase()
109			{
110	17		if ($this->configuration->rules()->get(Plexity::RULE_UPPER)) {
111	2		if (!$this->validateUpperCase()) {
112	1		throw new \Ballen\Plexity\Exceptions\ValidationException('The string failed to meet the upper case requirements.');
113			}
114	1		}
115	16		}
116
117			/**
118			* Checks the numeric character(s) requirement.
119			* @throws \Ballen\Plexity\Exceptions\ValidationException
120			*/
121	16	View Code Duplication	public function checkNumericCharacters()
122			{
123	16		if ($this->configuration->rules()->get(Plexity::RULE_NUMERIC) > 0) {
124	4		if (!$this->validateNumericCharacters()) {
125	2		throw new \Ballen\Plexity\Exceptions\ValidationException('The string failed to meet the numeric character requirements.');
126			}
127	2		}
128	14		}
129
130			/**
131			* Checks the special character(s) requirement.
132			* @throws \Ballen\Plexity\Exceptions\ValidationException
133			*/
134	14	View Code Duplication	public function checkSpecialCharacters()
135			{
136	14		if ($this->configuration->rules()->get(Plexity::RULE_SPECIAL) > 0) {
137	4		if (!$this->validateSpecialCharacters()) {
138	2		throw new \Ballen\Plexity\Exceptions\ValidationException('The string failed to meet the special character requirements.');
139			}
140	2		}
141	12		}
142
143	12	View Code Duplication	public function checkNotIn()
144			{
145	12		if (count($this->configuration->rules()->get(Plexity::RULE_NOT_IN)) > 0) {
146	2		if (!$this->validateNotIn()) {
147	1		throw new \Ballen\Plexity\Exceptions\ValidationException('The string exists in the list of disallowed values requirements.');
148			}
149	1		}
150	11		}
151
152			/**
153			* Validates the upper case requirements.
154			* @return boolean
155			*/
156	2		private function validateUpperCase()
157			{
158	2		return (bool) preg_match("/[A-Z]/", $this->configuration->checkString());
159			}
160
161			/**
162			* Validates the lower case requirements.
163			* @return boolean
164			*/
165	2		private function validateLowerCase()
166			{
167	2		return (bool) preg_match("/[a-z]/", $this->configuration->checkString());
168			}
169
170			/**
171			* Validates the special character requirements.
172			* @return boolean
173			*/
174	4		private function validateSpecialCharacters()
175			{
176	4		if ($this->countOccurences($this->specialCharacters, $this->configuration->checkString()) >= $this->configuration->rules()->get(Plexity::RULE_SPECIAL)) {
177	2		return true;
178			}
179	2		return false;
180			}
181
182			/**
183			* Validates the numeric case requirements.
184			* @return boolean
185			*/
186	4		private function validateNumericCharacters()
187			{
188	4		if ($this->countOccurences($this->numbers, $this->configuration->checkString()) >= $this->configuration->rules()->get(Plexity::RULE_NUMERIC)) {
189	2		return true;
190			}
191	2		return false;
192			}
193
194			/**
195			* Validates the minimum string length requirements.
196			* @return boolean
197			*/
198	6	View Code Duplication	private function validateLengthMin()
199			{
200	6		if (strlen($this->configuration->checkString()) >= $this->configuration->rules()->get(Plexity::RULE_LENGTH_MIN)) {
201	4		return true;
202			}
203	2		return false;
204			}
205
206			/**
207			* Validates the maximum string length requirements.
208			* @return boolean
209			*/
210	5	View Code Duplication	private function validateLengthMax()
211			{
212	5		if (strlen($this->configuration->checkString()) <= $this->configuration->rules()->get(Plexity::RULE_LENGTH_MAX)) {
213	3		return true;
214			}
215	2		return false;
216			}
217
218			/**
219			* Validates the not_in requirements.
220			* @return boolean
221			*/
222	2	View Code Duplication	private function validateNotIn()
223			{
224	2		if (in_array($this->configuration->checkString(), $this->configuration->rules()->get(Plexity::RULE_NOT_IN))) {
225	1		return false;
226			}
227	1		return true;
228			}
229
230			/**
231			* Count the number of occurences of a character or string in a string.
232			* @param array $needles The character/string to count occurences of.
233			* @param string $haystack The string to check against.
234			* @return int The number of occurences.
235			*/
236	8		private function countOccurences(array $needles, $haystack)
237			{
238	8		$count = 0;
239	8		foreach ($needles as $char) {
240	8		$count += substr_count($haystack, $char);
241	8		}
242	8		return $count;
243			}
244			}
245

allebb / plexity

Push — master ( 92def2...897125 )

Validator::validateSpecialCharacters() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like