From d9a466b833ede3c99b804317be75ce3f7cfce6a6 Mon Sep 17 00:00:00 2001 From: misantron Date: Thu, 26 Oct 2017 23:09:45 +0300 Subject: [PATCH] Array contains and unique validators added, code style fixes --- README.md | 2 + src/Valitron/Validator.php | 182 ++++++++++------- tests/Valitron/StaticVsInstanceTest.php | 5 +- .../Valitron/ValidateAddInstanceRuleTest.php | 56 ++--- tests/Valitron/ValidateTest.php | 192 +++++++++++++----- 5 files changed, 278 insertions(+), 159 deletions(-) diff --git a/README.md b/README.md index 0d520fd..d8d0223 100644 --- a/README.md +++ b/README.md @@ -132,6 +132,8 @@ V::lang('ar'); * `dateBefore` - Field is a valid date and is before the given date * `dateAfter` - Field is a valid date and is after the given date * `contains` - Field is a string and contains the given string + * `arrayContains` - Field is an array and contains the given array + * `unique` - Field is an array and contains unique values * `creditCard` - Field is a valid credit card number * `instanceOf` - Field contains an instance of the given class * `optional` - Value does not need to be included in data array. If it is however, it must pass validation. diff --git a/src/Valitron/Validator.php b/src/Valitron/Validator.php index 77305fa..30319f7 100644 --- a/src/Valitron/Validator.php +++ b/src/Valitron/Validator.php @@ -100,7 +100,7 @@ class Validator // Load language file in directory $langFile = rtrim($langDir, '/') . '/' . $lang . '.php'; - if (stream_resolve_include_path($langFile) ) { + if (stream_resolve_include_path($langFile)) { $langMessages = include $langFile; static::$_ruleMessages = array_merge(static::$_ruleMessages, $langMessages); } else { @@ -146,9 +146,9 @@ class Validator * @param array $params * @return bool */ - protected function validateRequired($field, $value, array $params= array(), array $fields = array()) + protected function validateRequired($field, $value, array $params = array()) { - if (isset($params[0]) && (bool) $params[0]){ + if (isset($params[0]) && (bool)$params[0]) { $find = $this->getPart($this->_fields, explode('.', $field), true); return $find[1]; } @@ -168,7 +168,6 @@ class Validator * @param string $field * @param mixed $value * @param array $params - * @internal param array $fields * @return bool */ protected function validateEquals($field, $value, array $params) @@ -184,7 +183,6 @@ class Validator * @param string $field * @param mixed $value * @param array $params - * @internal param array $fields * @return bool */ protected function validateDifferent($field, $value, array $params) @@ -244,7 +242,7 @@ class Validator */ protected function validateInteger($field, $value, $params) { - if (isset($params[0]) && (bool) $params[0]){ + if (isset($params[0]) && (bool)$params[0]) { //strict mode return preg_match('/^-?([0-9])+$/i', $value); } @@ -258,7 +256,6 @@ class Validator * @param string $field * @param mixed $value * @param array $params - * @internal param array $fields * @return bool */ protected function validateLength($field, $value, $params) @@ -278,7 +275,7 @@ class Validator * @param string $field * @param mixed $value * @param array $params - * @return boolean + * @return bool */ protected function validateLengthBetween($field, $value, $params) { @@ -294,7 +291,7 @@ class Validator * @param mixed $value * @param array $params * - * @return boolean + * @return bool */ protected function validateLengthMin($field, $value, $params) { @@ -310,7 +307,7 @@ class Validator * @param mixed $value * @param array $params * - * @return boolean + * @return bool */ protected function validateLengthMax($field, $value, $params) { @@ -342,7 +339,6 @@ class Validator * @param string $field * @param mixed $value * @param array $params - * @internal param array $fields * @return bool */ protected function validateMin($field, $value, $params) @@ -362,7 +358,6 @@ class Validator * @param string $field * @param mixed $value * @param array $params - * @internal param array $fields * @return bool */ protected function validateMax($field, $value, $params) @@ -405,7 +400,6 @@ class Validator * @param string $field * @param mixed $value * @param array $params - * @internal param array $fields * @return bool */ protected function validateIn($field, $value, $params) @@ -429,7 +423,6 @@ class Validator * @param string $field * @param mixed $value * @param array $params - * @internal param array $fields * @return bool */ protected function validateNotIn($field, $value, $params) @@ -441,7 +434,7 @@ class Validator * Validate a field contains a given string * * @param string $field - * @param mixed $value + * @param string $value * @param array $params * @return bool */ @@ -456,10 +449,9 @@ class Validator $strict = true; if (isset($params[1])) { - $strict = (bool) $params[1]; + $strict = (bool)$params[1]; } - $isContains = false; if ($strict) { if (function_exists('mb_strpos')) { $isContains = mb_strpos($value, $params[0]) !== false; @@ -476,6 +468,43 @@ class Validator return $isContains; } + /** + * Validate that all field values contains a given array + * + * @param string $field + * @param array $value + * @param array $params + * @return bool + */ + protected function validateArrayContains($field, $value, $params) + { + if (!isset($params[0])) { + return false; + } + if (!is_array($value) || !is_array($params[0])) { + return false; + } + + $intersect = array_intersect($value, $params[0]); + return array_diff($value, $intersect) === array_diff($intersect, $value); + } + + /** + * Validate that field array has only unique values + * + * @param string $field + * @param array $value + * @return bool + */ + protected function validateUnique($field, $value) + { + if (!is_array($value)) { + return false; + } + + return $value === array_unique($value, SORT_REGULAR); + } + /** * Validate that a field is a valid IP address * @@ -571,7 +600,7 @@ class Validator */ protected function validateSlug($field, $value) { - if(is_array($value)) { + if (is_array($value)) { return false; } return preg_match('/^([-a-z0-9_-])+$/i', $value); @@ -615,7 +644,6 @@ class Validator * @param string $field * @param mixed $value * @param array $params - * @internal param array $fields * @return bool */ protected function validateDateFormat($field, $value, $params) @@ -631,7 +659,6 @@ class Validator * @param string $field * @param mixed $value * @param array $params - * @internal param array $fields * @return bool */ protected function validateDateBefore($field, $value, $params) @@ -648,7 +675,6 @@ class Validator * @param string $field * @param mixed $value * @param array $params - * @internal param array $fields * @return bool */ protected function validateDateAfter($field, $value, $params) @@ -802,7 +828,8 @@ class Validator } //Validate optional field - protected function validateOptional($field, $value, $params) { + protected function validateOptional($field, $value, $params) + { //Always return true return true; } @@ -836,12 +863,12 @@ class Validator * Add an error to error messages array * * @param string $field - * @param string $msg + * @param string $message * @param array $params */ - public function error($field, $msg, array $params = array()) + public function error($field, $message, array $params = array()) { - $msg = $this->checkAndSetLabel($field, $msg, $params); + $message = $this->checkAndSetLabel($field, $message, $params); $values = array(); // Printed values need to be in string format @@ -865,18 +892,18 @@ class Validator $values[] = $param; } - $this->_errors[$field][] = vsprintf($msg, $values); + $this->_errors[$field][] = vsprintf($message, $values); } /** * Specify validation message to use for error for the last validation rule * - * @param string $msg - * @return $this + * @param string $message + * @return Validator */ - public function message($msg) + public function message($message) { - $this->_validations[count($this->_validations) - 1]['message'] = $msg; + $this->_validations[count($this->_validations) - 1]['message'] = $message; return $this; } @@ -941,7 +968,7 @@ class Validator /** * Run validations and return boolean result * - * @return boolean + * @return bool */ public function validate() { @@ -1011,9 +1038,8 @@ class Validator * * @param string $name The name of the rule * @param string $field The name of the field - * @return boolean + * @return bool */ - protected function hasRule($name, $field) { foreach ($this->_validations as $validation) { @@ -1030,17 +1056,18 @@ class Validator protected static function assertRuleCallback($callback) { if (!is_callable($callback)) { - throw new \InvalidArgumentException('Second argument must be a valid callback. Given argument was not callable.'); + throw new \InvalidArgumentException( + 'Second argument must be a valid callback. Given argument was not callable.' + ); } } - /** * Adds a new validation rule callback that is tied to the current * instance only. * * @param string $name - * @param mixed $callback + * @param mixed $callback * @param string $message * @throws \InvalidArgumentException */ @@ -1073,18 +1100,20 @@ class Validator static::$_ruleMessages[$name] = $message; } + /** + * @param mixed $fields + * @return string + */ public function getUniqueRuleName($fields) { - if (is_array($fields)) - { + if (is_array($fields)) { $fields = implode("_", $fields); } $orgName = "{$fields}_rule"; $name = $orgName; $rules = $this->getRules(); - while (isset($rules[$name])) - { + while (isset($rules[$name])) { $name = $orgName . "_" . rand(0, 10000); } @@ -1095,7 +1124,7 @@ class Validator * Returns true if either a valdiator with the given name has been * registered or there is a default validator by that name. * - * @param string $name + * @param string $name * @return bool */ public function hasValidator($name) @@ -1110,7 +1139,7 @@ class Validator * * @param string|callback $rule * @param array|string $fields - * @return $this + * @return Validator * @throws \InvalidArgumentException */ public function rule($rule, $fields) @@ -1118,12 +1147,10 @@ class Validator // Get any other arguments passed to function $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); - $msg = isset($params[0]) ? $params[0] : null; - $this->addInstanceRule($name, $rule, $msg); + $message = isset($params[0]) ? $params[0] : null; + $this->addInstanceRule($name, $rule, $message); $rule = $name; } @@ -1131,13 +1158,15 @@ class Validator if (!isset($errors[$rule])) { $ruleMethod = 'validate' . ucfirst($rule); if (!method_exists($this, $ruleMethod)) { - throw new \InvalidArgumentException("Rule '" . $rule . "' has not been registered with " . __CLASS__ . "::addRule()."); + throw new \InvalidArgumentException( + "Rule '" . $rule . "' has not been registered with " . __CLASS__ . "::addRule()." + ); } } // Ensure rule has an accompanying message - $msgs = $this->getRuleMessages(); - $message = isset($msgs[$rule]) ? $msgs[$rule] : self::ERROR_DEFAULT; + $messages = $this->getRuleMessages(); + $message = isset($messages[$rule]) ? $messages[$rule] : self::ERROR_DEFAULT; // Ensure message contains field label if (function_exists('mb_strpos')) { @@ -1151,8 +1180,8 @@ class Validator $this->_validations[] = array( 'rule' => $rule, - 'fields' => (array) $fields, - 'params' => (array) $params, + 'fields' => (array)$fields, + 'params' => (array)$params, 'message' => $message ); @@ -1161,8 +1190,7 @@ class Validator /** * @param string $value - * @internal param array $labels - * @return $this + * @return Validator */ public function label($value) { @@ -1174,7 +1202,7 @@ class Validator /** * @param array $labels - * @return $this + * @return Validator */ public function labels($labels = array()) { @@ -1185,29 +1213,29 @@ class Validator /** * @param string $field - * @param string $msg + * @param string $message * @param array $params * @return array */ - protected function checkAndSetLabel($field, $msg, $params) + protected function checkAndSetLabel($field, $message, $params) { if (isset($this->_labels[$field])) { - $msg = str_replace('{field}', $this->_labels[$field], $msg); + $message = str_replace('{field}', $this->_labels[$field], $message); if (is_array($params)) { $i = 1; foreach ($params as $k => $v) { - $tag = '{field'. $i .'}'; + $tag = '{field' . $i . '}'; $label = isset($params[$k]) && (is_numeric($params[$k]) || is_string($params[$k])) && isset($this->_labels[$params[$k]]) ? $this->_labels[$params[$k]] : $tag; - $msg = str_replace($tag, $label, $msg); + $message = str_replace($tag, $label, $message); $i++; } } } else { - $msg = str_replace('{field}', ucwords(str_replace('_', ' ', $field)), $msg); + $message = str_replace('{field}', ucwords(str_replace('_', ' ', $field)), $message); } - return $msg; + return $message; } /** @@ -1220,8 +1248,8 @@ class Validator foreach ($rules as $ruleType => $params) { if (is_array($params)) { foreach ($params as $innerParams) { - if (! is_array($innerParams)){ - $innerParams = (array) $innerParams; + if (!is_array($innerParams)) { + $innerParams = (array)$innerParams; } array_unshift($innerParams, $ruleType); call_user_func_array(array($this, 'rule'), $innerParams); @@ -1237,7 +1265,7 @@ class Validator * * @param array $data * @param array $fields - * @return \Valitron\Validator + * @return Validator */ public function withData($data, $fields = array()) { @@ -1250,29 +1278,30 @@ class Validator /** * Convenience method to add validation rule(s) by field * - * @param string field_name - * @param array $rules + * @param string $field + * @param array $rules */ - public function mapFieldRules($field_name, $rules){ + public function mapFieldRules($field, $rules) + { $me = $this; - array_map(function($rule) use($field_name, $me){ + array_map(function ($rule) use ($field, $me) { //rule must be an array $rule = (array)$rule; //First element is the name of the rule - $rule_name = array_shift($rule); + $ruleName = array_shift($rule); //find a custom message, if any $message = null; - if (isset($rule['message'])){ + if (isset($rule['message'])) { $message = $rule['message']; unset($rule['message']); } //Add the field and additional parameters to the rule - $added = call_user_func_array(array($me, 'rule'), array_merge(array($rule_name, $field_name), $rule)); - if (! empty($message)){ + $added = call_user_func_array(array($me, 'rule'), array_merge(array($ruleName, $field), $rule)); + if (!empty($message)) { $added->message($message); } }, (array) $rules); @@ -1283,10 +1312,11 @@ class Validator * * @param array $rules */ - public function mapFieldsRules($rules){ + public function mapFieldsRules($rules) + { $me = $this; - array_map(function($field_name) use($rules, $me){ - $me->mapFieldRules($field_name, $rules[$field_name]); + array_map(function ($field) use ($rules, $me) { + $me->mapFieldRules($field, $rules[$field]); }, array_keys($rules)); } } diff --git a/tests/Valitron/StaticVsInstanceTest.php b/tests/Valitron/StaticVsInstanceTest.php index 1601189..174334c 100644 --- a/tests/Valitron/StaticVsInstanceTest.php +++ b/tests/Valitron/StaticVsInstanceTest.php @@ -7,8 +7,9 @@ class StaticVsInstanceTest extends BaseTestCase { Validator::lang('ar'); new Validator(array(), array(), 'en'); - $this->assertEquals('ar', Validator::lang(), - 'instance defined lang should not replace static global lang'); + $this->assertEquals( + 'ar', Validator::lang(), 'instance defined lang should not replace static global lang' + ); } /** diff --git a/tests/Valitron/ValidateAddInstanceRuleTest.php b/tests/Valitron/ValidateAddInstanceRuleTest.php index ddefac3..03cf5cb 100644 --- a/tests/Valitron/ValidateAddInstanceRuleTest.php +++ b/tests/Valitron/ValidateAddInstanceRuleTest.php @@ -1,21 +1,23 @@ validate(); - foreach ($v->errors() as $label => $messages) - { - foreach ($messages as $theMessage) - { + foreach ($v->errors() as $label => $messages) { + foreach ($messages as $theMessage) { $msg .= "\n\t{$label}: {$theMessage}"; } } @@ -30,13 +32,11 @@ class ValidateAddInstanceRuleTest extends BaseTestCase "fuzz" => "bazz", )); - $v->addInstanceRule("fooRule", function($field, $value) - { + $v->addInstanceRule("fooRule", function ($field, $value) { return $field !== "foo" || $value !== "barz"; }); - Validator::addRule("fuzzerRule", function($field, $value) - { + Validator::addRule("fuzzerRule", function ($field, $value) { return $field !== "fuzz" || $value === "bazz"; }); @@ -50,8 +50,7 @@ class ValidateAddInstanceRuleTest extends BaseTestCase public function testAddInstanceRuleFail() { $v = new Validator(array("foo" => "bar")); - $v->addInstanceRule("fooRule", function($field) - { + $v->addInstanceRule("fooRule", function ($field) { return $field === "for"; }); $v->rule("fooRule", "foo"); @@ -61,7 +60,7 @@ class ValidateAddInstanceRuleTest extends BaseTestCase public function testAddAddRuleWithCallback() { $v = new Validator(array("foo" => "bar")); - $v->rule(function($field, $value) { + $v->rule(function ($field, $value) { return $field === "foo" && $value === "bar"; }, "foo"); @@ -71,7 +70,7 @@ class ValidateAddInstanceRuleTest extends BaseTestCase public function testAddAddRuleWithCallbackFail() { $v = new Validator(array("foo" => "baz")); - $v->rule(function($field, $value) { + $v->rule(function ($field, $value) { return $field === "foo" && $value === "bar"; }, "foo"); @@ -81,30 +80,30 @@ class ValidateAddInstanceRuleTest extends BaseTestCase public function testAddAddRuleWithCallbackFailMessage() { $v = new Validator(array("foo" => "baz")); - $v->rule(function($field, $value) { + $v->rule(function ($field, $value) { return $field === "foo" && $value === "bar"; }, "foo", "test error message"); $this->assertFalse($v->validate()); - $errors = $v->errors(); + $errors = $v->errors(); $this->assertArrayHasKey("foo", $errors); $this->assertCount(1, $errors["foo"]); $this->assertEquals("Foo test error message", $errors["foo"][0]); } - public function testAddRuleWithNamedCallbackOk() - { - $v = new Validator(array("bar" => "foo")); - $v->rule("callbackTestFunction", "bar"); - $this->assertFalse($v->validate()); - } + public function testAddRuleWithNamedCallbackOk() + { + $v = new Validator(array("bar" => "foo")); + $v->rule("callbackTestFunction", "bar"); + $this->assertFalse($v->validate()); + } - public function testAddRuleWithNamedCallbackErr() - { - $v = new Validator(array("foo" => "bar")); - $v->rule("callbackTestFunction", "foo"); - $this->assertTrue($v->validate()); - } + public function testAddRuleWithNamedCallbackErr() + { + $v = new Validator(array("foo" => "bar")); + $v->rule("callbackTestFunction", "foo"); + $this->assertTrue($v->validate()); + } public function testUniqueRuleName() { @@ -113,7 +112,8 @@ class ValidateAddInstanceRuleTest extends BaseTestCase $this->assertEquals("foo_bar_rule", $v->getUniqueRuleName($args)); $this->assertEquals("foo_rule", $v->getUniqueRuleName("foo")); - $v->addInstanceRule("foo_rule", function() {}); + $v->addInstanceRule("foo_rule", function () { + }); $u = $v->getUniqueRuleName("foo"); $this->assertRegExp("/^foo_rule_[0-9]{1,5}$/", $u); } diff --git a/tests/Valitron/ValidateTest.php b/tests/Valitron/ValidateTest.php index 6abdf6e..1ef30fa 100644 --- a/tests/Valitron/ValidateTest.php +++ b/tests/Valitron/ValidateTest.php @@ -768,14 +768,14 @@ class ValidateTest extends BaseTestCase $this->assertTrue($v->validate()); } - public function testContainsNotFound() + public function testContainsInvalid() { $v = new Validator(array('test_string' => 'this is a test')); $v->rule('contains', 'test_string', 'foobar'); $this->assertFalse($v->validate()); } - public function testContainsStrictNotFound() + public function testContainsStrictInvalid() { $v = new Validator(array('test_string' => 'this is a Test')); $v->rule('contains', 'test_string', 'test'); @@ -783,9 +783,93 @@ class ValidateTest extends BaseTestCase } public function testContainsInvalidValue() + { + $v = new Validator(array('test_string' => false)); + $v->rule('contains', 'test_string', 'foobar'); + $this->assertFalse($v->validate()); + } + + public function testContainsInvalidRule() { $v = new Validator(array('test_string' => 'this is a test')); - $v->rule('contains', 'test_string', array('test')); + $v->rule('contains', 'test_string', null); + $this->assertFalse($v->validate()); + } + + public function testArrayContainsValid() + { + // numeric values + $v = new Validator(array('test_field' => array(81, 3, 15))); + $v->rule('arrayContains', 'test_field', array(45, 15, 3, 7, 28, 81)); + $this->assertTrue($v->validate()); + + // string values + $v = new Validator(array('test_field' => array('white', 'green', 'blue'))); + $v->rule('arrayContains', 'test_field', array('green', 'orange', 'blue', 'yellow', 'white', 'brown')); + $this->assertTrue($v->validate()); + + // mixed values + $v = new Validator(array('test_field' => array(81, false, 'orange'))); + $v->rule('arrayContains', 'test_field', array(45, 'green', true, 'orange', null, 81, false)); + $this->assertTrue($v->validate()); + } + + public function testArrayContainsInvalid() + { + $v = new Validator(array('test_field' => array(81, false, 'orange'))); + $v->rule('arrayContains', 'test_field', array(45, 'green', true, 'orange', null, false, 7)); + $this->assertFalse($v->validate()); + } + + public function testArrayContainsInvalidValue() + { + $v = new Validator(array('test_field' => 'black 45')); + $v->rule('arrayContains', 'test_field', array('black', 45)); + $this->assertFalse($v->validate()); + } + + public function testArrayContainsInvalidRule() + { + // rule value has invalid type + $v = new Validator(array('test_field' => array('black', 45))); + $v->rule('arrayContains', 'test_field', 'black 45'); + $this->assertFalse($v->validate()); + + // rule value not specified + $v = new Validator(array('test_field' => array('black', 45))); + $v->rule('arrayContains', 'test_field'); + $this->assertFalse($v->validate()); + } + + public function testUniqueValid() + { + // numeric values + $v = new Validator(array('test_field' => array(81, 3, 15))); + $v->rule('unique', 'test_field'); + $this->assertTrue($v->validate()); + + // string values + $v = new Validator(array('test_field' => array('white', 'green', 'blue'))); + $v->rule('unique', 'test_field'); + $this->assertTrue($v->validate()); + + // mixed values + $v = new Validator(array('test_field' => array(81, false, 'orange'))); + $v->rule('unique', 'test_field'); + $this->assertTrue($v->validate()); + } + + public function testUniqueInvalid() + { + $v = new Validator(array('test_field' => array(81, false, 'orange', false))); + $v->rule('unique', 'test_field'); + $this->assertFalse($v->validate()); + } + + public function testUniqueInvalidValue() + { + $v = new Validator(array('test_field' => 'lorem ipsum')); + $v->rule('unique', 'test_field'); $this->assertFalse($v->validate()); } @@ -1110,66 +1194,66 @@ class ValidateTest extends BaseTestCase public function testInstanceOfValidWithString() { - $v = new Validator(array('attributeName' => new stdClass())); - $v->rule('instanceOf', 'attributeName', 'stdClass'); - $this->assertTrue($v->validate()); + $v = new Validator(array('attributeName' => new stdClass())); + $v->rule('instanceOf', 'attributeName', 'stdClass'); + $this->assertTrue($v->validate()); } public function testInstanceOfInvalidWithInstance() { - $v = new Validator(array('attributeName' => new stdClass())); - $v->rule('instanceOf', 'attributeName', new Validator(array())); - $this->assertFalse($v->validate()); + $v = new Validator(array('attributeName' => new stdClass())); + $v->rule('instanceOf', 'attributeName', new Validator(array())); + $this->assertFalse($v->validate()); } public function testInstanceOfValidWithInstance() { - $v = new Validator(array('attributeName' => new stdClass())); - $v->rule('instanceOf', 'attributeName', new stdClass()); - $this->assertTrue($v->validate()); + $v = new Validator(array('attributeName' => new stdClass())); + $v->rule('instanceOf', 'attributeName', new stdClass()); + $this->assertTrue($v->validate()); } public function testInstanceOfErrorMessageShowsInstanceName() { - $v = new Validator(array('attributeName' => new Validator(array()))); - $v->rule('instanceOf', 'attributeName', new stdClass()); - $v->validate(); - $expected_error = array( - "attributeName" => array( - "AttributeName must be an instance of 'stdClass'" - ) - ); - $this->assertEquals($expected_error, $v->errors()); + $v = new Validator(array('attributeName' => new Validator(array()))); + $v->rule('instanceOf', 'attributeName', new stdClass()); + $v->validate(); + $expected_error = array( + "attributeName" => array( + "AttributeName must be an instance of 'stdClass'" + ) + ); + $this->assertEquals($expected_error, $v->errors()); } public function testInstanceOfInvalidWithString() { - $v = new Validator(array('attributeName' => new stdClass())); - $v->rule('instanceOf', 'attributeName', 'SomeOtherClass'); - $this->assertFalse($v->validate()); + $v = new Validator(array('attributeName' => new stdClass())); + $v->rule('instanceOf', 'attributeName', 'SomeOtherClass'); + $this->assertFalse($v->validate()); } public function testInstanceOfWithAlternativeSyntaxValid() { - $v = new Validator(array('attributeName' => new stdClass())); - $v->rules(array( - 'instanceOf' => array( - array('attributeName', 'stdClass') - ) - )); - $this->assertTrue($v->validate()); + $v = new Validator(array('attributeName' => new stdClass())); + $v->rules(array( + 'instanceOf' => array( + array('attributeName', 'stdClass') + ) + )); + $this->assertTrue($v->validate()); } public function testInstanceOfWithAlternativeSyntaxInvalid() { - $v = new Validator(array('attributeName' => new stdClass())); - $v->rules(array( - 'instanceOf' => array( - array('attributeName', 'SomeOtherClassInAlternativeSyntaxInvalid') - ) - )); - $v->validate(); - $this->assertFalse($v->validate()); + $v = new Validator(array('attributeName' => new stdClass())); + $v->rules(array( + 'instanceOf' => array( + array('attributeName', 'SomeOtherClassInAlternativeSyntaxInvalid') + ) + )); + $v->validate(); + $this->assertFalse($v->validate()); } /** @@ -1244,35 +1328,37 @@ class ValidateTest extends BaseTestCase public function testRequiredEdgeCases() { $v = new Validator(array( - 'zero'=>0, - 'zero_txt' => '0', - 'false'=>false, - 'empty_array'=>array() - )); + 'zero' => 0, + 'zero_txt' => '0', + 'false' => false, + 'empty_array' => array() + )); $v->rule('required', array('zero', 'zero_txt', 'false', 'empty_array')); $this->assertTrue($v->validate()); } - public function testRequiredAllowEmpty(){ - $data= array( - 'empty_text'=>'', + public function testRequiredAllowEmpty() + { + $data = array( + 'empty_text' => '', 'null_value' => null, - 'in_array'=>array( - 'empty_text'=>'' + 'in_array' => array( + 'empty_text' => '' ) ); - $v1= new Validator($data); + $v1 = new Validator($data); $v1->rule('required', array('empty_text', 'null_value', 'in_array.empty_text')); $this->assertFalse($v1->validate()); - $v2= new Validator($data); + $v2 = new Validator($data); $v2->rule('required', array('empty_text', 'null_value', 'in_array.empty_text')); $this->assertFalse($v2->validate()); } } -function sampleFunctionCallback($field, $value, array $params) { - return true; +function sampleFunctionCallback($field, $value, array $params) +{ + return true; }