Class based after validation rules (#46757)

* Class based after validation rules

* formatting

---------

Co-authored-by: Taylor Otwell <[email protected]>

Author: timacdonald

src/Illuminate/Foundation/Http/FormRequest.php

@@ -96,6 +96,13 @@ protected function getValidatorInstance()
             $this->withValidator($validator);
         }
 
+        if (method_exists($this, 'after')) {
+            $validator->after($this->container->call(
+                $this->after(...),
+                ['validator' => $validator]
+            ));
+        }
+
         $this->setValidator($validator);
 
         return $this->validator;

src/Illuminate/Validation/Validator.php

@@ -383,11 +383,19 @@ protected function replacePlaceholderInString(string $value)
     /**
      * Add an after validation callback.
      *
-     * @param  callable|string  $callback
+     * @param  callable|array|string  $callback
      * @return $this
      */
     public function after($callback)
     {
+        if (is_array($callback) && ! is_callable($callback)) {
+            foreach ($callback as $rule) {
+                $this->after(method_exists($rule, 'after') ? $rule->after(...) : $rule);
+            }
+
+            return $this;
+        }
+
         $this->after[] = fn () => $callback($this);
 
         return $this;

tests/Foundation/FoundationFormRequestTest.php

@@ -149,6 +149,60 @@ public function testValidatedMethodReturnsOnlyRequestedNestedValidatedData()
         $this->assertSame('bar', $request->validated('nested.foo'));
     }
 
+    public function testAfterMethod()
+    {
+        $request = new class extends FormRequest {
+            public $value = 'value-from-request';
+
+            public function rules()
+            {
+                return [];
+            }
+
+            protected function failedValidation(Validator $validator)
+            {
+                throw new class ($validator) extends Exception {
+                    public function __construct(public $validator)
+                    {
+                        //
+                    }
+                };
+            }
+
+            public function after(InjectedDependency $dep)
+            {
+                return [
+                    new AfterValidationRule($dep->value),
+                    new InvokableAfterValidationRule($this->value),
+                    fn ($validator) => $validator->errors()->add('closure', 'true'),
+                ];
+            }
+        };
+        $request->setContainer($container = new Container);
+        $container->instance(\Illuminate\Contracts\Validation\Factory::class, (new \Illuminate\Validation\Factory(
+            new \Illuminate\Translation\Translator(new \Illuminate\Translation\ArrayLoader(), 'en')
+        ))->setContainer($container));
+        $container->instance(InjectedDependency::class, new InjectedDependency('value-from-dependency'));
+
+        $messages = [];
+
+        try {
+            $request->validateResolved();
+            $this->fail();
+        } catch (Exception $e) {
+            if (property_exists($e, 'validator')) {
+                $messages = $e->validator->messages()->messages();
+            }
+        }
+
+        $this->assertSame([
+            'after' => ['value-from-dependency'],
+            'invokable' => ['value-from-request'],
+            'closure' => ['true'],
+        ], $messages);
+    }
+
+
     /**
      * Catch the given exception thrown from the executor, and return it.
      *
@@ -377,3 +431,36 @@ public function authorize()
         return Response::allow('baz');
     }
 }
+
+class InvokableAfterValidationRule
+{
+    public function __construct(private $value)
+    {
+
+    }
+    public function __invoke($validator)
+    {
+        $validator->errors()->add('invokable', $this->value);
+    }
+}
+
+class AfterValidationRule
+{
+    public function __construct(private $value)
+    {
+        //
+    }
+
+    public function after($validator)
+    {
+        $validator->errors()->add('after', $this->value);
+    }
+}
+
+class InjectedDependency
+{
+    public function __construct(public $value)
+    {
+        //
+    }
+}

tests/Validation/ValidatorAfterRuleTest.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Illuminate\Tests\Validation;
+
+use Illuminate\Container\Container;
+use Illuminate\Translation\ArrayLoader;
+use Illuminate\Translation\Translator;
+use Illuminate\Validation\Validator;
+use PHPUnit\Framework\TestCase;
+
+class ValidatorAfterRuleTest extends TestCase
+{
+    public function testAfterAcceptsArrayOfRules()
+    {
+        $validator = new Validator(new Translator(new ArrayLoader, 'en'), [], []);
+
+        $validator->after([
+            fn ($validator) => $validator->errors()->add('closure', 'true'),
+            new InvokableAfterRule,
+            new AfterMethodRule,
+        ])->messages()->messages();
+
+        $this->assertSame($validator->messages()->messages(), [
+            'closure' => ['true'],
+            'invokableAfterRule' => ['true'],
+            'afterMethodRule' => ['true'],
+        ]);
+    }
+}
+
+class InvokableAfterRule
+{
+    public function __invoke($validator)
+    {
+        $validator->errors()->add('invokableAfterRule', 'true');
+    }
+}
+
+class AfterMethodRule
+{
+    public function __invoke()
+    {
+        //
+    }
+
+    public function after($validator)
+    {
+        $validator->errors()->add('afterMethodRule', 'true');
+    }
+}