chore: complete update

src/Framework/Core/PathProvider.php

@@ -0,0 +1,135 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core;
+
+/**
+ * Optimierter PathProvider mit Caching
+ */
+final class PathProvider
+{
+    private string $basePath;
+    private array $resolvedPaths = [];
+    private ?array $namespacePaths = null {
+        get {
+            if ($this->namespacePaths !== null) {
+                return $this->namespacePaths;
+            }
+
+            // Aus composer.json auslesen
+            $composerJsonPath = $this->basePath . '/composer.json';
+            if (!file_exists($composerJsonPath)) {
+                return $this->namespacePaths = [];
+            }
+
+            $composerJson = json_decode(file_get_contents($composerJsonPath), true);
+            $this->namespacePaths = [];
+
+            if (isset($composerJson['autoload']['psr-4'])) {
+                foreach ($composerJson['autoload']['psr-4'] as $namespace => $path) {
+                    $this->namespacePaths[$namespace] = $this->resolvePath($path);
+                }
+            }
+
+            return $this->namespacePaths;
+        }
+    }
+
+    public function __construct(string $basePath)
+    {
+        $this->basePath = rtrim($basePath, '/');
+    }
+
+    /**
+     * Gibt den Basispfad des Projekts zurück
+     */
+    public function getBasePath(): string
+    {
+        return $this->basePath;
+    }
+
+    /**
+     * Löst einen relativen Pfad zum Basispfad auf
+     */
+    public function resolvePath(string $relativePath): string
+    {
+        if (isset($this->resolvedPaths[$relativePath])) {
+            return $this->resolvedPaths[$relativePath];
+        }
+
+        $path = $this->basePath . '/' . ltrim($relativePath, '/');
+        $this->resolvedPaths[$relativePath] = $path;
+
+        return $path;
+    }
+
+    /**
+     * Prüft, ob ein Pfad im Projektverzeichnis existiert
+     */
+    public function pathExists(string $relativePath): bool
+    {
+        return file_exists($this->resolvePath($relativePath));
+    }
+
+    /**
+     * Konvertiert einen Namespace in einen relativen Pfad
+     */
+    public function namespaceToPath(string $namespace): ?string
+    {
+        $namespacePaths = $this->namespacePaths;
+
+        // Finde den passenden Namespace-Präfix
+        foreach ($namespacePaths as $prefix => $path) {
+            if (str_starts_with($namespace, $prefix)) {
+                $relativeNamespace = substr($namespace, strlen($prefix));
+                $relativePath = str_replace('\\', '/', $relativeNamespace);
+                return rtrim($path, '/') . '/' . $relativePath . '.php';
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Konvertiert einen Pfad in einen Namespace
+     */
+    public function pathToNamespace(string $path): ?string
+    {
+        $namespacePaths = $this->namespacePaths;
+        $absolutePath = realpath($path);
+
+        if (!$absolutePath) {
+            return null;
+        }
+
+        // Finde den passenden Pfad-Präfix
+        foreach ($namespacePaths as $namespace => $nsPath) {
+            $realNsPath = realpath($nsPath);
+
+            if ($realNsPath && str_starts_with($absolutePath, $realNsPath)) {
+                $relativePath = substr($absolutePath, strlen($realNsPath));
+                $relativePath = rtrim(str_replace('.php', '', $relativePath), '/');
+                $relativeNamespace = str_replace('/', '\\', $relativePath);
+                return $namespace . ltrim($relativeNamespace, '\\');
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Gibt den Pfad zum Cache-Verzeichnis zurück
+     */
+    public function getCachePath(string $path = ''): string
+    {
+        return $this->basePath . '/cache/' . ltrim($path, '/');
+    }
+
+    /**
+     * Gibt den Pfad zum Quellverzeichnis zurück
+     */
+    public function getSourcePath(string $path = ''): string
+    {
+        return $this->basePath . '/src/' . ltrim($path, '/');
+    }
+}