Router.php

• Pfad: src/Framework/Router.php
• Namespace: Framework
• Zeilen: 119 | Größe: 3,192 Bytes
• Geändert: 2025-12-23 08:09:01 | Gescannt: 2025-12-31 10:22:15

Code Hygiene Score: 100

• Dependencies: 100 (25%)
• LOC: 100 (20%)
• Methods: 100 (20%)
• Secrets: 100 (15%)
• Classes: 100 (10%)
• Magic Numbers: 100 (10%)

Keine Issues gefunden.

Klassen 1

• Router class Zeile 9

Funktionen 10

• setContainer() public Zeile 17
• get() public Zeile 22
• post() public Zeile 27
• put() public Zeile 32
• delete() public Zeile 37
• add() public Zeile 42
• dispatch() public Zeile 53
• convertToRegex() protected Zeile 74
• handle() protected Zeile 87
• resolveController() protected Zeile 107

Versionen 5

• v5 2025-12-23 08:09 | claude-code-hook | modified
  Claude Code Pre-Hook Backup vor Edit-Operation
• v4 2025-12-22 15:32 | claude-code-hook | modified
  Claude Code Pre-Hook Backup vor Edit-Operation
• v3 2025-12-22 15:29 | claude-code-hook | modified
  Claude Code Pre-Hook Backup vor Edit-Operation
• v2 2025-12-22 15:29 | claude-code-hook | modified
  Claude Code Pre-Hook Backup vor Edit-Operation
• v1 2025-12-22 08:53 | claude-code-hook | modified
  Claude Code Pre-Hook Backup vor Edit-Operation

Code

<?php

declare(strict_types=1);

namespace Framework;

// @responsibility: HTTP-Routing mit Pattern-Matching und Middleware

class Router
{
    protected array $routes = [];
    protected ?Container $container = null;

    /**
     * Set the DI container for controller resolution.
     */
    public function setContainer(Container $container): void
    {
        $this->container = $container;
    }

    public function get(string $path, array|callable $handler): self
    {
        return $this->add('GET', $path, $handler);
    }

    public function post(string $path, array|callable $handler): self
    {
        return $this->add('POST', $path, $handler);
    }

    public function put(string $path, array|callable $handler): self
    {
        return $this->add('PUT', $path, $handler);
    }

    public function delete(string $path, array|callable $handler): self
    {
        return $this->add('DELETE', $path, $handler);
    }

    public function add(string $method, string $path, array|callable $handler): self
    {
        $this->routes[] = [
            'method' => $method,
            'path' => $path,
            'handler' => $handler,
        ];

        return $this;
    }

    public function dispatch(string $uri, string $method): void
    {
        foreach ($this->routes as $route) {
            if ($route['method'] !== $method) {
                continue;
            }

            $pattern = $this->convertToRegex($route['path']);

            if (preg_match($pattern, $uri, $matches)) {
                array_shift($matches);
                $this->handle($route['handler'], $matches);

                return;
            }
        }

        http_response_code(404);
        echo '404 Not Found';
    }

    protected function convertToRegex(string $path): string
    {
        // Support {name:pattern} syntax for custom patterns (e.g., {path:.*})
        $pattern = preg_replace_callback('/\{([a-zA-Z]+):([^}]+)\}/', function ($matches) {
            return '(' . $matches[2] . ')';
        }, $path);

        // Support simple {name} syntax
        $pattern = preg_replace('/\{([a-zA-Z]+)\}/', '([^/]+)', $pattern);

        return '#^' . $pattern . '$#';
    }

    protected function handle(array|callable $handler, array $params): void
    {
        if (is_callable($handler)) {
            call_user_func_array($handler, $params);

            return;
        }

        [$controllerClass, $method] = $handler;
        $controller = $this->resolveController($controllerClass);
        /** @var callable $callback */
        $callback = [$controller, $method];
        call_user_func_array($callback, $params);
    }

    /**
     * Resolve a controller using the container or direct instantiation.
     *
     * @param class-string<Controller> $controllerClass
     */
    protected function resolveController(string $controllerClass): Controller
    {
        // Use container if available (with autowiring)
        if ($this->container !== null) {
            /** @var Controller */
            return $this->container->get($controllerClass);
        }

        // Fallback to direct instantiation
        return new $controllerClass();
    }
}