Merge pull request #10 from VladimirBerdnik/feature/rule-when

Add conditional rule set building possibility

Author: populov

CHANGES.md

@@ -1,5 +1,9 @@
 # Changes History
 
+1.0.11
+------
+Added when() method that allows to build rules according to conditions
+
 1.0.10
 ------
 Enum rule. See https://github.com/Saritasa/php-common#enum

README.md

@@ -13,6 +13,14 @@ Use fluent-style syntax to build [Laravel validation rules](https://laravel.com/
 $rules = [
     'id' => Rule::int()->required(),
     'name' => Rule::string()->required()->minLength(3)->toString(),
+    'salary' => Rule::int()->when($isPHPDeveloper, 
+                             function($ruleWhenTrue) { 
+                                 return $ruleWhenTrue->min(1000000); 
+                             }, 
+                             function($ruleWhenFalse) { 
+                                 return $ruleWhenFalse->max(1000); 
+                             }
+    ),
     'email' => Rule::string()->required()->email()->toArray()
 ]
 ```

src/Rule.php

@@ -63,6 +63,8 @@
 
  * @method static DatabaseRuleSet exists(string $table, string $column, \Closure $closure = null) Get a exists constraint builder instance.
  * @method static DatabaseRuleSet unique(string $table, string $column, \Closure $closure = null) Get a unique constraint builder instance.
+ *
+ * @method static RuleSet when($condition, \Closure $trueCallback, \Closure $falseCallback = null): RuleSet Performs conditional building of rule set.
 
  */
 class Rule

src/RuleSet.php

@@ -51,6 +51,7 @@ class RuleSet implements IRule
         'size',
         'sometimes',
         'custom',
+        'when',
     ];
 
     /**
@@ -116,6 +117,34 @@ protected static function mergeIfNotExists(string $rule, array $rules = []): arr
         }
     }
 
+    /**
+     * Performs conditional building of rule set.
+     *
+     * @param mixed $condition Condition to check
+     * @param \Closure $trueCallback Callback that will be called when condition is TRUE.
+     * Receives current rule set value and should return instance of RuleSer class.
+     * @param \Closure|null $falseCallback Callback that will be called when condition is FALSE.
+     * Receives current rule set value and should return instance of RuleSer class.
+     *
+     * @return RuleSet
+     */
+    public function when($condition, \Closure $trueCallback, \Closure $falseCallback = null): RuleSet
+    {
+        if ((bool)$condition) {
+            $result = $trueCallback($this);
+        } elseif ($falseCallback !== null) {
+            $result = $falseCallback($this);
+        } else {
+            $result = $this;
+        }
+
+        if (!is_a($result, RuleSet::class)) {
+            throw new \UnexpectedValueException('Callback should return instance of [' . RuleSet::class . '] class');
+        }
+
+        return $result;
+    }
+
     /** Return current rule set as array */
     public function toArray(): array
     {

tests/RuleTest.php

@@ -2,12 +2,14 @@
 
 namespace Saritasa\Laravel\Validation\Tests;
 
+use Illuminate\Support\Facades\Config;
 use Illuminate\Support\Str;
 use PHPUnit\Framework\TestCase;
 use Saritasa\Enums\Gender;
 use Saritasa\Exceptions\NotImplementedException;
 use Saritasa\Laravel\Validation\Rule;
 use Saritasa\Laravel\Validation\RuleSet;
+use UnexpectedValueException;
 
 /**
  * Test basic features
@@ -101,10 +103,10 @@ public function testMixed()
         $rules = Rule::string()->required()->min(3);
         $this->assertEquals('string|required|min:3', $rules);
 
-        $this->assertEquals('string|email|nullable|present',  Rule::email()->nullable()->present());
+        $this->assertEquals('string|email|nullable|present', Rule::email()->nullable()->present());
 
         $rules = Rule::requiredWithout('facebook_token')->confirmed();
-        $this->assertEquals('required_without:facebook_token|confirmed',  $rules);
+        $this->assertEquals('required_without:facebook_token|confirmed', $rules);
     }
 
 
@@ -116,4 +118,113 @@ public function testNonExistent()
         $this->expectException(NotImplementedException::class);
         Rule::nonExistent();
     }
+
+    /**
+     * Test that rule appended inside true callback of when() method.
+     */
+    public function testWhenTrueCallback()
+    {
+        $isPHPDeveloper = true;
+
+        $salaryRule = Rule::int()->when($isPHPDeveloper,
+            function(RuleSet $ruleWhenTrue) {
+                return $ruleWhenTrue->min(1000000);
+            },
+            function(RuleSet $ruleWhenFalse) {
+                return $ruleWhenFalse->max(1000);
+            }
+        );
+
+        $this->assertEquals('integer|min:1000000', $salaryRule->toString());
+    }
+
+    /**
+     * Test that rule appended inside false callback of when() method.
+     */
+    public function testWhenFalseCallback()
+    {
+        $rule = Rule::string()->when(
+            false,
+            function (RuleSet $rule) {
+                return $rule->max(10); // Should not be executed as passed condition is false
+            },
+            function (RuleSet $rule) {
+                return $rule->min(10); // Should be executed as passed condition if false
+            }
+        );
+
+        $this->assertEquals('string|min:10', $rule->toString());
+    }
+
+    /**
+     * Test that rule leaves the same when condition is false and false callback not passed to when() method.
+     */
+    public function testWhenFalseCallbackNotPassed()
+    {
+        $rule = Rule::string()->when(
+            false,
+            function (RuleSet $rule) {
+                return $rule->max(10); // Should not be executed as passed condition is false
+            }
+        );
+
+        $this->assertEquals('string', $rule->toString());
+    }
+
+    /**
+     * Test that callback of when() method should return instance of RuleSet class.
+     */
+    public function testWhenUnexpectedResultInCallback()
+    {
+        $this->expectException(UnexpectedValueException::class);
+
+        Rule::string()->when(true, function () {
+            return 'min:10'; // Invalid value. Instance of RuleSet expected
+        });
+    }
+
+    /**
+     * Test that rule appended inside callback of when() method and inside of this callback.
+     */
+    public function testDeepWhenCallback()
+    {
+        $rule = Rule::string()
+            ->when(true, function (RuleSet $rule) { // First level of condition
+                return $rule->max(10)
+                    ->when(true, function (RuleSet $rule) { // Second level of condition
+                        return $rule->nullable();
+                    });
+            });
+
+        $this->assertEquals('string|max:10|nullable', $rule->toString());
+    }
+
+    /**
+     * Test that method when() works from static call of Rule class.
+     */
+    public function testWhenFromRuleClass()
+    {
+        $rule = Rule::when(true, function (RuleSet $rule) {
+            return $rule->required()->max(10);
+        });
+
+        $this->assertEquals('required|max:10', $rule->toString());
+    }
+
+    /**
+     * Test that method when() works in instance of DatabaseRuleSet class (not only from GenericRuleSet).
+     */
+    public function testWhenFromDatabaseRuleSetClass()
+    {
+        Config::shouldReceive('get')->with('validation.allow_db', false)->andReturn(true);
+
+        $rule = Rule::exists('users', 'id')
+            ->when(true, function (RuleSet $rule) {
+                return $rule->nullable();
+            });
+
+        $this->assertEquals('exists:users,id|nullable', $rule->toString());
+
+        Config::clearResolvedInstances();
+    }
 }