Static, externalize routes array, unit test

.gitignore

@@ -1,3 +1,4 @@
 tests/trees
 
 /vendor/
+composer.lock

composer.json

@@ -15,5 +15,8 @@
             "email": "email@sharkk.net"
         }
     ],
-    "minimum-stability": "stable"
+    "minimum-stability": "stable",
+    "require-dev": {
+        "phpunit/phpunit": "^11.5"
+    }
 }

src/RouterInterface.php

@@ -4,6 +4,6 @@ namespace Sharkk\Router;
 
 interface RouterInterface
 {
-	public function add(string $method, string $route, callable $handler): RouterInterface;
+    public static function add(array &$routes, string $method, string $route, callable $handler): void;
-	public function lookup(string $method, string $uri): array;
+    public static function lookup(array &$routes, string $method, string $uri): array;
 }

src/SegmentRouter.php

@@ -2,188 +2,7 @@
 
 namespace Sharkk\Router;
 
-trait SegmentRouterTrait
-{
-	/**
-	 * Add a route to the route tree. The route must be a URI path, and contain dynamic segments
-	 * using a colon prefix. (:id, :slug, etc)
-	 *
-	 * Example:
-	 * `$r->add('GET', '/posts/:id', function($id) { echo "Viewing post $id"; });`
-	 */
-	public function add(string $method, string $route, callable $handler): RouterInterface
-	{
-		// Recursively build the node tree
-		$this->addNode(
-			$this->routes,
-			array_map( // Expand the route into segments and make dynamic segments into a common placeholder
-				fn($segment) => str_starts_with($segment, ':') ? ':x' : $segment,
-				explode('/', trim($route, '/'))
-			),
-			$method,
-			$handler
-		);
-
-		return $this;
-	}
-
-	private function addNode(array &$node, array $segments, string $method, callable $handler): void
-    {
-		// Base case: if no more segments, add the handler
-		if (empty($segments)) {
-			$node[$method] = $handler;
-			return;
-		}
-
-		// Get the current segment
-		$segment = array_shift($segments);
-
-		// Skip empty segments
-		if ($segment === '') {
-			$this->addNode($node, $segments, $method, $handler);
-			return;
-		}
-
-		// Ensure the segment exists in the node
-		if (!isset($node[$segment])) {
-			$node[$segment] = [];
-		}
-
-		// Recur for the next segment
-		$this->addNode($node[$segment], $segments, $method, $handler);
-    }
-
-	/**
-	 * Perform a lookup in the route tree for a given method and URI. Returns an array with a result code,
-	 * a handler if found, and any dynamic parameters. Codes are 200 for success, 404 for not found, and
-	 * 405 for method not allowed.
-	 *
-	 * @return array ['code', 'handler', 'params']
-	 */
-	public function lookup(string $method, string $uri): array
-	{
-		// node is a reference to our current location in the node tree
-		$node = $this->routes;
-
-		// if the URI is just a slash, we can return the handler for the root node
-		if ($uri === '/') {
-			return isset($node[$method])
-				? ['code' => 200, 'handler' => $node[$method], 'params' => null]
-				: ['code' => 405, 'handler' => null, 'params' => null];
-		}
-
-		// params will hold any dynamic segments we find
-		$params = array_reduce(
-			explode('/', trim($uri, '/')),
-			function ($carry, $segment) use (&$node) {
-				if (isset($node[$segment])) {
-					$node = $node[$segment];
-				} elseif (isset($node[':x'])) {
-					$carry[] = $segment;
-					$node = $node[':x'];
-				} else {
-					throw new \Exception('404');
-				}
-				return $carry;
-			},
-			[]
-		);
-
-		// if we found a handler for the method, return it and any params. if not, return a 405
-		return isset($node[$method])
-			? [
-				'code' => 200,
-				'handler' => $node[$method],
-				'params' => $params ?? []]
-			: [
-				'code' => 405,
-				'handler' => null,
-				'params' => []
-			];
-	}
-
-	/**
-	 * Clear all routes from the router.
-	 */
-	public function clear(): RouterInterface
-	{
-		$this->routes = [];
-		return $this;
-	}
-
-	/**
-	 * Dump the route tree as an array.
-	 */
-	public function dump(): array
-	{
-		return $this->routes;
-	}
-
-	/**
-	 * Register a GET route.
-	 */
-	public function get(string $route, callable $handler): RouterInterface
-	{
-		return $this->add('GET', $route, $handler);
-	}
-
-	/**
-	 * Register a POST route.
-	 */
-	public function post(string $route, callable $handler): RouterInterface
-	{
-		return $this->add('POST', $route, $handler);
-	}
-
-	/**
-	 * Register a PUT route.
-	 */
-	public function put(string $route, callable $handler): RouterInterface
-	{
-		return $this->add('PUT', $route, $handler);
-	}
-
-	/**
-	 * Register a PATCH route.
-	 */
-	public function patch(string $route, callable $handler): RouterInterface
-	{
-		return $this->add('PATCH', $route, $handler);
-	}
-
-	/**
-	 * Register a DELETE route.
-	 */
-	public function delete(string $route, callable $handler): RouterInterface
-	{
-		return $this->add('DELETE', $route, $handler);
-	}
-
-	/**
-	 * Register a HEAD route.
-	 */
-	public function head(string $route, callable $handler): RouterInterface
-	{
-		return $this->add('HEAD', $route, $handler);
-	}
-}
-
-interface SegmentRouterInterface extends RouterInterface
-{
-	//private function addNode(array &$node, array $segments, string $method, callable $handler): void;
-	public function clear(): RouterInterface;
-	public function dump(): array;
-	public function get(string $route, callable $handler): RouterInterface;
-	public function post(string $route, callable $handler): RouterInterface;
-	public function put(string $route, callable $handler): RouterInterface;
-	public function patch(string $route, callable $handler): RouterInterface;
-	public function delete(string $route, callable $handler): RouterInterface;
-	public function head(string $route, callable $handler): RouterInterface;
-}
-
 class SegmentRouter implements SegmentRouterInterface
 {
-	private array $routes = [];
+    use SegmentRouterTrait;
-
-	use SegmentRouterTrait;
 }

src/SegmentRouterInterface.php

@@ -0,0 +1,16 @@
+<?php declare(strict_types=1);
+
+namespace Sharkk\Router;
+
+interface SegmentRouterInterface extends RouterInterface
+{
+    //private function addNode(array &$node, array $segments, string $method, callable $handler): void;
+    public static function clear(array &$routes): void;
+    //public static function dump(array &$routes): array; // Deprecated, routes are now passed by reference
+    public static function get(array &$routes, string $route, callable $handler): void;
+    public static function post(array &$routes, string $route, callable $handler): void;
+    public static function put(array &$routes, string $route, callable $handler): void;
+    public static function patch(array &$routes, string $route, callable $handler): void;
+    public static function delete(array &$routes, string $route, callable $handler): void;
+    public static function head(array &$routes, string $route, callable $handler): void;
+}

src/SegmentRouterTrait.php

@@ -0,0 +1,166 @@
+<?php declare(strict_types=1);
+
+namespace Sharkk\Router;
+
+trait SegmentRouterTrait
+{
+    /**
+     * Add a route to the route tree. The route must be a URI path, and contain dynamic segments
+     * using a colon prefix. (:id, :slug, etc)
+     *
+     * Example:
+     * `$r->add('GET', '/posts/:id', function($id) { echo "Viewing post $id"; });`
+     */
+    public static function add(array &$routes, string $method, string $route, callable $handler): void
+    {
+        // Recursively build the node tree
+        self::addNode(
+            $routes,
+            array_map( // Expand the route into segments and make dynamic segments into a common placeholder
+                fn($segment) => str_starts_with($segment, ':') ? ':x' : $segment,
+                explode('/', trim($route, '/'))
+            ),
+            $method,
+            $handler
+        );
+    }
+
+    private static function addNode(array &$node, array $segments, string $method, callable $handler): void
+    {
+        // Base case: if no more segments, add the handler
+        if (empty($segments)) {
+            $node[$method] = $handler;
+            return;
+        }
+
+        // Get the current segment
+        $segment = array_shift($segments);
+
+        // Skip empty segments
+        if ($segment === '') {
+            self::addNode($node, $segments, $method, $handler);
+            return;
+        }
+
+        // Ensure the segment exists in the node
+        if (!isset($node[$segment])) {
+            $node[$segment] = [];
+        }
+
+        // Recur for the next segment
+        self::addNode($node[$segment], $segments, $method, $handler);
+    }
+
+    /**
+     * Perform a lookup in the route tree for a given method and URI. Returns an array with a result code,
+     * a handler if found, and any dynamic parameters. Codes are 200 for success, 404 for not found, and
+     * 405 for method not allowed.
+     *
+     * @return array ['code', 'handler', 'params']
+     */
+    public static function lookup(array &$routes, string $method, string $uri): array
+    {
+        // node is a reference to our current location in the node tree
+        $node = $routes;
+
+        // if the URI is just a slash, we can return the handler for the root node
+        if ($uri === '/') {
+            return isset($node[$method])
+                ? ['code' => 200, 'handler' => $node[$method], 'params' => null]
+                : ['code' => 405, 'handler' => null, 'params' => null];
+        }
+
+        // params will hold any dynamic segments we find
+        $params = array_reduce(
+            explode('/', trim($uri, '/')),
+            function ($carry, $segment) use (&$node) {
+                if (isset($node[$segment])) {
+                    $node = $node[$segment];
+                } elseif (isset($node[':x'])) {
+                    $carry[] = $segment;
+                    $node = $node[':x'];
+                } else {
+                    throw new \Exception('404');
+                }
+                return $carry;
+            },
+            []
+        );
+
+        // if we found a handler for the method, return it and any params. if not, return a 405
+        return isset($node[$method])
+            ? [
+                'code' => 200,
+                'handler' => $node[$method],
+                'params' => $params ?? []]
+            : [
+                'code' => 405,
+                'handler' => null,
+                'params' => []
+            ];
+    }
+
+    /**
+     * Clear all routes from the router.
+     */
+    public static function clear(array &$routes): void
+    {
+        $routes = [];
+    }
+
+    /**
+     * Dump the route tree as an array.
+     */
+    /*public static function dump(array &$routes): array
+    {
+        return $routes;
+    }*/
+
+    /**
+     * Register a GET route.
+     */
+    public static function get(array &$routes, string $route, callable $handler): void
+    {
+        self::add($routes, 'GET', $route, $handler);
+    }
+
+    /**
+     * Register a POST route.
+     */
+    public static function post(array &$routes, string $route, callable $handler): void
+    {
+        self::add($routes, 'POST', $route, $handler);
+    }
+
+    /**
+     * Register a PUT route.
+     */
+    public static function put(array &$routes, string $route, callable $handler): void
+    {
+        self::add($routes, 'PUT', $route, $handler);
+    }
+
+    /**
+     * Register a PATCH route.
+     */
+    public static function patch(array &$routes, string $route, callable $handler): void
+    {
+        self::add($routes, 'PATCH', $route, $handler);
+    }
+
+    /**
+     * Register a DELETE route.
+     */
+    public static function delete(array &$routes, string $route, callable $handler): void
+    {
+        self::add($routes, 'DELETE', $route, $handler);
+    }
+
+    /**
+     * Register a HEAD route.
+     */
+    public static function head(array &$routes, string $route, callable $handler): void
+    {
+        self::add($routes, 'HEAD', $route, $handler);
+    }
+}

tests/SegmentRouterTest.php

@@ -0,0 +1,84 @@
+<?php declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+use Sharkk\Router\SegmentRouter;
+
+final class SegmentRouterTest extends TestCase
+{
+    private SegmentRouter $router;
+
+    protected function setUp(): void
+    {
+        $this->router = new SegmentRouter();
+    }
+
+    public function testAddAndLookupRoute(): void
+    {
+        $routes = [];
+        SegmentRouter::add($routes, 'GET', '/blog/:id', function($id) {
+            return "Blog post $id";
+        });
+
+        $result = SegmentRouter::lookup($routes, 'GET', '/blog/123');
+        $this->assertEquals(200, $result['code']);
+        $this->assertIsCallable($result['handler']);
+        $this->assertEquals(['123'], $result['params']);
+        $this->assertEquals("Blog post 123", $result['handler'](...$result['params']));
+    }
+
+    public function testLookupNotFound(): void
+    {
+        $routes = [];
+        SegmentRouter::add($routes, 'GET', '/blog/:id', function($id) {
+            return "Blog post $id";
+        });
+
+        $result = SegmentRouter::lookup($routes, 'GET', '/nonexistent');
+        $this->assertEquals(404, $result['code']);
+        $this->assertNull($result['handler']);
+        $this->assertEmpty($result['params']);
+    }
+
+    public function testMethodNotAllowed(): void
+    {
+        $routes = [];
+        SegmentRouter::add($routes, 'GET', '/blog/:id', function($id) {
+            return "Blog post $id";
+        });
+
+        $result = SegmentRouter::lookup($routes, 'POST', '/blog/123');
+        $this->assertEquals(405, $result['code']);
+        $this->assertNull($result['handler']);
+        $this->assertEmpty($result['params']);
+    }
+
+    public function testClearRoutes(): void
+    {
+        $routes = [];
+        SegmentRouter::add($routes, 'GET', '/blog/:id', function($id) {
+            return "Blog post $id";
+        });
+
+        SegmentRouter::clear($routes);
+        $this->assertEmpty($routes);
+    }
+
+    public function testAddMultipleMethods(): void
+    {
+        $routes = [];
+        SegmentRouter::add($routes, 'GET', '/blog/:id', function($id) {
+            return "GET Blog post $id";
+        });
+        SegmentRouter::add($routes, 'POST', '/blog/:id', function($id) {
+            return "POST Blog post $id";
+        });
+
+        $resultGet = SegmentRouter::lookup($routes, 'GET', '/blog/123');
+        $this->assertEquals(200, $resultGet['code']);
+        $this->assertEquals("GET Blog post 123", $resultGet['handler'](...$resultGet['params']));
+
+        $resultPost = SegmentRouter::lookup($routes, 'POST', '/blog/123');
+        $this->assertEquals(200, $resultPost['code']);
+        $this->assertEquals("POST Blog post 123", $resultPost['handler'](...$resultPost['params']));
+    }
+}

tests/test.php

@@ -2,6 +2,8 @@
 
 require_once 'color.php';
 require_once __DIR__ . '/../src/RouterInterface.php';
+require_once __DIR__ . '/../src/SegmentRouterTrait.php';
+require_once __DIR__ . '/../src/SegmentRouterInterface.php';
 require_once __DIR__ . '/../src/SegmentRouter.php';
 
 const ROUTES = __DIR__ . '/routes/';
@@ -11,180 +13,189 @@ use Sharkk\Router\SegmentRouter;
 
 // if there's a flag, reset the opcache
 if (in_array('-f', $argv)) {
-	opcache_reset();
+    opcache_reset();
-	echoTitle("opcache reset");
+    echoTitle("opcache reset");
 }
 
 // create the trees directory if it doesn't exist
 if (!is_dir(TREES)) mkdir(TREES);
 
-$r = new SegmentRouter();
+$routes = [];
 
 // Blog lookups
-$blog = readAndAddRoutes(ROUTES . 'blog.txt', $r);
+$blog = readAndAddRoutes(ROUTES . 'blog.txt', $routes);
-writeRoutesToFile($r->dump(), TREES . 'blog.txt');
+writeRoutesToFile($routes, TREES . 'blog.txt');
 echoTitle("Starting blog lookups");
-runIterations(10000, $r, $blog);
+runIterations(10000, $routes, $blog);
-runIterations(100000, $r, $blog);
+runIterations(100000, $routes, $blog);
-runIterations(1000000, $r, $blog);
+runIterations(1000000, $routes, $blog);
 unset($blog);
 
 // Github lookups
-$r->clear();
+SegmentRouter::clear($routes);
-$github = readAndAddRoutes(ROUTES . 'github.txt', $r);
+$github = readAndAddRoutes(ROUTES . 'github.txt', $routes);
-writeRoutesToFile($r->dump(), TREES . 'github.txt');
+writeRoutesToFile($routes, TREES . 'github.txt');
 echoTitle("Starting github lookups");
-runIterations(10000, $r, $github);
+runIterations(10000, $routes, $github);
-runIterations(100000, $r, $github);
+runIterations(100000, $routes, $github);
-runIterations(1000000, $r, $github);
+runIterations(1000000, $routes, $github);
 unset($github);
 
 // Big lookups
-$r->clear();
+SegmentRouter::clear($routes);
-$big = readAndAddRoutes(ROUTES . 'big.txt', $r);
+$big = readAndAddRoutes(ROUTES . 'big.txt', $routes);
-writeRoutesToFile($r->dump(), TREES . 'big.txt');
+writeRoutesToFile($routes, TREES . 'big.txt');
 echoTitle("Starting big lookups");
-runIterations(10000, $r, $big);
+runIterations(10000, $routes, $big);
-runIterations(100000, $r, $big);
+runIterations(100000, $routes, $big);
-runIterations(1000000, $r, $big);
+runIterations(1000000, $routes, $big);
 unset($big);
 
 // Parameter testing
-$r->clear();
+SegmentRouter::clear($routes);
 echoTitle("Testing parameters");
 
-$routes = [
+$testRoutes = [
-	['GET', '/blog/:id', function($id) {
+    ['GET', '/blog/:id', function($id) {
-		echo $id."\n";
+        echo $id."\n";
-	}],
+    }],
-	['GET', '/blog/:id/:slug', function($id, $slug) {
+    ['GET', '/blog/:id/:slug', function($id, $slug) {
-		echo $id . ' - ' . $slug."\n";
+        echo $id . ' - ' . $slug."\n";
-	}],
+    }],
-	['GET', '/blog/:id/:slug/:page', function($id, $slug, $page) {
+    ['GET', '/blog/:id/:slug/:page', function($id, $slug, $page) {
-		echo $id . ' - ' . $slug . ' - ' . $page."\n";
+        echo $id . ' - ' . $slug . ' - ' . $page."\n";
-	}],
+    }],
-	['GET', '/blog/:id/:slug/:page/:extra', function($id, $slug, $page, $extra) {
+    ['GET', '/blog/:id/:slug/:page/:extra', function($id, $slug, $page, $extra) {
-		echo $id . ' - ' . $slug . ' - ' . $page . ' - ' . $extra."\n";
+        echo $id . ' - ' . $slug . ' - ' . $page . ' - ' . $extra."\n";
-	}],
+    }],
 ];
 
-array_walk($routes, fn($route) => $r->add($route[0], $route[1], $route[2]));
+foreach ($testRoutes as $route) SegmentRouter::add($routes, ...$route);
 
 for ($i = 0; $i < 10; $i++) {
-	[$method, $uri] = $routes[array_rand($routes)];
+    [$method, $uri] = $testRoutes[array_rand($testRoutes)];
 
-	// Generate some random parameters
+    // Generate some random parameters
-	$uri = str_replace(':id', rand(1, 100), $uri);
+    $uri = str_replace(':id', rand(1, 100), $uri);
-	$uri = str_replace(':slug', 'slug-' . rand(1, 100), $uri);
+    $uri = str_replace(':slug', 'slug-' . rand(1, 100), $uri);
-	$uri = str_replace(':page', rand(1, 100), $uri);
+    $uri = str_replace(':page', rand(1, 100), $uri);
-	$uri = str_replace(':extra', 'extra-' . rand(1, 100), $uri);
+    $uri = str_replace(':extra', 'extra-' . rand(1, 100), $uri);
 
-	$res = $r->lookup($method, $uri);
+    $res = SegmentRouter::lookup($routes, $method, $uri);
-	if ($res['code'] !== 200) {
+    if ($res['code'] !== 200) {
-		echo "Failed to handle request for $uri - $res\n";
+		echo "Failed to handle request for $uri - " . json_encode($res) . "\n";
-		exit(1);
+        exit(1);
-	}
+    }
-	$res['handler'](...$res['params']);
+    $res['handler'](...$res['params']);
 }
 
-$r->clear();
+SegmentRouter::clear($routes);
 echoTitle('Testing root node');
 
-$r->add('GET', '/', function() {
+SegmentRouter::add($routes, 'GET', '/', function() {
-	echo "Root node is gtg!\n";
+    echo "Root node is gtg!\n";
 });
 
-$res = $r->lookup('GET', '/');
+$res = SegmentRouter::lookup($routes, 'GET', '/');
 if ($res['code'] !== 200) {
-	echo "Failed to handle request for /\n";
+    echo "Failed to handle request for /\n";
-	exit(1);
+    exit(1);
 }
 $res['handler']();
 
 echo "\n".Color::blue("✔️ Done!")."\n\n";
 
 function echoTitle(string $title) {
-	echo "\n";
+    echo "\n";
-	echo Color::bold(Color::black("===============================================================")) . "\n";
+    echo Color::bold(Color::black("===============================================================")) . "\n";
-	echo "\n";
+    echo "\n";
-	echo Color::bold(Color::blue($title))."\n";
+    echo Color::bold(Color::blue($title))."\n";
-	echo "\n";
+    echo "\n";
-	echo Color::bold(Color::black("===============================================================")) . "\n";
+    echo Color::bold(Color::black("===============================================================")) . "\n";
-	echo "\n";
+    echo "\n";
 }
 
-function readAndAddRoutes(string $file, &$r): array
+function readAndAddRoutes(string $file, &$routes): array
 {
-	return array_map(function($route) use ($r) {
+    return array_map(function($route) use (&$routes) {
-		[$method, $path] = explode(' ', $route);
+        [$method, $path] = explode(' ', $route);
-		$path = trim($path);
+        $path = trim($path);
-		$r->add($method, $path, fn() => true);
+        SegmentRouter::add($routes, $method, $path, fn() => true);
-		return [$method, $path];
+        return [$method, $path];
-	}, file($file));
+    }, file($file));
 }
 
-function runIterations(int $iterations, $r, array $routes) {
+function addRoutes($routes): array
-	echo "\n🚀 Running $iterations iterations...\n";
+{
+	return array_map(function($route) use (&$routes) {
+		[$method, $path, $handler] = $route;
+		SegmentRouter::add($routes, $method, $path, $handler);
+		return [$method, $path, $handler];
+	}, $routes);
+}
 
-	$start = microtime(true); // start the timer
+function runIterations(int $iterations, &$routes, array $routesList) {
-	$reqs = 0; // track the timing of lookups
+    echo "\n🚀 Running $iterations iterations...\n";
-	$longest = 0; // track the longest lookup time
-	$shortest = 0; // track the shortest lookup time
-	$longestRoute = '';
-	$shortestRoute = '';
 
-	for ($i = 0; $i < $iterations; $i++) {
+    $start = microtime(true); // start the timer
-		// pick a random route from the array
+    $reqs = 0; // track the timing of lookups
-		[$method, $path] = $routes[array_rand($routes)];
+    $longest = 0; // track the longest lookup time
+    $shortest = 0; // track the shortest lookup time
+    $longestRoute = '';
+    $shortestRoute = '';
 
-		// replace all :params/ with random values
+    for ($i = 0; $i < $iterations; $i++) {
-		$uri = preg_replace_callback('/:(\w+)/', function($matches) {
+        // pick a random route from the array
-			return rand(1, 100);
+        [$method, $path] = $routesList[array_rand($routesList)];
-		}, $path);
 
-		$start2 = microtime(true); // start the timer for the lookup
+        // replace all :params/ with random values
+        $uri = preg_replace_callback('/:(\w+)/', function($matches) {
+            return rand(1, 100);
+        }, $path);
 
-		$res = $r->lookup($method, $uri); // run the lookup
+        $start2 = microtime(true); // start the timer for the lookup
 
-		$reqs += microtime(true) - $start2; // add this lookup time
+        $res = SegmentRouter::lookup($routes, $method, $uri); // run the lookup
-		if ($shortest == 0 || microtime(true) - $start2 < $shortest) {
-			$shortest = microtime(true) - $start2; // track the shortest lookup time
-			$shortestRoute = "$method $uri";
-		}
-		if (microtime(true) - $start2 > $longest) {
-			$longest = microtime(true) - $start2; // track the longest lookup time
-			$longestRoute = "$method $uri";
-		}
 
-		// if any error was encountered, print it and exit
+        $reqs += microtime(true) - $start2; // add this lookup time
-		if ($res['code'] !== 200) {
+        if ($shortest == 0 || microtime(true) - $start2 < $shortest) {
-			echo Color::red("Failed to handle request.\n$method {$res['code']}\n"."├─ URI: $uri\n└─ Path: $path\n");
+            $shortest = microtime(true) - $start2; // track the shortest lookup time
-			echo Color::yellow("Completed $i iterations before failure.\n");
+            $shortestRoute = "$method $uri";
-			exit(1);
+        }
-		}
+        if (microtime(true) - $start2 > $longest) {
-	}
+            $longest = microtime(true) - $start2; // track the longest lookup time
-	echo Color::blue("✔️ Done!")."\n";
+            $longestRoute = "$method $uri";
+        }
 
-	// echo peak memory usage
+        // if any error was encountered, print it and exit
-	echo "Peak memory: " . Color::magenta(round(memory_get_peak_usage() / 1024, 1) . " kb\n");
+        if ($res['code'] !== 200) {
+            echo Color::red("Failed to handle request.\n$method {$res['code']}\n"."├─ URI: $uri\n└─ Path: $path\n");
+            echo Color::yellow("Completed $i iterations before failure.\n");
+            exit(1);
+        }
+    }
+    echo Color::blue("✔️ Done!")."\n";
 
-	// total time used for this run
+    // echo peak memory usage
-	echo "Time: " . Color::cyan(number_format(microtime(true) - $start, 10) . " s\n");
+    echo "Peak memory: " . Color::magenta(round(memory_get_peak_usage() / 1024, 1) . " kb\n");
 
-	// echo the average time per request
+    // total time used for this run
-	echo "Avg/lookup: " . Color::yellow(number_format($reqs / $iterations, 10) . " s\n");
+    echo "Time: " . Color::cyan(number_format(microtime(true) - $start, 10) . " s\n");
 
-	// echo the shortest lookup time
+    // echo the average time per request
-	echo "Shortest lookup: " . Color::green(number_format($shortest, 10) . " s\n");
+    echo "Avg/lookup: " . Color::yellow(number_format($reqs / $iterations, 10) . " s\n");
 
-	// echo the longest lookup time
+    // echo the shortest lookup time
-	echo "Longest lookup: " . Color::red(number_format($longest, 10) . " s\n");
+    echo "Shortest lookup: " . Color::green(number_format($shortest, 10) . " s\n");
 
-	echo Color::black("==============================================") . "\n";
+    // echo the longest lookup time
+    echo "Longest lookup: " . Color::red(number_format($longest, 10) . " s\n");
 
-	// echo the longest and shortest routes
+    echo Color::black("==============================================") . "\n";
-	echo "Shortest route: " . Color::green($shortestRoute) . "\n";
+
-	echo "Longest route: " . Color::red($longestRoute) . "\n";
+    // echo the longest and shortest routes
+    echo "Shortest route: " . Color::green($shortestRoute) . "\n";
+    echo "Longest route: " . Color::red($longestRoute) . "\n";
 }
 
 // take a route tree (array) and store it in a file to be read
@@ -194,8 +205,8 @@ function writeRoutesToFile(array $routes, string $file) {
 
     $fp = fopen($file, 'w');
 
-	// write a / to the first line of the file
+    // write a / to the first line of the file
-	fwrite($fp, "/\n");
+    fwrite($fp, "/\n");
 
     // Start writing from the root level with an indentation of 0 and no prefix
     writeNode($routes, 0, '', $fp);
@@ -204,23 +215,23 @@ function writeRoutesToFile(array $routes, string $file) {
 }
 
 function writeNode($node, $indent, $prefix, $fp) {
-	$totalItems = count($node);
+    $totalItems = count($node);
-	$currentItem = 0;
+    $currentItem = 0;
 
-	foreach ($node as $key => $value) {
+    foreach ($node as $key => $value) {
-		$currentItem++;
+        $currentItem++;
-		$isLastChild = ($currentItem === $totalItems);
+        $isLastChild = ($currentItem === $totalItems);
-		$connector = $isLastChild ? '└── ' : '├── ';
+        $connector = $isLastChild ? '└── ' : '├── ';
 
-		$key = empty($key) ? '/' : $key;
+        $key = empty($key) ? '/' : $key;
 
-		// Write the current node's key with the tree symbol
+        // Write the current node's key with the tree symbol
-		fwrite($fp, $prefix . $connector . $key . "\n");
+        fwrite($fp, $prefix . $connector . $key . "\n");
 
-		// If the value is an array, it represents a child node, so recurse
+        // If the value is an array, it represents a child node, so recurse
-		if (is_array($value)) {
+        if (is_array($value)) {
-			$newPrefix = $prefix . ($isLastChild ? '    ' : '│   ');
+            $newPrefix = $prefix . ($isLastChild ? '    ' : '│   ');
-			writeNode($value, $indent + 1, $newPrefix, $fp);
+            writeNode($value, $indent + 1, $newPrefix, $fp);
-		}
+        }
-	}
+    }
 }