Refactor StrictTypes trait and InvalidTypesException for enhanced type validation and error handling. Update matchStrictType method to improve parameter handling and add comprehensive documentation. Introduce PHPUnit configuration and initial manual tests.

Author: dconco

Router/MapRoute.php

@@ -215,8 +215,8 @@ public function match(string $method, string|array $route): bool|array
 					$param_value = $value[1];
 
 					$parsed_value = static::matchStrictType(
-					 $param_types,
 					 $param_value,
+					 $param_types,
 					);
 					$req[$param_name] = $parsed_value;
 				}

phpunit.xml

@@ -0,0 +1,8 @@
+<phpunit>
+    <testsuites>
+        <testsuite name="Manual Tests">
+            <directory>./test/manualTest</directory>
+        </testsuite>
+    </testsuites>
+    <bootstrap>vendor/autoload.php</bootstrap>
+</phpunit>

src/Utils/Routes/Exception/InvalidTypesException.php

@@ -7,7 +7,22 @@
 
 class InvalidTypesException extends \PhpSlides\Exception
 {
-   private static array $types = [
+   /**
+    * @var array $types List of valid data types for route parameters.
+    * 
+    * The following types are supported:
+    * - INT: Integer
+    * - BOOL: Boolean
+    * - JSON: JSON string
+    * - ALPHA: Alphabetic characters
+    * - ALNUM: Alphanumeric characters
+    * - ARRAY: Array
+    * - FLOAT: Floating point number
+    * - STRING: String
+    * - BOOLEAN: Boolean (alias for BOOL)
+    * - INTEGER: Integer (alias for INT)
+    */
+   protected static array $types = [
    'INT',
    'BOOL',
    'JSON',
@@ -16,9 +31,19 @@ class InvalidTypesException extends \PhpSlides\Exception
    'ARRAY',
    'FLOAT',
    'STRING',
+   'BOOLEN',
    'INTEGER',
    ];
 
+
+   /**
+    * Catches invalid strict types and throws an exception if any are found.
+    *
+    * @param array|string $type The type(s) to check against the recognized URL parameter types.
+    * @param ?Closure $message Optional closure to generate a custom exception message.
+    *
+    * @throws self If any of the provided types are not recognized as URL parameter types.
+    */
    public static function catchInvalidStrictTypes (array|string $type, ?Closure $message = null): void
    {
       if (is_array($type))
@@ -54,6 +79,18 @@ public static function catchInvalidStrictTypes (array|string $type, ?Closure $me
       }
    }
 
+
+   /**
+    * Handles invalid parameter types by setting the HTTP response code and either
+    * printing a custom error message or throwing an InvalidTypesException.
+    *
+    * @param array $typeRequested The types that were expected.
+    * @param string $typeGotten The type that was actually received.
+    * @param string|null $message Optional custom error message.
+    * @param int $code The HTTP response code to set (default is 400).
+    * 
+    * @return InvalidTypesException
+    */
    public static function catchInvalidParameterTypes (array $typeRequested, string $typeGotten, ?string $message = null, int $code = 400): InvalidTypesException
    {
       http_response_code($code);

src/Utils/Routes/StrictTypes.php

@@ -4,28 +4,38 @@
 
 use PhpSlides\Src\Utils\Routes\Exception\InvalidTypesException;
 
+/**
+ * Trait StrictTypes
+ *
+ * This trait is used to enforce strict type checking in the parameter types
+ *
+ * @package PhpSlides\Src\Utils\Routes
+ */
 trait StrictTypes
 {
 	/**
+	 * Matches the type of a given string against an array of types.
 	 *
-	 * @param string[] $types
-	 * @param string $haystack
-	 * @return int|bool|float|array|string
+	 * @param string $needle The string to check the type of.
+	 * @param array $haystack The array of types to match against.
+	 * @return bool Returns true if the type of the string matches any type in the array, false otherwise.
 	 */
-	protected static function matchType (array $types, string $haystack): bool
+	protected static function matchType (string $needle, array $haystack): bool
 	{
-		$typeOfHaystack = self::typeOfString($haystack);
+		$typeOfNeedle = self::typeOfString($needle);
 
-		foreach ($types as $type)
+		foreach ($haystack as $type)
 		{
-			$type = $type === 'INTEGER' ? 'INT' : strtoupper(trim($type));
+			$type = strtoupper(trim($type));
+			$type = $type === 'INTEGER' ? 'INT' : $type;
+			$type = $type === 'BOOLEAN' ? 'BOOL' : $type;
 
-			if (self::matches($type, $haystack))
+			if (self::matches($needle, $type))
 			{
 				return true;
 			}
 
-			if (strtoupper($type) === $typeOfHaystack)
+			if (strtoupper($type) === $typeOfNeedle)
 			{
 				return true;
 			}
@@ -34,76 +44,113 @@ protected static function matchType (array $types, string $haystack): bool
 		return false;
 	}
 
+
 	/**
+	 * Matches the given string against a list of types and returns the value
+	 * cast to the matched type.
 	 *
-	 * @param string[] $types
-	 * @param string $haystack
-	 * @return int|bool|float|array|string
+	 * @param string $needle The string to match and cast.
+	 * @param string[] $haystack The list of types to match against.
+	 * @return int|bool|float|array|string The value cast to the matched type.
+	 * @throws InvalidTypesException If the type of the needle does not match any type in the haystack.
 	 */
 	protected static function matchStrictType (
-	 array $types,
-	 string $haystack,
+	 string $needle,
+	 array $haystack,
 	): int|bool|float|array|string {
-		$types = array_map(fn ($t) => strtoupper($t), $types);
-		$typeOfHaystack = self::typeOfString($haystack);
+		$types = array_map(fn ($t) => strtoupper($t), $haystack);
+		$typeOfNeedle = self::typeOfString($needle);
 
-		if (self::matchType($types, $haystack))
+		if (self::matchType($needle, $types))
 		{
-			return match ($typeOfHaystack)
+			return match ($typeOfNeedle)
 			{
-				  'INT' => (int) $haystack,
-				  'BOOL' => (bool) $haystack,
-				  'FLOAT' => (float) $haystack,
-				  'ARRAY' => json_decode($haystack, true),
-				  default => $haystack,
+				  'INT' => (int) $needle,
+				  'BOOL' => (bool) $needle,
+				  'FLOAT' => (float) $needle,
+				  'ARRAY' => json_decode($needle, true),
+				  default => $needle,
 			};
 		}
 
-		throw InvalidTypesException::catchInvalidParameterTypes($types, $typeOfHaystack);
+		throw InvalidTypesException::catchInvalidParameterTypes($types, $typeOfNeedle);
 	}
 
-	private static function matches ($type, $haystack): bool
+
+	/**
+	 * Matches the type of the given needle against the specified haystack type.
+	 *
+	 * This method checks if the type of the needle matches the type specified in the haystack.
+	 * If the haystack specifies an array type, it will recursively check each element of the array.
+	 *
+	 * @param string $needle The value to check.
+	 * @param string $haystack The type specification to match against.
+	 * @return bool Returns true if the needle matches the haystack type, otherwise false.
+	 * @throws InvalidTypesException If the needle does not match the haystack type.
+	 */
+	private static function matches (string $needle, string $haystack): bool
 	{
-		$typeOfHaystack = self::typeOfString((string) $haystack);
-		$typeOfHaystack2 = $typeOfHaystack;
-		$haystack2 = $haystack;
+		$typeOfNeedle = self::typeOfString((string) $needle);
+		$typeOfNeedle2 = $typeOfNeedle;
+		$needle2 = $needle;
 
+		/**
+		 * MATCH ARRAY RECURSIVELY
+		 */
 		if (
-		preg_match('/ARRAY<(.+)>/', $type, $matches) &&
-		$typeOfHaystack === 'ARRAY'
+		preg_match('/ARRAY<(.+)>/', $haystack, $matches) &&
+		$typeOfNeedle === 'ARRAY'
 		)
 		{
-			$haystack = json_decode($haystack, true);
+			$needle = json_decode($needle, true);
 			$eachArrayTypes = explode(',', $matches[1]);
 
 			foreach ($eachArrayTypes as $key => $eachArrayType)
 			{
-				$haystack2 = is_array($haystack[$key])
-				 ? json_encode($haystack[$key])
-				 : (string) $haystack[$key];
+				$needle2 = is_array($needle[$key])
+				 ? json_encode($needle[$key])
+				 : (string) $needle[$key];
 
 				$eachTypes = preg_split('/\|(?![^<]*>)/', trim($eachArrayType));
-				$typeOfHaystack2 = self::typeOfString($haystack2);
+				$typeOfNeedle2 = self::typeOfString($needle2);
 
-				if (!self::matchType($eachTypes, $haystack2))
+				if (!self::matchType($needle2, $eachTypes))
 				{
 					$requested = implode(', ', $eachTypes);
 					InvalidTypesException::catchInvalidStrictTypes($eachTypes);
 					throw InvalidTypesException::catchInvalidParameterTypes(
 					 $eachTypes,
-					 $typeOfHaystack2,
-					 "Invalid request parameter type. {{$requested}} requested on array index $key, but got {{$typeOfHaystack2}}",
+					 $typeOfNeedle2,
+					 "Invalid request parameter type. {{$requested}} requested on array index $key, but got {{$typeOfNeedle2}}",
 					);
 				}
 			}
 			return true;
 		}
 
-		InvalidTypesException::catchInvalidStrictTypes($type);
+		InvalidTypesException::catchInvalidStrictTypes($haystack);
 		return false;
 	}
 
-	private static function typeOfString (string $string)
+
+	/**
+	 * Determines the type of a given string.
+	 *
+	 * This method analyzes the input string and returns a string representing its type.
+	 * The possible return values are:
+	 * - 'FLOAT' if the string represents a floating-point number.
+	 * - 'INT' if the string represents an integer.
+	 * - 'BOOL' if the string represents a boolean value ('true' or 'false').
+	 * - 'ALPHA' if the string contains only alphabetic characters.
+	 * - 'ALNUM' if the string contains only alphanumeric characters.
+	 * - 'JSON' if the string is a valid JSON object.
+	 * - 'ARRAY' if the string is a valid JSON array.
+	 * - 'STRING' if the string does not match any of the above types.
+	 *
+	 * @param string $string The input string to be analyzed.
+	 * @return string The type of the input string.
+	 */
+	protected static function typeOfString (string $string): string
 	{
 		$jd = json_decode($string, false);
 

test/manualTest/HelloWorldTest.php

@@ -0,0 +1,15 @@
+<?php
+use PHPUnit\Framework\TestCase;
+
+class HelloWorldTest extends TestCase
+{
+    public function testHelloWorld()
+    {
+        $this->assertEquals('Hello, World!', 'Hello, World!');
+    }
+
+    public function testAddition()
+    {
+        $this->assertEquals(2, 1 + 1);
+    }
+}