[9.x] Add validation Rule::raw($rule, $parameters)

src/Illuminate/Validation/Concerns/ValidatesAttributes.php

@@ -2136,12 +2136,19 @@ protected function compare($first, $second, $operator)
     public function parseNamedParameters($parameters)
     {
         return array_reduce($parameters, function ($result, $item) {
-            [$key, $value] = array_pad(explode('=', $item, 2), 2, null);
-
-            $result[$key] = $value;
+            // If the item is a an array, we will assume the parameters have been
+            // passed in as groups of key value pairs. Otherwise, we can assume
+            // they are string based, separating them by their equals sign.
+            if (is_array($item)) {
+                array_push($result, $item);
+            } else {
+                [$key, $value] = array_pad(explode('=', $item, 2), 2, null);
+
+                $result[$key] = $value;
+            }
 
             return $result;
-        });
+        }, []);
     }
 
     /**

src/Illuminate/Validation/Rule.php

@@ -3,20 +3,38 @@
 namespace Illuminate\Validation;
 
 use Illuminate\Contracts\Support\Arrayable;
+use Illuminate\Support\Arr;
 use Illuminate\Support\Traits\Macroable;
 use Illuminate\Validation\Rules\Dimensions;
 use Illuminate\Validation\Rules\ExcludeIf;
 use Illuminate\Validation\Rules\Exists;
 use Illuminate\Validation\Rules\In;
 use Illuminate\Validation\Rules\NotIn;
 use Illuminate\Validation\Rules\ProhibitedIf;
+use Illuminate\Validation\Rules\RawRule;
 use Illuminate\Validation\Rules\RequiredIf;
 use Illuminate\Validation\Rules\Unique;
 
 class Rule
 {
     use Macroable;
 
+    /**
+     * Make a new raw validation rule.
+     *
+     * @param  string  $rule
+     * @param  \Illuminate\Contracts\Support\Arrayable|string|array  $parameters
+     * @return \Illuminate\Validation\Rules\RawRule
+     */
+    public static function raw($rule, $parameters = [])
+    {
+        if ($parameters instanceof Arrayable) {
+            $parameters = $parameters->toArray();
+        }
+
+        return new RawRule($rule, Arr::wrap($parameters));
+    }
+
     /**
      * Create a new conditional rule set.
      *

src/Illuminate/Validation/Rules/RawRule.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Illuminate\Validation\Rules;
+
+class RawRule
+{
+    /**
+     * The validation rule.
+     *
+     * @var string
+     */
+    public $rule;
+
+    /**
+     * The validation rule parameters.
+     *
+     * @var array
+     */
+    public $parameters = [];
+
+    /**
+     * Constructor.
+     *
+     * @param  string  $rule
+     * @param  array  $parameters
+     * @return void
+     */
+    public function __construct($rule, array $parameters)
+    {
+        $this->rule = $rule;
+        $this->parameters = $parameters;
+    }
+}

src/Illuminate/Validation/ValidationRuleParser.php

@@ -8,6 +8,7 @@
 use Illuminate\Support\Arr;
 use Illuminate\Support\Str;
 use Illuminate\Validation\Rules\Exists;
+use Illuminate\Validation\Rules\RawRule;
 use Illuminate\Validation\Rules\Unique;
 
 class ValidationRuleParser
@@ -120,6 +121,7 @@ protected function prepareRule($rule, $attribute)
         }
 
         if (! is_object($rule) ||
+            $rule instanceof RawRule ||
             $rule instanceof RuleContract ||
             ($rule instanceof Exists && $rule->queryCallbacks()) ||
             ($rule instanceof Unique && $rule->queryCallbacks())) {
@@ -228,6 +230,12 @@ public static function parse($rule)
             return [$rule, []];
         }
 
+        if ($rule instanceof RawRule) {
+            $rule = Arr::isAssoc($rule->parameters)
+                ? [$rule->rule, $rule->parameters]
+                : [$rule->rule, ...$rule->parameters];
+        }
+
         if (is_array($rule)) {
             $rule = static::parseArrayRule($rule);
         } else {

tests/Validation/ValidationForEachTest.php

@@ -201,6 +201,38 @@ public function testForEachCallbacksCanReturnDifferentRules()
         ], $v->getMessageBag()->toArray());
     }
 
+    public function testForEachCallbacksCanReturnRawRules()
+    {
+        $data = [
+            'items' => [
+                ['sku' => '|foo'],
+                ['sku' => '|bar'],
+                ['sku' => '|baz'],
+            ],
+        ];
+
+        $rules = [
+            'items.*.sku' => Rule::forEach(function () {
+                return [
+                    Rule::raw('in', ['|foo', '|bar', '|baz']),
+                    Rule::raw('ends_with', 'invalid'),
+                ];
+            }),
+        ];
+
+        $trans = $this->getIlluminateArrayTranslator();
+
+        $v = new Validator($trans, $data, $rules);
+
+        $this->assertFalse($v->passes());
+
+        $this->assertEquals([
+            'items.0.sku' => ['validation.ends_with'],
+            'items.1.sku' => ['validation.ends_with'],
+            'items.2.sku' => ['validation.ends_with'],
+        ], $v->getMessageBag()->toArray());
+    }
+
     public function testForEachCallbacksDoNotBreakRegexRules()
     {
         $data = [

tests/Validation/ValidationRawRuleTest.php

@@ -0,0 +1,129 @@
+<?php
+
+namespace Illuminate\Tests\Validation;
+
+use Illuminate\Translation\ArrayLoader;
+use Illuminate\Translation\Translator;
+use Illuminate\Validation\Rule;
+use Illuminate\Validation\Validator;
+use Mockery as m;
+use PHPUnit\Framework\TestCase;
+
+class ValidationRawRuleTest extends TestCase
+{
+    public function testRawRule()
+    {
+        $data = ['foo' => 'bar'];
+
+        $rules = [
+            'foo' => [
+                Rule::raw('required'),
+                Rule::raw('in', 'bar'),
+            ],
+        ];
+
+        $trans = $this->getIlluminateArrayTranslator();
+
+        $v = new Validator($trans, $data, $rules);
+
+        $this->assertTrue($v->passes());
+        $this->assertEquals($data, $v->validated());
+    }
+
+    public function testRawRulesSupportReservedKeywords()
+    {
+        $data = [
+            'foo' => '|',
+            'bar' => ';',
+            'baz' => ',',
+        ];
+
+        $rules = [
+            'foo' => Rule::raw('in', '|'),
+            'bar' => Rule::raw('in', ';'),
+            'baz' => Rule::raw('in', ','),
+        ];
+
+        $trans = $this->getIlluminateArrayTranslator();
+
+        $v = new Validator($trans, $data, $rules);
+
+        $this->assertTrue($v->passes());
+        $this->assertEquals($data, $v->validated());
+    }
+
+    public function testRawRulesCanBeAppliedToArrays()
+    {
+        $data = [
+            'items' => [
+                ['|foo' => '...', ';bar' => '...', '.baz' => '...'],
+                ['|foo' => '...', ';bar' => '...', '.baz' => '...'],
+                ['|foo' => '...', ';bar' => '...', '.baz' => '...'],
+            ],
+        ];
+
+        $rules = [
+            'items' => ['array'],
+            'items.*.name' => [
+                'array',
+                Rule::raw('required_array_keys', ['|foo', ';bar', '.baz']),
+            ],
+        ];
+
+        $trans = $this->getIlluminateArrayTranslator();
+
+        $v = new Validator($trans, $data, $rules);
+
+        $this->assertTrue($v->passes());
+        $this->assertEquals($data, $v->validated());
+    }
+
+    public function testRawRulesCanBeUsedWithReservedKeywordFields()
+    {
+        $data = [
+            '|foo' => null,
+            ';baz' => 'zal',
+            ',zee' => 'fur',
+        ];
+
+        $rules = [
+            '|foo' => Rule::raw('required_if', [';baz', 'zal']),
+            ',zee' => Rule::raw('prohibited_if', [';baz', 'zal']),
+        ];
+
+        $trans = $this->getIlluminateArrayTranslator();
+
+        $v = new Validator($trans, $data, $rules);
+
+        $this->assertFalse($v->passes());
+        $this->assertEquals([
+            '|foo' => ['validation.required_if'],
+            ',zee' => ['validation.prohibited_if'],
+        ], $v->getMessageBag()->toArray());
+    }
+
+    public function testRawRegexRule()
+    {
+        $data = ['x' => 'asdasdf'];
+
+        $rules = ['x' => Rule::raw('regex', '/^[a-z]+$/i')];
+
+        $trans = $this->getIlluminateArrayTranslator();
+
+        $v = new Validator($trans, $data, $rules);
+
+        $this->assertTrue($v->passes());
+    }
+
+    protected function getTranslator()
+    {
+        return m::mock(TranslatorContract::class);
+    }
+
+    public function getIlluminateArrayTranslator()
+    {
+        return new Translator(
+            new ArrayLoader, 'en'
+        );
+    }
+}

tests/Validation/ValidationValidatorTest.php

@@ -21,6 +21,7 @@
 use Illuminate\Translation\Translator;
 use Illuminate\Validation\DatabasePresenceVerifierInterface;
 use Illuminate\Validation\Rules\Exists;
+use Illuminate\Validation\Rules\RawRule;
 use Illuminate\Validation\Rules\Unique;
 use Illuminate\Validation\ValidationData;
 use Illuminate\Validation\ValidationException;
@@ -3039,6 +3040,14 @@ public function testValidationExists()
         $v->setPresenceVerifier($mock);
         $this->assertTrue($v->passes());
 
+        $trans = $this->getIlluminateArrayTranslator();
+        $v = new Validator($trans, ['email' => 'foo'], ['email' => new RawRule('Exists', ['users', 'email', 'account_id', 1, 'name', 'taylor'])]);
+        $mock = m::mock(DatabasePresenceVerifierInterface::class);
+        $mock->shouldReceive('setConnection')->once()->with(null);
+        $mock->shouldReceive('getCount')->once()->with('users', 'email', 'foo', null, null, ['account_id' => 1, 'name' => 'taylor'])->andReturn(1);
+        $v->setPresenceVerifier($mock);
+        $this->assertTrue($v->passes());
+
         $trans = $this->getIlluminateArrayTranslator();
         $v = new Validator($trans, ['email' => 'foo'], ['email' => 'Exists:users,email,account_id,1,name,taylor']);
         $mock = m::mock(DatabasePresenceVerifierInterface::class);
@@ -3673,6 +3682,12 @@ public function testValidateImageDimensions()
         $v = new Validator($trans, ['x' => $uploadedFile], ['x' => 'dimensions:min_height=2,ratio=3/2']);
         $this->assertTrue($v->passes());
 
+        $v = new Validator($trans, ['x' => $uploadedFile], ['x' => new RawRule('dimensions', ['min_height' => 2, 'ratio' => '3/2'])]);
+        $this->assertTrue($v->passes());
+
+        $v = new Validator($trans, ['x' => $uploadedFile], ['x' => new RawRule('dimensions', ['min_height=2', 'ratio=3/2'])]);
+        $this->assertTrue($v->passes());
+
         $v = new Validator($trans, ['x' => $uploadedFile], ['x' => 'dimensions:ratio=1.5']);
         $this->assertTrue($v->passes());