Merge pull request #22 from rakit/rule-callback

Adding Rule Callback

Author: emsifa

README.md

@@ -293,6 +293,7 @@ Below is list of all available validation rules
 * [different](#rule-different)
 * [after](#after)
 * [before](#before)
+* [callback](#callback)
 
 <a id="rule-required"></a>
 #### required
@@ -489,10 +490,54 @@ Anything that can be parsed by `strtotime` can be passed as a parameter to this
 
 This also works the same way as the [after rule](#after). Pass anything that can be parsed by `strtotime`
 
+<a id="callback"></a>
+#### callback
+
+You can use this rule to define your own validation rule.
+This rule can't be registered using string pipe.
+To use this rule, you should put Closure inside array of rules.
+
+For example:
+
+```php
+$validation = $validator->validate($_POST, [
+    'even_number' => [
+        'required',
+        function ($value) {
+            // false = invalid
+            return (is_numeric($value) AND $value % 2 === 0);
+        }
+    ]
+]);
+```
+
+You can set invalid message by returning a string. 
+For example, example above would be:
+
+```php
+$validation = $validator->validate($_POST, [
+    'even_number' => [
+        'required',
+        function ($value) {
+            if (!is_numeric($value)) {
+                return ":attribute must be numeric.";
+            }
+            if ($value % 2 !== 0) {
+                return ":attribute is not even number.";
+            }
+            // you can return true or don't return anything if value is valid
+        }
+    ]
+]);
+```
+
+> Note: `Rakit\Validation\Rules\Callback` instance is binded into your Closure. 
+  So you can access rule properties and methods using `$this`.
+
 ## Register/Modify Rule
 
-To create your own validation rule, you need to create a class extending `Rakit\Validation\Rule` 
-then register it using `setValidator` or `addValidator`.
+Another way to use custom validation rule is to create a class extending `Rakit\Validation\Rule`. 
+Then register it using `setValidator` or `addValidator`.
 
 For example, you want to create `unique` validator that check field availability from database. 
 

src/Rules/Callback.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace Rakit\Validation\Rules;
+
+use Rakit\Validation\Rule;
+use InvalidArgumentException;
+use Closure;
+
+class Callback extends Rule
+{
+
+    protected $message = "The :attribute is not valid";
+
+    protected $fillable_params = ['callback'];
+
+    public function setCallback(Closure $callback)
+    {
+        return $this->setParameter('callback', $callback);
+    }
+
+    public function check($value)
+    {
+        $this->requireParameters($this->fillable_params);
+
+        $callback = $this->parameter('callback');
+        if (false === $callback instanceof Closure) {
+            $key = $this->attribute->getKey();
+            throw new InvalidArgumentException("Callback rule for '{$key}' is not callable.");
+        }
+
+        $callback = $callback->bindTo($this);
+        $invalidMessage = $callback($value);
+
+        if (is_string($invalidMessage)) {
+            $this->setMessage($invalidMessage);
+            return false;
+        } elseif(false === $invalidMessage) {
+            return false;
+        }
+
+        return true;
+    }
+
+}

src/Validation.php

@@ -3,6 +3,7 @@
 namespace Rakit\Validation;
 
 use Rakit\Validation\Rules\Required;
+use Closure;
 
 class Validation
 {
@@ -326,12 +327,13 @@ protected function resolveRules($rules)
                 $validator = call_user_func_array($validatorFactory, array_merge([$rulename], $params));
             } elseif($rule instanceof Rule) {
                 $validator = $rule;
+            } elseif($rule instanceof Closure) {
+                $validator = call_user_func_array($validatorFactory, ['callback', $rule]);
             } else {
                 $ruleName = is_object($rule) ? get_class($rule) : gettype($rule);
-                throw new \Exception("Rule must be a string or Rakit\Validation\Rule instance. ".$ruleName." given", 1);
+                throw new \Exception("Rule must be a string, closure or Rakit\Validation\Rule instance. ".$ruleName." given");
             }
 
-
             $resolved_rules[] = $validator;
         }
 

src/Validator.php

@@ -2,9 +2,6 @@
 
 namespace Rakit\Validation;
 
-use Rakit\Validation\Rules\After;
-use Rakit\Validation\Rules\Before;
-
 class Validator
 {
 
@@ -102,8 +99,9 @@ protected function registerBaseValidators()
             'present'                   => new Rules\Present,
             'different'                 => new Rules\Different,
             'uploaded_file'             => new Rules\UploadedFile,
-            'before'                    => new Before,
-            'after'                     => new After
+            'callback'                  => new Rules\Callback,
+            'before'                    => new Rules\Before,
+            'after'                     => new Rules\After,
         ];
 
         foreach($baseValidator as $key => $validator) {

tests/Rules/CallbackTest.php

@@ -0,0 +1,30 @@
+<?php
+
+use Rakit\Validation\Rules\Callback;
+
+class CallbackTest extends PHPUnit_Framework_TestCase
+{
+
+    public function setUp()
+    {
+        $this->rule = new Callback;
+        $this->rule->setCallback(function($value) {
+            return (is_numeric($value) AND $value % 2 === 0);
+        });
+    }
+
+    public function testValids()
+    {
+        $this->assertTrue($this->rule->check(2));
+        $this->assertTrue($this->rule->check('4'));
+        $this->assertTrue($this->rule->check("1000"));
+    }
+
+    public function testInvalids()
+    {
+        $this->assertFalse($this->rule->check(1));
+        $this->assertFalse($this->rule->check('abc12'));
+        $this->assertFalse($this->rule->check("12abc"));
+    }
+
+}

tests/ValidatorTest.php

@@ -626,6 +626,27 @@ public function testSetCustomMessagesInValidation()
         $this->assertEquals($errors->first('comments.0.text:required'), 'baz');
     }
 
+    public function testCustomMessageInCallbackRule()
+    {
+        $evenNumberValidator = function ($value) {
+            if (!is_numeric($value) OR $value % 2 !== 0) {
+                return ":attribute must be even number";
+            }
+            return true;
+        };
+
+        $validation = $this->validator->make([
+            'foo' => 'abc',
+        ], [
+            'foo' => [$evenNumberValidator],
+        ]);
+
+        $validation->validate();
+
+        $errors = $validation->errors();
+        $this->assertEquals($errors->first('foo:callback'), "Foo must be even number");
+    }
+
     public function testSpecificRuleMessage()
     {
         $validation = $this->validator->make([