Failed opening required C:\ ' (include_path='.;C:\php\pear')

Hello,

Première chose, je te conseil de mettre la visibilité aussi sur tes méthodes de classe.

Ensuite tu suis un tuto en particulier ou tu essaye de ton côté de le faire ? Car je trouve que ça part un peu dans tous les sens entre des instanciations dans le constructeur, du statique et la création de données à droite et à gauche.

Comme on ne voit pas comment marche le parse de ton router ça va être dur d'imaginer mais j'ai du coup peut-être que l'erreur est là-bas.

Le controller :

namespace Tuto\Controller;

class PagesController extends Controller
{
    public function view(): void
    {
        echo "Hello World!"; // Just for debug, don't echo in a class
    }
}

Puis on représente une requête :

namespace Tuto;

class Request
{
    public function __construct(
        private readonly string $method,
        private readonly string $uri,
    ) {
    }

    public static function fromGlobals()
    {
        return new self(
            method: strtoupper($_SERVER['REQUEST_METHOD'] ?? 'GET'),
            uri: $_SERVER['REQUEST_URI'] ?? '/',
        );
    }

    public function getMethod(): string
    {
        return $this->method;
    }

    public function getUri(): string
    {
        return $this->uri;
    }
}

Puis on a notre router avec la représentation d'une route

namespace Tuto;

class Router
{
    /** @var Route[] $routes */
    private array $routes = [];

    public function add(string $method, string $path, string $controller, string $action): void
    {
        $this->routes[] = new Route($method, $path, $controller, $action);
    }

    public function match(Request $request): Route
    {
        foreach ($this->routes as $route) {
            if ($route->match($request)) {
                return $route;
            }
        }
        throw new \Exception('No matching route');
    }
}

namespace Tuto;

class Route
{
    public function __construct(
        public readonly string $method,
        public readonly string $path,
        public readonly string $controller,
        public readonly string $action,
    ) {
    }

    public function match(Request $request): bool
    {
        return $this->method === $request->getMethod() && $this->path === $request->getUri(); // Change for better matching
    }
}

Enfin ton dispatcher qui utilise les classes précédentes et non pas qui y sont dépendante :

namespace Tuto;

class Dispatcher
{
    public function __construct(
        private readonly Router $router,
    ) {
    }

    public function dispatch(Request $request): void
    {
        $route = $this->router->match($request);

        $controllerName = $route->controller;
        $controller = new $controllerName();
        $controller->{$route->action}();
    }
}

Et du coup l'utilisation donnerai :

use Tuto\Dispatcher;
use Tuto\Request;
use Tuto\Route;
use Tuto\Router;
use Tuto\Controller\PagesController;

$router = new Router();
$router->add('GET', '/', PagesController::class, 'view');

$dispatcher = new Dispatcher($router);
$dispatcher->dispatch(Request::fromGlobals());

Comme on peut le voir je ne suis pas contre le statique mais il faut que ça servent vraiment les intérêts. La par exemple ça évite de gérer une création complexe d'un objet Request en utilisant ce que php nous mets à disposition.

Je te laisse voir un peu le code et poser les questions nécessaire sachant que je n'ai pas testé ce dernier mais c'est pour le principe de base. Je te conseil aussi de voir un peu le principe S.O.L.I.D. (https://essential-dev-skills.com/poo/principe-solid ou encore https://guillaume-richard.fr/principe-solid-simplifies-avec-des-exemples-en-php/)