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

Indent fixed

Browse Source
This commit is contained in:
Matteo Kloiber 2016-11-06 01:46:28 +01:00
parent 7a5fd66990
commit 74a882969e
2 changed files with 111 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
src/Valitron/Validator.php
View File

@ -1037,10 +1037,10 @@ class Validator
*/ */
public static function addRule($name, $callback, $message = null) public static function addRule($name, $callback, $message = null)
{ {
if ($message === null) if ($message === null)
{ {
$message = static::ERROR_DEFAULT; $message = static::ERROR_DEFAULT;
} }
static::assertRuleCallback($callback); static::assertRuleCallback($callback);
@ -1048,23 +1048,23 @@ class Validator
static::$_ruleMessages[$name] = $message; static::$_ruleMessages[$name] = $message;
} }
public function getUniqueRuleName($fields) public function getUniqueRuleName($fields)
{ {
if (is_array($fields)) if (is_array($fields))
{ {
$fields = implode("_", $fields); $fields = implode("_", $fields);
} }
$orgName = "{$fields}_rule"; $orgName = "{$fields}_rule";
$name = $orgName; $name = $orgName;
$rules = $this->getRules(); $rules = $this->getRules();
while (isset($rules[$name])) while (isset($rules[$name]))
{ {
$name = $orgName . "_" . rand(0, 10000); $name = $orgName . "_" . rand(0, 10000);
} }
return $name; return $name;
} }
/** /**
* Convenience method to add a single validation rule * Convenience method to add a single validation rule
@ -1079,19 +1079,19 @@ 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);
// Note: we cannot use is_callable here since max, int, and many // Note: we cannot use is_callable here since max, int, and many
// other string can also be callables but aren't really rule callbacks. // other string can also be callables but aren't really rule callbacks.
// //
// If a closure is used, we can be sure that the user actually // If a closure is used, we can be sure that the user actually
// wants $rule to be a custom rule check. // wants $rule to be a custom rule check.
if (is_object($rule) && ($rule instanceof \Closure)) if (is_object($rule) && ($rule instanceof \Closure))
{ {
$name = $this->getUniqueRuleName($fields); $name = $this->getUniqueRuleName($fields);
$msg = isset($params[0]) ? $params[0] : null; $msg = isset($params[0]) ? $params[0] : null;
$this->addInstanceRule($name, $rule, $msg); $this->addInstanceRule($name, $rule, $msg);
$rule = $name; $rule = $name;
} }
$errors = $this->getRules(); $errors = $this->getRules();
if (!isset($errors[$rule])) { if (!isset($errors[$rule])) {
$ruleMethod = 'validate' . ucfirst($rule); $ruleMethod = 'validate' . ucfirst($rule);

158
tests/Valitron/ValidateAddInstanceRuleTest.php
View File

@ -3,99 +3,99 @@ use Valitron\Validator;
class ValidateAddInstanceRuleTest extends BaseTestCase class ValidateAddInstanceRuleTest extends BaseTestCase
{ {
protected function assertValid($v) protected function assertValid($v)
{ {
$msg = "\tErrors:\n"; $msg = "\tErrors:\n";
$status = $v->validate(); $status = $v->validate();
foreach ($v->errors() as $label => $messages) foreach ($v->errors() as $label => $messages)
{ {
foreach ($messages as $theMessage) foreach ($messages as $theMessage)
{ {
$msg .= "\n\t{$label}: {$theMessage}"; $msg .= "\n\t{$label}: {$theMessage}";
} }
} }
$this->assertTrue($v->validate(), $msg); $this->assertTrue($v->validate(), $msg);
} }
public function testAddInstanceRule() public function testAddInstanceRule()
{ {
$v = new Validator(array( $v = new Validator(array(
"foo" => "bar", "foo" => "bar",
"fuzz" => "bazz", "fuzz" => "bazz",
)); ));
$v->addInstanceRule("fooRule", function($field, $value) $v->addInstanceRule("fooRule", function($field, $value)
{ {
return $field !== "foo" || $value !== "barz"; return $field !== "foo" || $value !== "barz";
}); });
Validator::addRule("fuzzerRule", function($field, $value) Validator::addRule("fuzzerRule", function($field, $value)
{ {
return $field !== "fuzz" || $value === "bazz"; return $field !== "fuzz" || $value === "bazz";
}); });
$v->rule("required", array("foo", "fuzz")); $v->rule("required", array("foo", "fuzz"));
$v->rule("fuzzerRule", "fuzz"); $v->rule("fuzzerRule", "fuzz");
$v->rule("fooRule", "foo"); $v->rule("fooRule", "foo");
$this->assertValid($v); $this->assertValid($v);
} }
public function testAddInstanceRuleFail() public function testAddInstanceRuleFail()
{ {
$v = new Validator(array("foo" => "bar")); $v = new Validator(array("foo" => "bar"));
$v->addInstanceRule("fooRule", function($field) $v->addInstanceRule("fooRule", function($field)
{ {
return $field === "for"; return $field === "for";
}); });
$v->rule("fooRule", "foo"); $v->rule("fooRule", "foo");
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
} }
public function testAddAddRuleWithCallback() public function testAddAddRuleWithCallback()
{ {
$v = new Validator(array("foo" => "bar")); $v = new Validator(array("foo" => "bar"));
$v->rule(function($field, $value) { $v->rule(function($field, $value) {
return $field === "foo" && $value === "bar"; return $field === "foo" && $value === "bar";
}, "foo"); }, "foo");
$this->assertValid($v); $this->assertValid($v);
} }
public function testAddAddRuleWithCallbackFail() public function testAddAddRuleWithCallbackFail()
{ {
$v = new Validator(array("foo" => "baz")); $v = new Validator(array("foo" => "baz"));
$v->rule(function($field, $value) { $v->rule(function($field, $value) {
return $field === "foo" && $value === "bar"; return $field === "foo" && $value === "bar";
}, "foo"); }, "foo");
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
} }
public function testAddAddRuleWithCallbackFailMessage() public function testAddAddRuleWithCallbackFailMessage()
{ {
$v = new Validator(array("foo" => "baz")); $v = new Validator(array("foo" => "baz"));
$v->rule(function($field, $value) { $v->rule(function($field, $value) {
return $field === "foo" && $value === "bar"; return $field === "foo" && $value === "bar";
}, "foo", "test error message"); }, "foo", "test error message");
$this->assertFalse($v->validate()); $this->assertFalse($v->validate());
$errors = $v->errors(); $errors = $v->errors();
$this->assertArrayHasKey("foo", $errors); $this->assertArrayHasKey("foo", $errors);
$this->assertCount(1, $errors["foo"]); $this->assertCount(1, $errors["foo"]);
$this->assertEquals("Foo test error message", $errors["foo"][0]); $this->assertEquals("Foo test error message", $errors["foo"][0]);
} }
public function testUniqueRuleName() public function testUniqueRuleName()
{ {
$v = new Validator(array()); $v = new Validator(array());
$args = array("foo", "bar"); $args = array("foo", "bar");
$this->assertEquals("foo_bar_rule", $v->getUniqueRuleName($args)); $this->assertEquals("foo_bar_rule", $v->getUniqueRuleName($args));
$this->assertEquals("foo_rule", $v->getUniqueRuleName("foo")); $this->assertEquals("foo_rule", $v->getUniqueRuleName("foo"));
$v->addInstanceRule("foo_rule", function() {}); $v->addInstanceRule("foo_rule", function() {});
$u = $v->getUniqueRuleName("foo"); $u = $v->getUniqueRuleName("foo");
$this->assertRegExp("/^foo_rule_[0-9]{1,5}$/", $u); $this->assertRegExp("/^foo_rule_[0-9]{1,5}$/", $u);
} }
} }