v6

henriquemoody · henriquemoody · commit 15b70decea19 · 2024-12-26T21:57:09.000+01:00
diff --git a/library/Rules/Key.php b/library/Rules/Key.php
@@ -34,16 +34,16 @@ public function getKey(): int|string
 
     public function evaluate(mixed $input): Result
     {
+        $keyExistsResult = (new KeyExists($this->key))->evaluate($input);
+        if (!$keyExistsResult->isValid) {
+            return $keyExistsResult->withNameFrom($this->rule);
+        }
+
         $name = (string) $this->key;
         if ($this->rule instanceof Nameable) {
             $name = $this->rule->getName() ?? $name;
         }
 
-        $keyExistsResult = (new KeyExists($this->key))->evaluate($input);
-        if (!$keyExistsResult->isValid) {
-            return $keyExistsResult->withFuckingName($name);
-        }
-
         return $this->rule
             ->evaluate($input[$this->key])
             ->withFuckingName($name)
diff --git a/library/Rules/KeyOptional.php b/library/Rules/KeyOptional.php
@@ -14,6 +14,7 @@
 use Respect\Validation\Rule;
 use Respect\Validation\Rules\Core\Binder;
 use Respect\Validation\Rules\Core\KeyRelated;
+use Respect\Validation\Rules\Core\Nameable;
 use Respect\Validation\Rules\Core\Wrapper;
 
 #[Attribute(Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
@@ -23,7 +24,7 @@ public function __construct(
         private readonly int|string $key,
         Rule $rule,
     ) {
-        parent::__construct(new Named($rule, (string) $this->key));
+        parent::__construct($rule);
     }
 
     public function getKey(): int|string
@@ -33,11 +34,11 @@ public function getKey(): int|string
 
     public function evaluate(mixed $input): Result
     {
-        $keyExistsResult = (new Binder($this, new KeyExists($this->key)))->evaluate($input);
+        $keyExistsResult = (new KeyExists($this->key))->evaluate($input);
         if (!$keyExistsResult->isValid) {
-            return $keyExistsResult->withInvertedMode();
+            return $keyExistsResult->withNameFrom($this->rule)->withInvertedMode();
         }
 
-        return (new Binder($this, $this->rule))->evaluate($input[$this->key])->withUnchangeableId((string) $this->key);
+        return (new Key($this->key, $this->rule))->evaluate($input);
     }
 }
diff --git a/library/Rules/Named.php b/library/Rules/Named.php
@@ -41,7 +41,6 @@ public function evaluate(mixed $input): Result
     private function enrichResult(Result $result): Result
     {
         return $result
-            ->withName($result->name ?? $this->name)
-            ->withChildren(...array_map(fn (Result $child) => $this->enrichResult($child), $result->children));
+            ->withFuckingName($this->name);
     }
 }
diff --git a/library/Rules/Property.php b/library/Rules/Property.php
@@ -14,6 +14,7 @@
 use Respect\Validation\Result;
 use Respect\Validation\Rule;
 use Respect\Validation\Rules\Core\Binder;
+use Respect\Validation\Rules\Core\Nameable;
 use Respect\Validation\Rules\Core\Wrapper;
 
 #[Attribute(Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
@@ -30,13 +31,19 @@ public function __construct(
 
     public function evaluate(mixed $input): Result
     {
-        $propertyExistsResult = (new Binder($this, new PropertyExists($this->propertyName)))->evaluate($input);
+        $propertyExistsResult = (new PropertyExists($this->propertyName))->evaluate($input);
         if (!$propertyExistsResult->isValid) {
-            return $propertyExistsResult;
+            return $propertyExistsResult->withNameFrom($this->rule);
         }
 
-        return (new Binder($this, $this->rule))
+        $name = $this->propertyName;
+        if ($this->rule instanceof Nameable) {
+            $name = $this->rule->getName() ?? $name;
+        }
+
+        return $this->rule
             ->evaluate($this->extractPropertyValue($input, $this->propertyName))
+            ->withFuckingName($name)
             ->withUnchangeableId($this->propertyName);
     }
 }
diff --git a/library/Rules/PropertyExists.php b/library/Rules/PropertyExists.php
@@ -13,6 +13,7 @@
 use ReflectionObject;
 use Respect\Validation\Message\Template;
 use Respect\Validation\Result;
+use Respect\Validation\Rules\Core\PreNamed;
 use Respect\Validation\Rules\Core\Standard;
 
 use function is_object;
@@ -22,7 +23,7 @@
     '{{name}} must be present',
     '{{name}} must not be present',
 )]
-final class PropertyExists extends Standard
+final class PropertyExists extends Standard implements PreNamed
 {
     public function __construct(
         public readonly string $propertyName
diff --git a/library/Rules/PropertyOptional.php b/library/Rules/PropertyOptional.php
@@ -32,11 +32,9 @@ public function evaluate(mixed $input): Result
     {
         $propertyExistsResult = (new Binder($this, new PropertyExists($this->propertyName)))->evaluate($input);
         if (!$propertyExistsResult->isValid) {
-            return $propertyExistsResult->withInvertedMode();
+            return $propertyExistsResult->withNameFrom($this->rule)->withInvertedMode();
         }
 
-        return (new Binder($this, $this->rule))
-            ->evaluate($this->extractPropertyValue($input, $this->propertyName))
-            ->withUnchangeableId($this->propertyName);
+        return (new Property($this->propertyName, $this->rule))->evaluate($input);
     }
 }
diff --git a/tests/feature/Rules/KeyTest.php b/tests/feature/Rules/KeyTest.php
@@ -36,21 +36,21 @@
 ));
 
 test('With wrapped name, missing key', expectAll(
-    fn() => v::key('foo', v::intType()->setName('Wrapped'))->setName('Wrapper')->assert([]),
+    fn() => v::key('foo', v::intType()->setName('Wrapped'))->assert([]),
     'Wrapped must be present',
     '- Wrapped must be present',
     ['foo' => 'Wrapped must be present'],
 ));
 
 test('With wrapped name, default', expectAll(
-    fn() => v::key('foo', v::intType()->setName('Wrapped'))->setName('Wrapper')->assert(['foo' => 'string']),
+    fn() => v::key('foo', v::intType()->setName('Wrapped'))->assert(['foo' => 'string']),
     'Wrapped must be an integer',
     '- Wrapped must be an integer',
     ['foo' => 'Wrapped must be an integer'],
 ));
 
 test('With wrapped name, inverted', expectAll(
-    fn() => v::not(v::key('foo', v::intType()->setName('Wrapped'))->setName('Wrapper'))->setName('Not')->assert(['foo' => 12]),
+    fn() => v::not(v::key('foo', v::intType()->setName('Wrapped')))->assert(['foo' => 12]),
     'Wrapped must not be an integer',
     '- Wrapped must not be an integer',
     ['foo' => 'Wrapped must not be an integer'],
@@ -65,9 +65,9 @@
 
 test('With wrapper name, missing key', expectAll(
     fn() => v::key('foo', v::intType())->setName('Wrapper')->assert([]),
-    'foo must be present',
-    '- foo must be present',
-    ['foo' => 'foo must be present'],
+    'Wrapper must be present',
+    '- Wrapper must be present',
+    ['foo' => 'Wrapper must be present'],
 ));
 
 test('With wrapper name, inverted', expectAll(
diff --git a/tests/feature/Rules/PropertyTest.php b/tests/feature/Rules/PropertyTest.php
@@ -36,22 +36,22 @@
 ));
 
 test('With wrapped name, missing property', expectAll(
-    fn() => v::property('foo', v::intType()->setName('Wrapped'))->setName('Wrapper')->assert(new stdClass()),
-    'Wrapped must be present',
-    '- Wrapped must be present',
-    ['foo' => 'Wrapped must be present'],
+    fn() => v::property('foo', v::intType()->setName('Wrapped'))->assert(new stdClass()),
+    'foo must be present',
+    '- foo must be present',
+    ['foo' => 'foo must be present'],
 ));
 
 test('With wrapped name, default', expectAll(
-    fn() => v::property('foo', v::intType()->setName('Wrapped'))->setName('Wrapper')->assert((object) ['foo' => 'string']),
+    fn() => v::property('foo', v::intType()->setName('Wrapped'))->assert((object) ['foo' => 'string']),
     'Wrapped must be an integer',
     '- Wrapped must be an integer',
     ['foo' => 'Wrapped must be an integer'],
 ));
 
 test('With wrapped name, inverted', expectAll(
     fn() => v::not(
-        v::property('foo', v::intType()->setName('Wrapped'))->setName('Wrapper'),
+        v::property('foo', v::intType()->setName('Wrapped')),
     )
         ->setName('Not')
         ->assert((object) ['foo' => 12]),
@@ -68,7 +68,7 @@
 ));
 
 test('With wrapper name, missing property', expectAll(
-    fn() => v::property('foo', v::intType())->setName('Wrapper')->assert(new stdClass()),
+    fn() => v::property('foo', v::intType()->setName('Wrapper'))->assert(new stdClass()),
     'foo must be present',
     '- foo must be present',
     ['foo' => 'foo must be present'],

Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@`
`14`	`14`	`use Respect\Validation\Rule;`
`15`	`15`	`use Respect\Validation\Rules\Core\Binder;`
`16`	`16`	`use Respect\Validation\Rules\Core\KeyRelated;`
	`17`	`+use Respect\Validation\Rules\Core\Nameable;`
`17`	`18`	`use Respect\Validation\Rules\Core\Wrapper;`
`18`	`19`
`19`	`20`	`#[Attribute(Attribute::TARGET_PROPERTY \| Attribute::IS_REPEATABLE)]`
`@@ -23,7 +24,7 @@ public function __construct(`
`23`	`24`	`private readonly int\|string $key,`
`24`	`25`	`Rule $rule,`
`25`	`26`	`) {`
`26`		`- parent::__construct(new Named($rule, (string) $this->key));`
	`27`	`+ parent::__construct($rule);`
`27`	`28`	`}`
`28`	`29`
`29`	`30`	`public function getKey(): int\|string`
`@@ -33,11 +34,11 @@ public function getKey(): int\|string`
`33`	`34`
`34`	`35`	`public function evaluate(mixed $input): Result`
`35`	`36`	`{`
`36`		`- $keyExistsResult = (new Binder($this, new KeyExists($this->key)))->evaluate($input);`
	`37`	`+ $keyExistsResult = (new KeyExists($this->key))->evaluate($input);`
`37`	`38`	`if (!$keyExistsResult->isValid) {`
`38`		`- return $keyExistsResult->withInvertedMode();`
	`39`	`+ return $keyExistsResult->withNameFrom($this->rule)->withInvertedMode();`
`39`	`40`	`}`
`40`	`41`
`41`		`- return (new Binder($this, $this->rule))->evaluate($input[$this->key])->withUnchangeableId((string) $this->key);`
	`42`	`+ return (new Key($this->key, $this->rule))->evaluate($input);`
`42`	`43`	`}`
`43`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,6 @@ public function evaluate(mixed $input): Result`
`41`	`41`	`private function enrichResult(Result $result): Result`
`42`	`42`	`{`
`43`	`43`	`return $result`
`44`		`- ->withName($result->name ?? $this->name)`
`45`		`- ->withChildren(...array_map(fn (Result $child) => $this->enrichResult($child), $result->children));`
	`44`	`+ ->withFuckingName($this->name);`
`46`	`45`	`}`
`47`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,11 +32,9 @@ public function evaluate(mixed $input): Result`
`32`	`32`	`{`
`33`	`33`	`$propertyExistsResult = (new Binder($this, new PropertyExists($this->propertyName)))->evaluate($input);`
`34`	`34`	`if (!$propertyExistsResult->isValid) {`
`35`		`- return $propertyExistsResult->withInvertedMode();`
	`35`	`+ return $propertyExistsResult->withNameFrom($this->rule)->withInvertedMode();`
`36`	`36`	`}`
`37`	`37`
`38`		`- return (new Binder($this, $this->rule))`
`39`		`- ->evaluate($this->extractPropertyValue($input, $this->propertyName))`
`40`		`- ->withUnchangeableId($this->propertyName);`
	`38`	`+ return (new Property($this->propertyName, $this->rule))->evaluate($input);`
`41`	`39`	`}`
`42`	`40`	`}`