LiittleCookie/valitron
1
0
Fork 0
mirror of https://github.com/vlucas/valitron.git synced 2025-12-30 23:01:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote master branch

Browse Source
This commit is contained in:
misantron 2018-09-22 16:35:15 +03:00
commit f70e27af56
10 changed files with 388 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -3,3 +3,4 @@
composer.phar composer.phar
composer.lock composer.lock
vendor vendor
.idea/

12
.travis.yml
View File

@ -1,21 +1,27 @@
# see http://about.travis-ci.org/docs/user/languages/php/ for more hints # see http://about.travis-ci.org/docs/user/languages/php/ for more hints
language: php language: php
dist: precise
# list any PHP version you want to test against # list any PHP version you want to test against
php: php:
- 5.3
- 5.4 - 5.4
- 5.5 - 5.5
- 5.6 - 5.6
- 7.0
- 7.1
- 7.2
- nightly
- hhvm - hhvm
matrix: matrix:
allow_failures: allow_failures:
- php: hhvm - php: hhvm
- php: nightly
include:
- php: 5.3
dist: precise
before_script: before_script:
- composer install - composer install
# Script to run tests # Script to run tests
script: ./vendor/bin/phpunit script: composer test

3
README.md
View File

@ -133,12 +133,15 @@ V::lang('ar');
* `in` - Performs in_array check on given array values * `in` - Performs in_array check on given array values
* `notIn` - Negation of `in` rule (not in array of values) * `notIn` - Negation of `in` rule (not in array of values)
* `ip` - Valid IP address * `ip` - Valid IP address
* `ipv4` - Valid IP v4 address
* `ipv6` - Valid IP v6 address
* `email` - Valid email address * `email` - Valid email address
* `emailDNS` - Valid email address with active DNS record * `emailDNS` - Valid email address with active DNS record
* `url` - Valid URL * `url` - Valid URL
* `urlActive` - Valid URL with active DNS record * `urlActive` - Valid URL with active DNS record
* `alpha` - Alphabetic characters only * `alpha` - Alphabetic characters only
* `alphaNum` - Alphabetic and numeric characters only * `alphaNum` - Alphabetic and numeric characters only
* `ascii` - ASCII characters only
* `slug` - URL slug characters (a-z, 0-9, -, \_) * `slug` - URL slug characters (a-z, 0-9, -, \_)
* `regex` - Field matches given regex pattern * `regex` - Field matches given regex pattern
* `date` - Field is a valid date * `date` - Field is a valid date

14
composer.json
View File

@ -16,11 +16,19 @@
"php": ">=5.3.2" "php": ">=5.3.2"
}, },
"require-dev": { "require-dev": {
"phpunit/phpunit": "~4.8.35" "phpunit/phpunit": "^4.8.35 || ^5.5 || ^6.5"
},
"suggest": {
"ext-mbstring": "It can support the multiple bytes string length."
}, },
"autoload": { "autoload": {
"psr-0": { "psr-4": {
"Valitron": "src/" "Valitron\\": "src/Valitron"
}
},
"autoload-dev": {
"psr-4": {
"Valitron\\": "tests/Valitron"
} }
}, },
"scripts": { "scripts": {

34
lang/ko.php Normal file
View File

@ -0,0 +1,34 @@
<?php
return array(
'required' => "을(를) 입력해야 합니다.",
'equals' => "은(는) '%s'와(과) 같아야 합니다.",
'different' => "은(는) '%s'와(과) 달라야 합니다.",
'accepted' => "을(를) 동의해야 합니다.",
'numeric' => "은(는) 숫자여야 합니다.",
'integer' => "은(는) 정수여야 합니다.",
'length' => "의 길이는 %d 이어야 합니다.",
'min' => "은(는) %s 이상이어야 합니다.",
'max' => "은(는) %s 이하여야 합니다.",
'in' => "은(는) 올바르지 않은 값을 포함하고 있습니다.",
'notIn' => "은(는) 올바르지 않은 값을 포함하고 있습니다.",
'ip' => "은(는) 올바르지 않은 IP입니다.",
'email' => "은(는) 올바르지 않은 email입니다.",
'url' => "은(는) 올바르지 않은 URL입니다.",
'urlActive' => "은(는) 접속 가능한 도메인이어야 합니다.",
'alpha' => "은(는) 영문자(a-z)로만 이루어져야 합니다.",
'alphaNum' => "은(는) 영문자(a-z)와 숫자(0-9)로만 이루어져야 합니다.",
'slug' => "은(는) 영문자(a-z)와 숫자(0-9), 특수문자 -와 _로만 이루어져야 합니다.",
'regex' => "은(는) 올바르지 않은 문자를 포함하고 있습니다.",
'date' => "은(는) 올바르지 않은 날짜입니다.",
'dateFormat' => "은(는) '%s' 형태의 날짜여야 합니다.",
'dateBefore' => "은(는) '%s' 보다 이전이어야 합니다.",
'dateAfter' => "은(는) '%s' 보다 이후여야 합니다.",
'contains' => "은(는) '%s'을(를) 포함해야 합니다.",
'boolean' => "은(는) boolean이어야 합니다.",
'lengthBetween' => "의 길이는 %d에서 %d 사이여야 합니다.",
'creditCard' => "은(는) 올바른 신용카드 번호가 아닙니다.",
'lengthMin' => "의 길이는 %d 이상이어야 합니다.",
'lengthMax' => "의 길이는 %d을(를) 넘을 수 없습니다.",
'instanceOf' => "는 '%s'의 객체여야 합니다."
);

8
phpunit.xml
View File

@ -15,4 +15,12 @@
<directory suffix="Test.php">tests/Valitron</directory> <directory suffix="Test.php">tests/Valitron</directory>
</testsuite> </testsuite>
</testsuites> </testsuites>
<filter>
<whitelist>
<directory suffix=".php">src/</directory>
</whitelist>
<blacklist>
<directory suffix=".php">vendor/</directory>
</blacklist>
</filter>
</phpunit> </phpunit>

165
src/Valitron/Validator.php
View File

@ -1,4 +1,5 @@
<?php <?php
namespace Valitron; namespace Valitron;
/** /**
@ -77,13 +78,18 @@ class Validator
*/ */
protected $validUrlPrefixes = array('http://', 'https://', 'ftp://'); protected $validUrlPrefixes = array('http://', 'https://', 'ftp://');
/**
* @var bool
*/
protected $stop_on_first_fail = false;
/** /**
* Setup validation * Setup validation
* *
* @param array $data * @param array $data
* @param array $fields * @param array $fields
* @param string $lang * @param string $lang
* @param string $langDir * @param string $langDir
* @throws \InvalidArgumentException * @throws \InvalidArgumentException
*/ */
public function __construct($data = array(), $fields = array(), $lang = null, $langDir = null) public function __construct($data = array(), $fields = array(), $lang = null, $langDir = null)
@ -142,8 +148,8 @@ class Validator
* Required field validator * Required field validator
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @param array $params * @param array $params
* @return bool * @return bool
*/ */
protected function validateRequired($field, $value, $params = array()) protected function validateRequired($field, $value, $params = array())
@ -198,7 +204,7 @@ class Validator
* This validation rule implies the field is "required" * This validation rule implies the field is "required"
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @return bool * @return bool
*/ */
protected function validateAccepted($field, $value) protected function validateAccepted($field, $value)
@ -212,7 +218,7 @@ class Validator
* Validate that a field is an array * Validate that a field is an array
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @return bool * @return bool
*/ */
protected function validateArray($field, $value) protected function validateArray($field, $value)
@ -224,7 +230,7 @@ class Validator
* Validate that a field is numeric * Validate that a field is numeric
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @return bool * @return bool
*/ */
protected function validateNumeric($field, $value) protected function validateNumeric($field, $value)
@ -236,15 +242,15 @@ class Validator
* Validate that a field is an integer * Validate that a field is an integer
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @param array $params * @param array $params
* @return bool * @return bool
*/ */
protected function validateInteger($field, $value, $params) protected function validateInteger($field, $value, $params)
{ {
if (isset($params[0]) && (bool)$params[0]) { if (isset($params[0]) && (bool)$params[0]) {
//strict mode //strict mode
return preg_match('/^-?([0-9])+$/i', $value); return preg_match('/^([0-9]|-[1-9]|-?[1-9][0-9]*)$/i', $value);
} }
return filter_var($value, \FILTER_VALIDATE_INT) !== false; return filter_var($value, \FILTER_VALIDATE_INT) !== false;
@ -288,8 +294,8 @@ class Validator
* Validate the length of a string (min) * Validate the length of a string (min)
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @param array $params * @param array $params
* *
* @return bool * @return bool
*/ */
@ -304,8 +310,8 @@ class Validator
* Validate the length of a string (max) * Validate the length of a string (max)
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @param array $params * @param array $params
* *
* @return bool * @return bool
*/ */
@ -375,9 +381,8 @@ class Validator
* Validate the size of a field is between min and max values * Validate the size of a field is between min and max values
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @param array $params * @param array $params
* @return bool * @return bool
*/ */
protected function validateBetween($field, $value, $params) protected function validateBetween($field, $value, $params)
@ -512,7 +517,7 @@ class Validator
* Validate that a field is a valid IP address * Validate that a field is a valid IP address
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @return bool * @return bool
*/ */
protected function validateIp($field, $value) protected function validateIp($field, $value)
@ -521,22 +526,64 @@ class Validator
} }
/** /**
* Validate that a field is a valid e-mail address * Validate that a field is a valid IP v4 address
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @return bool * @return bool
*/ */
protected function validateIpv4($field, $value)
{
return filter_var($value, \FILTER_VALIDATE_IP, \FILTER_FLAG_IPV4) !== false;
}
/**
* Validate that a field is a valid IP v6 address
*
* @param string $field
* @param mixed $value
* @return bool
*/
protected function validateIpv6($field, $value)
{
return filter_var($value, \FILTER_VALIDATE_IP, \FILTER_FLAG_IPV6) !== false;
}
/**
* Validate that a field is a valid e-mail address
*
* @param string $field
* @param mixed $value
* @return bool
*/
protected function validateEmail($field, $value) protected function validateEmail($field, $value)
{ {
return filter_var($value, \FILTER_VALIDATE_EMAIL) !== false; return filter_var($value, \FILTER_VALIDATE_EMAIL) !== false;
} }
/**
* Validate that a field contains only ASCII characters
*
* @param $field
* @param $value
* @return bool|false|string
*/
protected function validateAscii($field, $value)
{
// multibyte extension needed
if (function_exists('mb_detect_encoding')) {
return mb_detect_encoding($value, 'ASCII', true);
}
// fallback with regex
return 0 === preg_match('/[^\x00-\x7F]/', $value);
}
/** /**
* Validate that a field is a valid e-mail address and the domain name is active * Validate that a field is a valid e-mail address and the domain name is active
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @return bool * @return bool
*/ */
protected function validateEmailDNS($field, $value) protected function validateEmailDNS($field, $value)
@ -556,7 +603,7 @@ class Validator
* Validate that a field is a valid URL by syntax * Validate that a field is a valid URL by syntax
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @return bool * @return bool
*/ */
protected function validateUrl($field, $value) protected function validateUrl($field, $value)
@ -574,7 +621,7 @@ class Validator
* Validate that a field is an active URL by verifying DNS record * Validate that a field is an active URL by verifying DNS record
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @return bool * @return bool
*/ */
protected function validateUrlActive($field, $value) protected function validateUrlActive($field, $value)
@ -594,7 +641,7 @@ class Validator
* Validate that a field contains only alphabetic characters * Validate that a field contains only alphabetic characters
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @return bool * @return bool
*/ */
protected function validateAlpha($field, $value) protected function validateAlpha($field, $value)
@ -606,7 +653,7 @@ class Validator
* Validate that a field contains only alpha-numeric characters * Validate that a field contains only alpha-numeric characters
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @return bool * @return bool
*/ */
protected function validateAlphaNum($field, $value) protected function validateAlphaNum($field, $value)
@ -618,7 +665,7 @@ class Validator
* Validate that a field contains only alpha-numeric characters, dashes, and underscores * Validate that a field contains only alpha-numeric characters, dashes, and underscores
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @return bool * @return bool
*/ */
protected function validateSlug($field, $value) protected function validateSlug($field, $value)
@ -633,8 +680,8 @@ class Validator
* Validate that a field passes a regular expression check * Validate that a field passes a regular expression check
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @param array $params * @param array $params
* @return bool * @return bool
*/ */
protected function validateRegex($field, $value, $params) protected function validateRegex($field, $value, $params)
@ -646,7 +693,7 @@ class Validator
* Validate that a field is a valid date * Validate that a field is a valid date
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @return bool * @return bool
*/ */
protected function validateDate($field, $value) protected function validateDate($field, $value)
@ -712,7 +759,7 @@ class Validator
* Validate that a field contains a boolean. * Validate that a field contains a boolean.
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @return bool * @return bool
*/ */
protected function validateBoolean($field, $value) protected function validateBoolean($field, $value)
@ -725,8 +772,8 @@ class Validator
* optionally filtered by an array * optionally filtered by an array
* *
* @param string $field * @param string $field
* @param mixed $value * @param mixed $value
* @param array $params * @param array $params
* @return bool * @return bool
*/ */
protected function validateCreditCard($field, $value, $params) protected function validateCreditCard($field, $value, $params)
@ -742,7 +789,7 @@ class Validator
if (is_array($params[0])) { if (is_array($params[0])) {
$cards = $params[0]; $cards = $params[0];
} elseif (is_string($params[0])) { } elseif (is_string($params[0])) {
$cardType = $params[0]; $cardType = $params[0];
if (isset($params[1]) && is_array($params[1])) { if (isset($params[1]) && is_array($params[1])) {
$cards = $params[1]; $cards = $params[1];
if (!in_array($cardType, $cards)) { if (!in_array($cardType, $cards)) {
@ -765,7 +812,7 @@ class Validator
return false; return false;
} }
for ($i = 0; $i < $strlen; $i++) { for ($i = 0; $i < $strlen; $i++) {
$digit = (int) substr($number, $strlen - $i - 1, 1); $digit = (int)substr($number, $strlen - $i - 1, 1);
if ($i % 2 == 1) { if ($i % 2 == 1) {
$sub_total = $digit * 2; $sub_total = $digit * 2;
if ($sub_total > 9) { if ($sub_total > 9) {
@ -777,7 +824,7 @@ class Validator
$sum += $sub_total; $sum += $sub_total;
} }
if ($sum > 0 && $sum % 10 == 0) { if ($sum > 0 && $sum % 10 == 0) {
return true; return true;
} }
return false; return false;
@ -788,11 +835,11 @@ class Validator
return true; return true;
} else { } else {
$cardRegex = array( $cardRegex = array(
'visa' => '#^4[0-9]{12}(?:[0-9]{3})?$#', 'visa' => '#^4[0-9]{12}(?:[0-9]{3})?$#',
'mastercard' => '#^(5[1-5]|2[2-7])[0-9]{14}$#', 'mastercard' => '#^(5[1-5]|2[2-7])[0-9]{14}$#',
'amex' => '#^3[47][0-9]{13}$#', 'amex' => '#^3[47][0-9]{13}$#',
'dinersclub' => '#^3(?:0[0-5]|[68][0-9])[0-9]{11}$#', 'dinersclub' => '#^3(?:0[0-5]|[68][0-9])[0-9]{11}$#',
'discover' => '#^6(?:011|5[0-9]{2})[0-9]{12}$#', 'discover' => '#^6(?:011|5[0-9]{2})[0-9]{12}$#',
); );
if (isset($cardType)) { if (isset($cardType)) {
@ -973,16 +1020,14 @@ class Validator
return array(null, array_key_exists($identifier, $data)); return array(null, array_key_exists($identifier, $data));
} }
return array(null, false); return array(null, false);
} } // Match array element
// Match array element
elseif (count($identifiers) === 0) { elseif (count($identifiers) === 0) {
if ($allow_empty){ if ($allow_empty) {
//when empty values are allowed, we only care if the key exists //when empty values are allowed, we only care if the key exists
return array(null, array_key_exists($identifier, $data)); return array(null, array_key_exists($identifier, $data));
} }
return array($data[$identifier], false); return array($data[$identifier], $allow_empty);
} } // We need to go deeper
// We need to go deeper
else { else {
return $this->getPart($data[$identifier], $identifiers, $allow_empty); return $this->getPart($data[$identifier], $identifiers, $allow_empty);
} }
@ -995,9 +1040,10 @@ class Validator
*/ */
public function validate() public function validate()
{ {
$set_to_break = false;
foreach ($this->_validations as $v) { foreach ($this->_validations as $v) {
foreach ($v['fields'] as $field) { foreach ($v['fields'] as $field) {
list($values, $multiple) = $this->getPart($this->_fields, explode('.', $field)); list($values, $multiple) = $this->getPart($this->_fields, explode('.', $field), false);
// Don't validate if the field is not required and the value is empty // Don't validate if the field is not required and the value is empty
if ($this->hasRule('optional', $field) && isset($values)) { if ($this->hasRule('optional', $field) && isset($values)) {
@ -1005,7 +1051,7 @@ class Validator
} elseif ( } elseif (
$v['rule'] !== 'required' && !$this->hasRule('required', $field) && $v['rule'] !== 'required' && !$this->hasRule('required', $field) &&
$v['rule'] !== 'accepted' && $v['rule'] !== 'accepted' &&
(! isset($values) || $values === '' || ($multiple && count($values) == 0)) (!isset($values) || $values === '' || ($multiple && count($values) == 0))
) { ) {
continue; continue;
} }
@ -1020,6 +1066,8 @@ class Validator
if (!$multiple) { if (!$multiple) {
$values = array($values); $values = array($values);
} else if (! $this->hasRule('required', $field)){
$values = array_filter($values);
} }
$result = true; $result = true;
@ -1029,13 +1077,27 @@ class Validator
if (!$result) { if (!$result) {
$this->error($field, $v['message'], $v['params']); $this->error($field, $v['message'], $v['params']);
if ($this->stop_on_first_fail) {
$set_to_break = true;
break;
}
} }
} }
if ($set_to_break) break;
} }
return count($this->errors()) === 0; return count($this->errors()) === 0;
} }
/**
* Should the validation stop a rule is failed
* @param bool $stop
*/
public function stopOnFirstFail($stop = true)
{
$this->stop_on_first_fail = (bool)$stop;
}
/** /**
* Returns all rule callbacks, the static and instance ones. * Returns all rule callbacks, the static and instance ones.
* *
@ -1169,7 +1231,8 @@ class Validator
// Get any other arguments passed to function // Get any other arguments passed to function
$params = array_slice(func_get_args(), 2); $params = array_slice(func_get_args(), 2);
if (is_callable($rule) && !(is_string($rule) && $this->hasValidator($rule))) { if (is_callable($rule)
&& !(is_string($rule) && $this->hasValidator($rule))) {
$name = $this->getUniqueRuleName($fields); $name = $this->getUniqueRuleName($fields);
$message = isset($params[0]) ? $params[0] : null; $message = isset($params[0]) ? $params[0] : null;
$this->addInstanceRule($name, $rule, $message); $this->addInstanceRule($name, $rule, $message);
@ -1330,7 +1393,7 @@ class Validator
if (!empty($message)) { if (!empty($message)) {
$added->message($message); $added->message($message);
} }
}, (array) $rules); }, (array)$rules);
} }
/** /**

28
tests/Valitron/StopOnFirstFailTest.php Normal file
View File

@ -0,0 +1,28 @@
<?php
use Valitron\Validator;
class StopOnFirstFail extends BaseTestCase {
public function testStopOnFirstFail() {
$rules = array(
'myField1' => array(
array('lengthMin', 5, 'message'=>'myField1 must be 5 characters minimum'),
array('url', 'message' => 'myField1 is not a valid url'),
array('urlActive', 'message' => 'myField1 is not an active url')
)
);
$v = new Validator(array(
'myField1' => 'myVal'
));
$v->mapFieldsRules($rules);
$v->stopOnFirstFail(true);
$this->assertFalse($v->validate());
$errors = $v->errors();
$this->assertCount(1, $errors['myField1']);
}
}

236
tests/Valitron/ValidateTest.php
View File

@ -1,4 +1,5 @@
<?php <?php
use Valitron\Validator; use Valitron\Validator;
class ValidateTest extends BaseTestCase class ValidateTest extends BaseTestCase
@ -15,12 +16,13 @@ class ValidateTest extends BaseTestCase
$this->assertEquals($v->data(), array('foo' => 'bar')); $this->assertEquals($v->data(), array('foo' => 'bar'));
} }
public function testAccurateErrorCount() public function testAccurateErrorShouldReturnFalse()
{ {
$v = new Validator(array('name' => 'Chester Tester')); $v = new Validator(array('name' => 'Chester Tester'));
$v->rule('required', 'name'); $v->rule('required', 'name');
$this->assertSame(1, count($v->errors('name'))); $this->assertFalse($v->errors('name'));
} }
public function testArrayOfFieldsToValidate() public function testArrayOfFieldsToValidate()
{ {
$v = new Validator(array('name' => 'Chester Tester', 'email' => 'chester@tester.com')); $v = new Validator(array('name' => 'Chester Tester', 'email' => 'chester@tester.com'));
@ -158,7 +160,8 @@ class ValidateTest extends BaseTestCase
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
} }
public function testAcceptedNotSet(){ public function testAcceptedNotSet()
{
$v = new Validator(); $v = new Validator();
$v->rule('accepted', 'agree'); $v->rule('accepted', 'agree');
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
@ -189,25 +192,52 @@ class ValidateTest extends BaseTestCase
$this->assertTrue($v->validate()); $this->assertTrue($v->validate());
} }
public function testIntegerStrict(){ public function testIntegerStrict()
{
$v = new Validator(array('num' => ' 41243')); $v = new Validator(array('num' => ' 41243'));
$v->rule('integer', 'num'); $v->rule('integer', 'num');
$this->assertTrue($v->validate()); $this->assertTrue($v->validate());
$v = new Validator(array('num' => ' 41243')); $v = new Validator(array('num' => ' 41243'));
$v->rule('integer', 'num', true); $v->rule('integer', 'num', true);
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
$v = new Validator(array('num' => '+41243')); $v = new Validator(array('num' => '+41243'));
$v->rule('integer', 'num'); $v->rule('integer', 'num');
$this->assertTrue($v->validate()); $this->assertTrue($v->validate());
$v = new Validator(array('num' => '+41243')); $v = new Validator(array('num' => '+41243'));
$v->rule('integer', 'num', true); $v->rule('integer', 'num', true);
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
$v = new Validator(array('num' => '-1'));
$v->rule('integer', 'num', true);
$this->assertTrue($v->validate());
$v = new Validator(array('num' => '-0'));
$v->rule('integer', 'num', true);
$this->assertFalse($v->validate());
$v = new Validator(array('num' => '0'));
$v->rule('integer', 'num', true);
$this->assertTrue($v->validate());
$v = new Validator(array('num' => '+0'));
$v->rule('integer', 'num', true);
$this->assertFalse($v->validate());
$v = new Validator(array('num' => '+1'));
$v->rule('integer', 'num', true);
$this->assertFalse($v->validate());
$v = new Validator(array('num' => '0123'));
$v->rule('integer', 'num', true);
$this->assertFalse($v->validate());
$v = new Validator(array('num' => '-0123'));
$v->rule('integer', 'num', true);
$this->assertFalse($v->validate());
} }
public function testIntegerInvalid() public function testIntegerInvalid()
@ -216,7 +246,6 @@ class ValidateTest extends BaseTestCase
$v->rule('integer', 'num'); $v->rule('integer', 'num');
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
$v = new Validator(array('num' => '--1231')); $v = new Validator(array('num' => '--1231'));
$v->rule('integer', 'num'); $v->rule('integer', 'num');
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
@ -592,6 +621,20 @@ class ValidateTest extends BaseTestCase
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
} }
public function testAsciiValid()
{
$v = new Validator(array('text' => '12345 abcde'));
$v->rule('ascii', 'text');
$this->assertTrue($v->validate());
}
public function testAsciiInvalid()
{
$v = new Validator(array('text' => '12345 abcdé'));
$v->rule('ascii', 'text');
$this->assertFalse($v->validate());
}
public function testIpValid() public function testIpValid()
{ {
$v = new Validator(array('ip' => '127.0.0.1')); $v = new Validator(array('ip' => '127.0.0.1'));
@ -606,6 +649,34 @@ class ValidateTest extends BaseTestCase
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
} }
public function testIpv4Valid()
{
$v = new Validator(array('ip' => '127.0.0.1'));
$v->rule('ipv4', 'ip');
$this->assertTrue($v->validate());
}
public function testIpv4Invalid()
{
$v = new Validator(array('ip' => 'FE80::0202:B3FF:FE1E:8329'));
$v->rule('ipv4', 'ip');
$this->assertFalse($v->validate());
}
public function testIpv6Valid()
{
$v = new Validator(array('ip' => 'FE80::0202:B3FF:FE1E:8329'));
$v->rule('ipv6', 'ip');
$this->assertTrue($v->validate());
}
public function testIpv6Invalid()
{
$v = new Validator(array('ip' => '127.0.0.1'));
$v->rule('ipv6', 'ip');
$this->assertFalse($v->validate());
}
public function testEmailValid() public function testEmailValid()
{ {
$v = new Validator(array('name' => 'Chester Tester', 'email' => 'chester@tester.com')); $v = new Validator(array('name' => 'Chester Tester', 'email' => 'chester@tester.com'));
@ -620,13 +691,15 @@ class ValidateTest extends BaseTestCase
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
} }
public function testEmailDnsValid(){ public function testEmailDnsValid()
{
$v = new Validator(array('name' => 'Chester Tester', 'email' => 'chester@tester.com')); $v = new Validator(array('name' => 'Chester Tester', 'email' => 'chester@tester.com'));
$v->rule('emailDNS', 'email'); $v->rule('emailDNS', 'email');
$this->assertTrue($v->validate()); $this->assertTrue($v->validate());
} }
public function testEmailDnsInvalid(){ public function testEmailDnsInvalid()
{
$v = new Validator(array('name' => 'Chester Tester', 'email' => 'chester@tester.zyx')); $v = new Validator(array('name' => 'Chester Tester', 'email' => 'chester@tester.zyx'));
$v->rule('emailDNS', 'email'); $v->rule('emailDNS', 'email');
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
@ -793,7 +866,7 @@ class ValidateTest extends BaseTestCase
$v->rule( $v->rule(
'dateBefore', 'dateBefore',
'endDate', 'endDate',
new DateTime('2013-04-08') new DateTime('2013-04-08')
)->label('End date')->message('{field} must be before the end of the fiscal year, %s.'); )->label('End date')->message('{field} must be before the end of the fiscal year, %s.');
$v->rule( $v->rule(
@ -955,7 +1028,7 @@ class ValidateTest extends BaseTestCase
$rules = array( $rules = array(
'required' => 'nonexistent_field', 'required' => 'nonexistent_field',
'accepted' => 'foo', 'accepted' => 'foo',
'integer' => 'foo' 'integer' => 'foo'
); );
$v1 = new Validator(array('foo' => 'bar', 'bar' => 'baz')); $v1 = new Validator(array('foo' => 'bar', 'bar' => 'baz'));
@ -1001,7 +1074,7 @@ class ValidateTest extends BaseTestCase
public function testAcceptBulkRulesWithNestedRules() public function testAcceptBulkRulesWithNestedRules()
{ {
$rules = array( $rules = array(
'length' => array( 'length' => array(
array('foo', 5), array('foo', 5),
array('bar', 5) array('bar', 5)
) )
@ -1022,7 +1095,7 @@ class ValidateTest extends BaseTestCase
public function testAcceptBulkRulesWithNestedRulesAndMultipleFields() public function testAcceptBulkRulesWithNestedRulesAndMultipleFields()
{ {
$rules = array( $rules = array(
'length' => array( 'length' => array(
array(array('foo', 'bar'), 5), array(array('foo', 'bar'), 5),
array('baz', 5) array('baz', 5)
) )
@ -1043,7 +1116,7 @@ class ValidateTest extends BaseTestCase
public function testAcceptBulkRulesWithMultipleArrayParams() public function testAcceptBulkRulesWithMultipleArrayParams()
{ {
$rules = array( $rules = array(
'in' => array( 'in' => array(
array(array('foo', 'bar'), array('x', 'y')) array(array('foo', 'bar'), array('x', 'y'))
) )
); );
@ -1059,15 +1132,16 @@ class ValidateTest extends BaseTestCase
$this->assertEquals($v1->errors(), $v2->errors()); $this->assertEquals($v1->errors(), $v2->errors());
} }
public function testMalformedBulkRules(){ public function testMalformedBulkRules()
$v = new Validator(); {
$v->rules( $v = new Validator();
array( $v->rules(
'required'=>array('foo', 'bar') array(
) 'required' => array('foo', 'bar')
); )
);
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
} }
public function testCustomLabelInMessage() public function testCustomLabelInMessage()
@ -1083,30 +1157,30 @@ class ValidateTest extends BaseTestCase
$v = new Valitron\Validator(array()); $v = new Valitron\Validator(array());
$v->rule('required', array('name', 'email'))->message('{field} is required'); $v->rule('required', array('name', 'email'))->message('{field} is required');
$v->labels(array( $v->labels(array(
'name' => 'Name', 'name' => 'Name',
'email' => 'Email address' 'email' => 'Email address'
)); ));
$v->validate(); $v->validate();
$this->assertEquals(array( $this->assertEquals(array(
'name' => array('Name is required'), 'name' => array('Name is required'),
'email' => array('Email address is required') 'email' => array('Email address is required')
), $v->errors()); ), $v->errors());
} }
public function testCustomLabelArrayWithoutMessage() public function testCustomLabelArrayWithoutMessage()
{ {
$v = new Valitron\Validator(array( $v = new Valitron\Validator(array(
'password' => 'foo', 'password' => 'foo',
'passwordConfirm' => 'bar' 'passwordConfirm' => 'bar'
)); ));
$v->rule('equals', 'password', 'passwordConfirm'); $v->rule('equals', 'password', 'passwordConfirm');
$v->labels(array( $v->labels(array(
'password' => 'Password', 'password' => 'Password',
'passwordConfirm' => 'Password Confirm' 'passwordConfirm' => 'Password Confirm'
)); ));
$v->validate(); $v->validate();
$this->assertEquals(array( $this->assertEquals(array(
'password' => array("Password must be the same as 'Password Confirm'"), 'password' => array("Password must be the same as 'Password Confirm'"),
), $v->errors()); ), $v->errors());
} }
@ -1117,7 +1191,9 @@ class ValidateTest extends BaseTestCase
public function testAddRuleClosure() public function testAddRuleClosure()
{ {
$v = new Validator(array('name' => 'Chester Tester')); $v = new Validator(array('name' => 'Chester Tester'));
$v->addRule('testRule', function() { return true; }); $v->addRule('testRule', function () {
return true;
});
$v->rule('testRule', 'name'); $v->rule('testRule', 'name');
$this->assertTrue($v->validate()); $this->assertTrue($v->validate());
} }
@ -1125,7 +1201,9 @@ class ValidateTest extends BaseTestCase
public function testAddRuleClosureReturnsFalse() public function testAddRuleClosureReturnsFalse()
{ {
$v = new Validator(array('name' => 'Chester Tester')); $v = new Validator(array('name' => 'Chester Tester'));
$v->addRule('testRule', function() { return false; }); $v->addRule('testRule', function () {
return false;
});
$v->rule('testRule', 'name'); $v->rule('testRule', 'name');
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
} }
@ -1133,7 +1211,9 @@ class ValidateTest extends BaseTestCase
public function testAddRuleClosureWithFieldArray() public function testAddRuleClosureWithFieldArray()
{ {
$v = new Validator(array('name' => 'Chester Tester', 'email' => 'foo@example.com')); $v = new Validator(array('name' => 'Chester Tester', 'email' => 'foo@example.com'));
$v->addRule('testRule', function() { return true; }); $v->addRule('testRule', function () {
return true;
});
$v->rule('testRule', array('name', 'email')); $v->rule('testRule', array('name', 'email'));
$this->assertTrue($v->validate()); $this->assertTrue($v->validate());
} }
@ -1141,7 +1221,9 @@ class ValidateTest extends BaseTestCase
public function testAddRuleClosureWithArrayAsExtraParameter() public function testAddRuleClosureWithArrayAsExtraParameter()
{ {
$v = new Validator(array('name' => 'Chester Tester')); $v = new Validator(array('name' => 'Chester Tester'));
$v->addRule('testRule', function() { return true; }); $v->addRule('testRule', function () {
return true;
});
$v->rule('testRule', 'name', array('foo', 'bar')); $v->rule('testRule', 'name', array('foo', 'bar'));
$this->assertTrue($v->validate()); $this->assertTrue($v->validate());
} }
@ -1154,8 +1236,16 @@ class ValidateTest extends BaseTestCase
$this->assertTrue($v->validate()); $this->assertTrue($v->validate());
} }
public function sampleObjectCallback() { return true; } public function sampleObjectCallback()
public function sampleObjectCallbackFalse() { return false; } {
return true;
}
public function sampleObjectCallbackFalse()
{
return false;
}
public function testAddRuleCallbackArray() public function testAddRuleCallbackArray()
{ {
$v = new Validator(array('name' => 'Chester Tester')); $v = new Validator(array('name' => 'Chester Tester'));
@ -1219,14 +1309,14 @@ class ValidateTest extends BaseTestCase
public function testCreditCardValid() public function testCreditCardValid()
{ {
$visa = array(4539511619543489, 4532949059629052, 4024007171194938, 4929646403373269, 4539135861690622); $visa = array(4539511619543489, 4532949059629052, 4024007171194938, 4929646403373269, 4539135861690622);
$mastercard = array(5162057048081965, 5382687859049349, 5484388880142230, 5464941521226434, 5473481232685965, 2223000048400011, 2223520043560014); $mastercard = array(5162057048081965, 5382687859049349, 5484388880142230, 5464941521226434, 5473481232685965, 2223000048400011, 2223520043560014);
$amex = array(371442067262027, 340743030537918, 345509167493596, 343665795576848, 346087552944316); $amex = array(371442067262027, 340743030537918, 345509167493596, 343665795576848, 346087552944316);
$dinersclub = array(30363194756249, 30160097740704, 38186521192206, 38977384214552, 38563220301454); $dinersclub = array(30363194756249, 30160097740704, 38186521192206, 38977384214552, 38563220301454);
$discover = array(6011712400392605, 6011536340491809, 6011785775263015, 6011984124619056, 6011320958064251); $discover = array(6011712400392605, 6011536340491809, 6011785775263015, 6011984124619056, 6011320958064251);
foreach (compact('visa', 'mastercard', 'amex', 'dinersclub', 'discover') as $type => $numbers) { foreach (compact('visa', 'mastercard', 'amex', 'dinersclub', 'discover') as $type => $numbers) {
foreach($numbers as $number) { foreach ($numbers as $number) {
$v = new Validator(array('test' => $number)); $v = new Validator(array('test' => $number));
$v->rule('creditCard', 'test'); $v->rule('creditCard', 'test');
$this->assertTrue($v->validate()); $this->assertTrue($v->validate());
@ -1243,14 +1333,14 @@ class ValidateTest extends BaseTestCase
public function testCreditCardInvalid() public function testCreditCardInvalid()
{ {
$visa = array(3539511619543489, 3532949059629052, 3024007171194938, 3929646403373269, 3539135861690622); $visa = array(3539511619543489, 3532949059629052, 3024007171194938, 3929646403373269, 3539135861690622);
$mastercard = array(4162057048081965, 4382687859049349, 4484388880142230, 4464941521226434, 4473481232685965); $mastercard = array(4162057048081965, 4382687859049349, 4484388880142230, 4464941521226434, 4473481232685965);
$amex = array(271442067262027, 240743030537918, 245509167493596, 243665795576848, 246087552944316); $amex = array(271442067262027, 240743030537918, 245509167493596, 243665795576848, 246087552944316);
$dinersclub = array(20363194756249, 20160097740704, 28186521192206, 28977384214552, 28563220301454); $dinersclub = array(20363194756249, 20160097740704, 28186521192206, 28977384214552, 28563220301454);
$discover = array(5011712400392605, 5011536340491809, 5011785775263015, 5011984124619056, 5011320958064251); $discover = array(5011712400392605, 5011536340491809, 5011785775263015, 5011984124619056, 5011320958064251);
foreach (compact('visa', 'mastercard', 'amex', 'dinersclub', 'discover') as $type => $numbers) { foreach (compact('visa', 'mastercard', 'amex', 'dinersclub', 'discover') as $type => $numbers) {
foreach($numbers as $number) { foreach ($numbers as $number) {
$v = new Validator(array('test' => $number)); $v = new Validator(array('test' => $number));
$v->rule('creditCard', 'test'); $v->rule('creditCard', 'test');
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
@ -1349,29 +1439,29 @@ class ValidateTest extends BaseTestCase
return array( return array(
array( array(
'expected' => 'Test must be at least 140 long', 'expected' => 'Test must be at least 140 long',
'input' => 'tweeet', 'input' => 'tweeet',
'test' => array(140), 'test' => array(140),
'message' => '{field} must be at least %d long', 'message' => '{field} must be at least %d long',
), ),
array( array(
'expected' => 'Test must be between 1 and 140 characters', 'expected' => 'Test must be between 1 and 140 characters',
'input' => array(1, 2, 3), 'input' => array(1, 2, 3),
'test' => array(1, 140), 'test' => array(1, 140),
'message' => 'Test must be between %d and %d characters', 'message' => 'Test must be between %d and %d characters',
), ),
); );
} }
public function testOptionalProvidedValid() public function testOptionalProvidedValid()
{ {
$v = new Validator(array('address' => 'user@example.com')); $v = new Validator(array('address' => 'user@example.com'));
$v->rule('optional', 'address')->rule('email', 'address'); $v->rule('optional', 'address')->rule('email', 'address');
$this->assertTrue($v->validate()); $this->assertTrue($v->validate());
} }
public function testOptionalProvidedInvalid() public function testOptionalProvidedInvalid()
{ {
$v = new Validator(array('address' => 'userexample.com')); $v = new Validator(array('address' => 'userexample.com'));
$v->rule('optional', 'address')->rule('email', 'address'); $v->rule('optional', 'address')->rule('email', 'address');
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
} }
@ -1522,6 +1612,38 @@ class ValidateTest extends BaseTestCase
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
} }
/**
* @see https://github.com/vlucas/valitron/issues/262
*/
public function testOptionalArrayPartsAreIgnored()
{
$v = new Validator(array(
'data' => array(
array('foo' => '2018-01-01'),
array('bar' => 1)
)
)
);
$v->rule('date', 'data.*.foo');
$this->assertTrue($v->validate());
}
/**
* @see https://github.com/vlucas/valitron/issues/262
*/
public function testRequiredArrayPartsAreNotIgnored()
{
$v = new Validator(array(
'data' => array(
array('foo' => '2018-01-01'),
array('bar' => 1)
)
)
);
$v->rule('required', 'data.*.foo');
$v->rule('date', 'data.*.foo');
$this->assertFalse($v->validate());
}
} }
function sampleFunctionCallback($field, $value, array $params) function sampleFunctionCallback($field, $value, array $params)