Merge pull request #1 from WebdevCave/analysis-54J2lY

carloscarucce · web-flow · commit 7fcca06b3b3e · 2025-01-13T22:56:28.000-03:00
Apply fixes from StyleCI
diff --git a/src/Schemas/ArraySchema.php b/src/Schemas/ArraySchema.php
@@ -16,12 +16,14 @@ public function __construct(
 
     /**
      * @inheritDoc
+     *
      * @throws Exception
      */
     protected function validateSchema(mixed $value): void
     {
         if (!is_array($value)) {
-            $this->error($this->customMessages['type'] ?? "Provided value must be an array");
+            $this->error($this->customMessages['type'] ?? 'Provided value must be an array');
+
             return;
         }
 
diff --git a/src/Schemas/BaseSchema.php b/src/Schemas/BaseSchema.php
@@ -58,7 +58,7 @@ public function optional(): static
         return $this;
     }
 
-    public function refine(callable $callback, $customMessage = "Custom validation error"): static
+    public function refine(callable $callback, $customMessage = 'Custom validation error'): static
     {
         $this->customMessages['refine'] = $customMessage;
         $this->callback = $callback(...);
@@ -100,7 +100,7 @@ public function validate(mixed $value): bool
      *
      * @return void
      */
-    protected final function error(string $message): void
+    final protected function error(string $message): void
     {
         $this->errorMessages[] = $message;
     }
@@ -110,7 +110,7 @@ protected final function error(string $message): void
      *
      * @return void
      */
-    protected final function setErrorMessages(array $errors): void
+    final protected function setErrorMessages(array $errors): void
     {
         $this->errorMessages = $errors;
     }
diff --git a/src/Schemas/NumericSchema.php b/src/Schemas/NumericSchema.php
@@ -17,7 +17,7 @@ class NumericSchema extends BaseSchema
     /**
      * @return $this
      */
-    public function integer(string $customMessage = "Value must be an integer"): static
+    public function integer(string $customMessage = 'Value must be an integer'): static
     {
         $this->integerOnly = true;
         $this->customMessages['integerOnly'] = $customMessage;
@@ -28,7 +28,7 @@ public function integer(string $customMessage = "Value must be an integer"): sta
     /**
      * @return $this
      */
-    public function float(string $customMessage = "Value must be a float"): static
+    public function float(string $customMessage = 'Value must be a float'): static
     {
         $this->floatOnly = true;
         $this->customMessages['floatOnly'] = $customMessage;
@@ -39,7 +39,7 @@ public function float(string $customMessage = "Value must be a float"): static
     /**
      * @return $this
      */
-    public function positive(string $customMessage = "Value must be positive"): static
+    public function positive(string $customMessage = 'Value must be positive'): static
     {
         $this->positiveOnly = true;
         $this->customMessages['positiveOnly'] = $customMessage;
@@ -53,7 +53,7 @@ public function positive(string $customMessage = "Value must be positive"): stat
     protected function validateSchema(mixed $value): void
     {
         if (!is_numeric($value)) {
-            $this->error($this->customMessages['type'] ?? "Value must be a number");
+            $this->error($this->customMessages['type'] ?? 'Value must be a number');
         }
 
         if (!is_null($this->min) && $value < $this->min) {
diff --git a/src/Schemas/ObjectSchema.php b/src/Schemas/ObjectSchema.php
@@ -9,7 +9,8 @@ class ObjectSchema extends ArraySchema
     protected function validateSchema(mixed $value): void
     {
         if (!is_object($value)) {
-            $this->error($this->customMessages['type'] ?? "Provided value must be an object");
+            $this->error($this->customMessages['type'] ?? 'Provided value must be an object');
+
             return;
         }
 
diff --git a/src/Schemas/StringSchema.php b/src/Schemas/StringSchema.php
@@ -19,7 +19,7 @@ class StringSchema extends BaseSchema
     protected function validateSchema(mixed $value): void
     {
         if (!is_string($value)) {
-            $this->error($this->customMessages['type'] ?? "Value must be a string");
+            $this->error($this->customMessages['type'] ?? 'Value must be a string');
         }
 
         if (!is_null($this->min)) {
diff --git a/src/Validator.php b/src/Validator.php
@@ -3,7 +3,6 @@
 namespace Webdevcave\SchemaValidator;
 
 use Webdevcave\SchemaValidator\Schemas\ArraySchema;
-use Webdevcave\SchemaValidator\Schemas\BaseSchema;
 use Webdevcave\SchemaValidator\Schemas\NumericSchema;
 use Webdevcave\SchemaValidator\Schemas\ObjectSchema;
 use Webdevcave\SchemaValidator\Schemas\StringSchema;
diff --git a/tests/Schemas/ArraySchemaTest.php b/tests/Schemas/ArraySchemaTest.php
@@ -22,24 +22,24 @@ public function testTypeCheck(): void
     {
         $schema = Validator::array();
 
-        $this->assertFalse($schema->validate(1), "Array schema should not validate integers");
-        $this->assertFalse($schema->validate(1.1), "Array schema should not validate floats");
-        $this->assertFalse($schema->validate('str'), "Array schema should not validate strings");
-        $this->assertFalse($schema->validate(new stdClass()), "Array schema should not validate objects");
+        $this->assertFalse($schema->validate(1), 'Array schema should not validate integers');
+        $this->assertFalse($schema->validate(1.1), 'Array schema should not validate floats');
+        $this->assertFalse($schema->validate('str'), 'Array schema should not validate strings');
+        $this->assertFalse($schema->validate(new stdClass()), 'Array schema should not validate objects');
 
-        $this->assertTrue($schema->validate([1, 2, 3]), "Array schema should validate arrays");
+        $this->assertTrue($schema->validate([1, 2, 3]), 'Array schema should validate arrays');
     }
 
     public function testDataValidation(): void
     {
         $positiveIntCheckMessage = 'must be positive';
-        $schema = Validator::array(['name' => Validator::string()->min(3), 'age' => Validator::numeric()->integer()->positive($positiveIntCheckMessage),]);
+        $schema = Validator::array(['name' => Validator::string()->min(3), 'age' => Validator::numeric()->integer()->positive($positiveIntCheckMessage)]);
 
-        $validData = ['name' => 'Carlos', 'age' => 35,];
-        $this->assertTrue($schema->validate($validData), "Should return true when dataset is valid");
+        $validData = ['name' => 'Carlos', 'age' => 35];
+        $this->assertTrue($schema->validate($validData), 'Should return true when dataset is valid');
 
-        $invalidData = ['name' => 'John', 'age' => -10,];
-        $this->assertFalse($schema->validate($invalidData), "Should return false when dataset is not valid");
+        $invalidData = ['name' => 'John', 'age' => -10];
+        $this->assertFalse($schema->validate($invalidData), 'Should return false when dataset is not valid');
         $this->assertEquals(['age' => [$positiveIntCheckMessage]], $schema->errorMessages(), 'Error messages doesn\'t match');
     }
 
@@ -49,10 +49,10 @@ public function testWildcardIndexValidation()
         $schema = Validator::array(['*' => Validator::numeric()->integer($errorMessage)]);
 
         $validData = [1, 2, 3];
-        $this->assertTrue($schema->validate($validData), "Error evaluating wildcard index with valid data");
+        $this->assertTrue($schema->validate($validData), 'Error evaluating wildcard index with valid data');
 
         $invalidData = [null];
-        $this->assertFalse($schema->validate($invalidData), "Error evaluating wildcard index with invalid data");
+        $this->assertFalse($schema->validate($invalidData), 'Error evaluating wildcard index with invalid data');
     }
 
     public function testOptionalCheckShouldPassOnEmptyArray(): void
@@ -74,6 +74,6 @@ public function testDoubleRuleValidation(): void
         $data = [
             'name' => str_repeat('a', 10),
         ];
-        $this->assertTrue($schema->validate($data), "Array schema should accept double rule");
+        $this->assertTrue($schema->validate($data), 'Array schema should accept double rule');
     }
 }
diff --git a/tests/Schemas/BaseSchemaTest.php b/tests/Schemas/BaseSchemaTest.php
@@ -43,7 +43,8 @@ public function testSetGetRule(): void
 
         $this->schema->equals($value);
         $this->assertEquals(
-            $value, $this->schema->equals(),
+            $value,
+            $this->schema->equals(),
             'Schema should be able to set and get a rule value'
         );
     }
diff --git a/tests/Schemas/NumericSchemaTest.php b/tests/Schemas/NumericSchemaTest.php
@@ -19,57 +19,57 @@ public function testMinValue(): void
         $schema = new NumericSchema();
         $schema->min(10);
 
-        $this->assertTrue($schema->validate(10), "Failed asserting equals than minimum value");
-        $this->assertTrue($schema->validate(11), "Failed asserting number greater than minimum value");
-        $this->assertFalse($schema->validate(9), "Failed asserting number lower than minimum value");
+        $this->assertTrue($schema->validate(10), 'Failed asserting equals than minimum value');
+        $this->assertTrue($schema->validate(11), 'Failed asserting number greater than minimum value');
+        $this->assertFalse($schema->validate(9), 'Failed asserting number lower than minimum value');
     }
 
     public function testMaxValue(): void
     {
         $schema = new NumericSchema();
         $schema->max(10);
 
-        $this->assertTrue($schema->validate(10), "Failed asserting equals than maximum value");
-        $this->assertFalse($schema->validate(11), "Failed asserting number greater than maximum value");
-        $this->assertTrue($schema->validate(9), "Failed asserting number lower than maximum value");
+        $this->assertTrue($schema->validate(10), 'Failed asserting equals than maximum value');
+        $this->assertFalse($schema->validate(11), 'Failed asserting number greater than maximum value');
+        $this->assertTrue($schema->validate(9), 'Failed asserting number lower than maximum value');
     }
 
     public function testRequirePositive(): void
     {
         $schema = new NumericSchema();
         $schema->positive();
 
-        $this->assertTrue($schema->validate(1), "Failed asserting positive value");
-        $this->assertFalse($schema->validate(-1), "Failed asserting negative value (positive required)");
+        $this->assertTrue($schema->validate(1), 'Failed asserting positive value');
+        $this->assertFalse($schema->validate(-1), 'Failed asserting negative value (positive required)');
     }
 
     public function testTypeValidation(): void
     {
         $schema = new NumericSchema();
 
-        $this->assertFalse($schema->validate('str'), "Numeric schema should not validate strings");
-        $this->assertFalse($schema->validate(new stdClass()), "Numeric schema should not validate objects");
-        $this->assertFalse($schema->validate([1,2,3]), "Numeric schema should validate arrays");
+        $this->assertFalse($schema->validate('str'), 'Numeric schema should not validate strings');
+        $this->assertFalse($schema->validate(new stdClass()), 'Numeric schema should not validate objects');
+        $this->assertFalse($schema->validate([1, 2, 3]), 'Numeric schema should validate arrays');
 
-        $this->assertTrue($schema->validate(1), "Numeric schema should validate integers");
-        $this->assertTrue($schema->validate(1.1), "Numeric schema should validate floats");
+        $this->assertTrue($schema->validate(1), 'Numeric schema should validate integers');
+        $this->assertTrue($schema->validate(1.1), 'Numeric schema should validate floats');
     }
 
     public function testExclusiveIntegerValidation(): void
     {
         $schema = new NumericSchema();
         $schema->integer();
 
-        $this->assertTrue($schema->validate(1), "Numeric schema should validate integers (int only)");
-        $this->assertFalse($schema->validate(1.1), "Numeric schema should not validate floats (int only)");
+        $this->assertTrue($schema->validate(1), 'Numeric schema should validate integers (int only)');
+        $this->assertFalse($schema->validate(1.1), 'Numeric schema should not validate floats (int only)');
     }
 
     public function testExclusiveFloatValidation(): void
     {
         $schema = new NumericSchema();
         $schema->float();
 
-        $this->assertFalse($schema->validate(1), "Numeric schema should not validate integers (floats only)");
-        $this->assertTrue($schema->validate(1.1), "Numeric schema should validate floats (floats only)");
+        $this->assertFalse($schema->validate(1), 'Numeric schema should not validate integers (floats only)');
+        $this->assertTrue($schema->validate(1.1), 'Numeric schema should validate floats (floats only)');
     }
 }
diff --git a/tests/Schemas/ObjectSchemaTest.php b/tests/Schemas/ObjectSchemaTest.php
@@ -3,11 +3,11 @@
 namespace Webdevcave\SchemaValidator\Tests\Schemas;
 
 use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
 use stdClass;
 use Webdevcave\SchemaValidator\Schemas\ArraySchema;
 use Webdevcave\SchemaValidator\Schemas\BaseSchema;
 use Webdevcave\SchemaValidator\Schemas\ObjectSchema;
-use PHPUnit\Framework\TestCase;
 use Webdevcave\SchemaValidator\Validator;
 
 #[CoversClass(ObjectSchema::class)]
@@ -20,11 +20,11 @@ public function testTypeCheck(): void
     {
         $schema = Validator::object();
 
-        $this->assertFalse($schema->validate(1), "Array schema should not validate integers");
-        $this->assertFalse($schema->validate(1.1), "Array schema should not validate floats");
-        $this->assertFalse($schema->validate('str'), "Array schema should not validate strings");
-        $this->assertFalse($schema->validate([1, 2, 3]), "Array schema should not validate arrays");
+        $this->assertFalse($schema->validate(1), 'Array schema should not validate integers');
+        $this->assertFalse($schema->validate(1.1), 'Array schema should not validate floats');
+        $this->assertFalse($schema->validate('str'), 'Array schema should not validate strings');
+        $this->assertFalse($schema->validate([1, 2, 3]), 'Array schema should not validate arrays');
 
-        $this->assertTrue($schema->validate(new stdClass()), "Array schema should validate object");
+        $this->assertTrue($schema->validate(new stdClass()), 'Array schema should validate object');
     }
 }
diff --git a/tests/Schemas/StringSchemaTest.php b/tests/Schemas/StringSchemaTest.php
@@ -3,10 +3,10 @@
 namespace Webdevcave\SchemaValidator\Tests\Schemas;
 
 use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
 use stdClass;
 use Webdevcave\SchemaValidator\Schemas\BaseSchema;
 use Webdevcave\SchemaValidator\Schemas\StringSchema;
-use PHPUnit\Framework\TestCase;
 use Webdevcave\SchemaValidator\Validator;
 
 #[CoversClass(Validator::class)]
@@ -21,7 +21,7 @@ public function testMustValidateOnlyStrings(): void
         $this->assertFalse($schema->validate(1), 'Should not validate integers');
         $this->assertFalse($schema->validate(1.2), 'Should not validate floats');
         $this->assertFalse($schema->validate([]), 'Should not validate arrays');
-        $this->assertFalse($schema->validate(new stdClass), 'Should not validate objects');
+        $this->assertFalse($schema->validate(new stdClass()), 'Should not validate objects');
         $this->assertFalse($schema->validate(null), 'Should not validate null');
         $this->assertTrue($schema->validate('my string'), 'Should validate strings');
     }
diff --git a/tests/ValidatorTest.php b/tests/ValidatorTest.php
@@ -3,12 +3,12 @@
 namespace Webdevcave\SchemaValidator\Tests;
 
 use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
 use Webdevcave\SchemaValidator\Schemas\ArraySchema;
 use Webdevcave\SchemaValidator\Schemas\NumericSchema;
 use Webdevcave\SchemaValidator\Schemas\ObjectSchema;
 use Webdevcave\SchemaValidator\Schemas\StringSchema;
 use Webdevcave\SchemaValidator\Validator;
-use PHPUnit\Framework\TestCase;
 
 #[CoversClass(Validator::class)]
 #[CoversClass(StringSchema::class)]

Original file line number	Diff line number	Diff line change
`@@ -16,12 +16,14 @@ public function __construct(`
`16`	`16`
`17`	`17`	`/**`
`18`	`18`	`* @inheritDoc`
	`19`	`+ *`
`19`	`20`	`* @throws Exception`
`20`	`21`	`*/`
`21`	`22`	`protected function validateSchema(mixed $value): void`
`22`	`23`	`{`
`23`	`24`	`if (!is_array($value)) {`
`24`		`- $this->error($this->customMessages['type'] ?? "Provided value must be an array");`
	`25`	`+ $this->error($this->customMessages['type'] ?? 'Provided value must be an array');`
	`26`	`+`
`25`	`27`	`return;`
`26`	`28`	`}`
`27`	`29`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ public function optional(): static`
`58`	`58`	`return $this;`
`59`	`59`	`}`
`60`	`60`
`61`		`- public function refine(callable $callback, $customMessage = "Custom validation error"): static`
	`61`	`+ public function refine(callable $callback, $customMessage = 'Custom validation error'): static`
`62`	`62`	`{`
`63`	`63`	`$this->customMessages['refine'] = $customMessage;`
`64`	`64`	`$this->callback = $callback(...);`
`@@ -100,7 +100,7 @@ public function validate(mixed $value): bool`
`100`	`100`	`*`
`101`	`101`	`* @return void`
`102`	`102`	`*/`
`103`		`- protected final function error(string $message): void`
	`103`	`+ final protected function error(string $message): void`
`104`	`104`	`{`
`105`	`105`	`$this->errorMessages[] = $message;`
`106`	`106`	`}`
`@@ -110,7 +110,7 @@ protected final function error(string $message): void`
`110`	`110`	`*`
`111`	`111`	`* @return void`
`112`	`112`	`*/`
`113`		`- protected final function setErrorMessages(array $errors): void`
	`113`	`+ final protected function setErrorMessages(array $errors): void`
`114`	`114`	`{`
`115`	`115`	`$this->errorMessages = $errors;`
`116`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,8 @@ class ObjectSchema extends ArraySchema`
`9`	`9`	`protected function validateSchema(mixed $value): void`
`10`	`10`	`{`
`11`	`11`	`if (!is_object($value)) {`
`12`		`- $this->error($this->customMessages['type'] ?? "Provided value must be an object");`
	`12`	`+ $this->error($this->customMessages['type'] ?? 'Provided value must be an object');`
	`13`	`+`
`13`	`14`	`return;`
`14`	`15`	`}`
`15`	`16`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ class StringSchema extends BaseSchema`
`19`	`19`	`protected function validateSchema(mixed $value): void`
`20`	`20`	`{`
`21`	`21`	`if (!is_string($value)) {`
`22`		`- $this->error($this->customMessages['type'] ?? "Value must be a string");`
	`22`	`+ $this->error($this->customMessages['type'] ?? 'Value must be a string');`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`if (!is_null($this->min)) {`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,8 @@ public function testSetGetRule(): void`
`43`	`43`
`44`	`44`	`$this->schema->equals($value);`
`45`	`45`	`$this->assertEquals(`
`46`		`- $value, $this->schema->equals(),`
	`46`	`+ $value,`
	`47`	`+ $this->schema->equals(),`
`47`	`48`	`'Schema should be able to set and get a rule value'`
`48`	`49`	`);`
`49`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,57 +19,57 @@ public function testMinValue(): void`
`19`	`19`	`$schema = new NumericSchema();`
`20`	`20`	`$schema->min(10);`
`21`	`21`
`22`		`- $this->assertTrue($schema->validate(10), "Failed asserting equals than minimum value");`
`23`		`- $this->assertTrue($schema->validate(11), "Failed asserting number greater than minimum value");`
`24`		`- $this->assertFalse($schema->validate(9), "Failed asserting number lower than minimum value");`
	`22`	`+ $this->assertTrue($schema->validate(10), 'Failed asserting equals than minimum value');`
	`23`	`+ $this->assertTrue($schema->validate(11), 'Failed asserting number greater than minimum value');`
	`24`	`+ $this->assertFalse($schema->validate(9), 'Failed asserting number lower than minimum value');`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`public function testMaxValue(): void`
`28`	`28`	`{`
`29`	`29`	`$schema = new NumericSchema();`
`30`	`30`	`$schema->max(10);`
`31`	`31`
`32`		`- $this->assertTrue($schema->validate(10), "Failed asserting equals than maximum value");`
`33`		`- $this->assertFalse($schema->validate(11), "Failed asserting number greater than maximum value");`
`34`		`- $this->assertTrue($schema->validate(9), "Failed asserting number lower than maximum value");`
	`32`	`+ $this->assertTrue($schema->validate(10), 'Failed asserting equals than maximum value');`
	`33`	`+ $this->assertFalse($schema->validate(11), 'Failed asserting number greater than maximum value');`
	`34`	`+ $this->assertTrue($schema->validate(9), 'Failed asserting number lower than maximum value');`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`public function testRequirePositive(): void`
`38`	`38`	`{`
`39`	`39`	`$schema = new NumericSchema();`
`40`	`40`	`$schema->positive();`
`41`	`41`
`42`		`- $this->assertTrue($schema->validate(1), "Failed asserting positive value");`
`43`		`- $this->assertFalse($schema->validate(-1), "Failed asserting negative value (positive required)");`
	`42`	`+ $this->assertTrue($schema->validate(1), 'Failed asserting positive value');`
	`43`	`+ $this->assertFalse($schema->validate(-1), 'Failed asserting negative value (positive required)');`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`public function testTypeValidation(): void`
`47`	`47`	`{`
`48`	`48`	`$schema = new NumericSchema();`
`49`	`49`
`50`		`- $this->assertFalse($schema->validate('str'), "Numeric schema should not validate strings");`
`51`		`- $this->assertFalse($schema->validate(new stdClass()), "Numeric schema should not validate objects");`
`52`		`- $this->assertFalse($schema->validate([1,2,3]), "Numeric schema should validate arrays");`
	`50`	`+ $this->assertFalse($schema->validate('str'), 'Numeric schema should not validate strings');`
	`51`	`+ $this->assertFalse($schema->validate(new stdClass()), 'Numeric schema should not validate objects');`
	`52`	`+ $this->assertFalse($schema->validate([1, 2, 3]), 'Numeric schema should validate arrays');`
`53`	`53`
`54`		`- $this->assertTrue($schema->validate(1), "Numeric schema should validate integers");`
`55`		`- $this->assertTrue($schema->validate(1.1), "Numeric schema should validate floats");`
	`54`	`+ $this->assertTrue($schema->validate(1), 'Numeric schema should validate integers');`
	`55`	`+ $this->assertTrue($schema->validate(1.1), 'Numeric schema should validate floats');`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`public function testExclusiveIntegerValidation(): void`
`59`	`59`	`{`
`60`	`60`	`$schema = new NumericSchema();`
`61`	`61`	`$schema->integer();`
`62`	`62`
`63`		`- $this->assertTrue($schema->validate(1), "Numeric schema should validate integers (int only)");`
`64`		`- $this->assertFalse($schema->validate(1.1), "Numeric schema should not validate floats (int only)");`
	`63`	`+ $this->assertTrue($schema->validate(1), 'Numeric schema should validate integers (int only)');`
	`64`	`+ $this->assertFalse($schema->validate(1.1), 'Numeric schema should not validate floats (int only)');`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`public function testExclusiveFloatValidation(): void`
`68`	`68`	`{`
`69`	`69`	`$schema = new NumericSchema();`
`70`	`70`	`$schema->float();`
`71`	`71`
`72`		`- $this->assertFalse($schema->validate(1), "Numeric schema should not validate integers (floats only)");`
`73`		`- $this->assertTrue($schema->validate(1.1), "Numeric schema should validate floats (floats only)");`
	`72`	`+ $this->assertFalse($schema->validate(1), 'Numeric schema should not validate integers (floats only)');`
	`73`	`+ $this->assertTrue($schema->validate(1.1), 'Numeric schema should validate floats (floats only)');`
`74`	`74`	`}`
`75`	`75`	`}`