Pseudo-routing take two

packages/framework/src/Contracts/AbstractPage.php

@@ -99,14 +99,20 @@ public static function getOutputLocation(string $basename): string
     public string $slug;
 
     /** @inheritDoc */
-    public function getCurrentPagePath(): string
+    public function getSourcePath(): string
     {
-        return trim(static::getOutputDirectory().'/'.$this->slug, '/');
+        return static::qualifyBasename($this->slug);
     }
 
     /** @inheritDoc */
     public function getOutputPath(): string
     {
         return static::getCurrentPagePath().'.html';
     }
+
+    /** @inheritDoc */
+    public function getCurrentPagePath(): string
+    {
+        return trim(static::getOutputDirectory().'/'.$this->slug, '/');
+    }
 }

packages/framework/src/Contracts/PageContract.php

@@ -88,19 +88,26 @@ public static function qualifyBasename(string $basename): string;
     public static function getOutputLocation(string $basename): string;
 
     /**
-     * Get the URI path relative to the site root.
+     * Get the path to the source file, relative to the project root.
      *
-     * @example if the compiled page will be saved to _site/docs/index.html,
-     *          then this method will return 'docs/index'
-     *
-     * @return string URI path relative to the site root.
+     * @return string Path relative to the project root.
      */
-    public function getCurrentPagePath(): string;
+    public function getSourcePath(): string;
 
     /**
      * Get the path where the compiled page will be saved.
      *
-     * @return string Relative to the site output directory.
+     * @return string Path relative to the site output directory.
      */
     public function getOutputPath(): string;
+
+    /**
+     * Get the URI path relative to the site root.
+     *
+     * @example if the compiled page will be saved to _site/docs/index.html,
+     *          then this method will return 'docs/index'
+     *
+     * @return string URI path relative to the site root.
+     */
+    public function getCurrentPagePath(): string;
 }

packages/framework/src/Modules/Routing/Route.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace Hyde\Framework\Modules\Routing;
+
+use Hyde\Framework\Contracts\PageContract;
+
+/**
+ * @see \Hyde\Framework\Testing\Feature\RouteTest
+ */
+class Route implements RouteContract
+{
+    /**
+     * The source model for the route.
+     *
+     * @var \Hyde\Framework\Contracts\PageContract
+     */
+    protected PageContract $sourceModel;
+
+    /**
+     * The unique route key for the route.
+     *
+     * @var string The route key. Generally <output-directory/slug>.
+     */
+    protected string $routeKey;
+
+    /** @inheritDoc */
+    public function __construct(PageContract $sourceModel)
+    {
+        $this->sourceModel = $sourceModel;
+        $this->routeKey = $this->constructRouteKey();
+    }
+
+    /** @inheritDoc */
+    public function getSourceModel(): PageContract
+    {
+        return $this->sourceModel;
+    }
+
+    /** @inheritDoc */
+    public function getRouteKey(): string
+    {
+        return $this->routeKey;
+    }
+
+    /** @inheritDoc */
+    public function getSourceFilePath(): string
+    {
+        return $this->sourceModel->getSourcePath();
+    }
+
+    /** @inheritDoc */
+    public function getOutputFilePath(): string
+    {
+        return $this->sourceModel->getOutputPath();
+    }
+
+    /** @inheritDoc */
+    public static function get(string $routeKey): ?RouteContract
+    {
+        return Router::getInstance()->getRoutes()->get($routeKey);
+    }
+
+    /** @inheritDoc */
+    public static function getOrFail(string $routeKey): RouteContract
+    {
+        return static::get($routeKey) ?? throw new RouteNotFoundException($routeKey);
+    }
+
+    protected function constructRouteKey(): string
+    {
+        return $this->sourceModel->getCurrentPagePath();
+    }
+}

packages/framework/src/Modules/Routing/RouteContract.php

@@ -0,0 +1,61 @@
+<?php
+
+namespace Hyde\Framework\Modules\Routing;
+
+use Hyde\Framework\Contracts\PageContract;
+
+interface RouteContract
+{
+    /**
+     * Construct a new Route instance for the given page model.
+     *
+     * @param  \Hyde\Framework\Contracts\PageContract  $sourceModel
+     */
+    public function __construct(PageContract $sourceModel);
+
+    /**
+     * Get the source model for the route.
+     *
+     * @return \Hyde\Framework\Contracts\PageContract
+     */
+    public function getSourceModel(): PageContract;
+
+    /**
+     * Get the unique route key for the route.
+     *
+     * @return string The route key. Generally <output-directory/slug>.
+     */
+    public function getRouteKey(): string;
+
+    /**
+     * Get the path to the source file.
+     *
+     * @return string Path relative to the root of the project.
+     */
+    public function getSourceFilePath(): string;
+
+    /**
+     * Get the path to the output file.
+     *
+     * @return string Path relative to the site output directory.
+     */
+    public function getOutputFilePath(): string;
+
+    /**
+     * Get a route from the Router index for the specified route key.
+     *
+     * @param  string  $routeKey
+     * @return \Hyde\Framework\Modules\Routing\RouteContract|null
+     */
+    public static function get(string $routeKey): ?RouteContract;
+
+    /**
+     * Same as static::get(), but throws an exception if the route key is not found.
+     *
+     * @param  string  $routeKey
+     * @return \Hyde\Framework\Modules\Routing\RouteContract
+     *
+     * @throws \Hyde\Framework\Modules\Routing\RouteNotFoundException
+     */
+    public static function getOrFail(string $routeKey): RouteContract;
+}

packages/framework/src/Modules/Routing/RouteNotFoundException.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Hyde\Framework\Modules\Routing;
+
+class RouteNotFoundException extends \Exception
+{
+    protected $message = 'Route not found.';
+    protected $code = 404;
+
+    public function __construct(?string $routeKey = null)
+    {
+        if ($routeKey) {
+            $this->message = "Route not found: '$routeKey'";
+        }
+
+        parent::__construct($this->message, $this->code);
+    }
+}

packages/framework/src/Modules/Routing/Router.php

@@ -0,0 +1,99 @@
+<?php
+
+namespace Hyde\Framework\Modules\Routing;
+
+use Hyde\Framework\Contracts\PageContract;
+use Hyde\Framework\Models\Pages\BladePage;
+use Hyde\Framework\Models\Pages\DocumentationPage;
+use Hyde\Framework\Models\Pages\MarkdownPage;
+use Hyde\Framework\Models\Pages\MarkdownPost;
+use Illuminate\Support\Collection;
+
+/**
+ * Pseudo-Router for Hyde.
+ *
+ * This is not a router in the traditional sense that it decides where to go.
+ * Instead, it creates a pre-generated object encapsulating the Hyde autodiscovery.
+ *
+ * If successful, this will not only let us emulate Laravel route helpers, but also
+ * serve as the canonical source of truth for the Hyde autodiscovery process.
+ *
+ * The routes defined can then also be used to power the RealtimeCompiler without
+ * having to reverse-engineer the source file mapping.
+ *
+ * Routes cannot be added manually, instead the route index is created using the
+ * exact same rules as the current autodiscovery process and compiled file output.
+ *
+ * The route index shall serve as a multidimensional mapping allowing you to
+ * determine where a source file will be compiled to, and where a compiled
+ * file was generated from.
+ *
+ * @todo Convert into Singleton.
+ *       As the constructor needs to load and parse every single page,
+ *       this could be a rather expensive operation that would benefit
+ *       from being a singleton. It could also be a good idea to cache
+ *       the parsed route index using the Laravel cache in the future.
+ *
+ * @see \Hyde\Framework\Testing\Feature\RouterTest
+ */
+class Router implements RouterContract
+{
+    /**
+     * The routes discovered by the router.
+     *
+     * @var \Illuminate\Support\Collection<\Hyde\Framework\Modules\Routing\RouteContract>
+     */
+    protected Collection $routes;
+
+    /** @inheritDoc */
+    public function __construct()
+    {
+        $this->discoverRoutes();
+    }
+
+    /** @inheritDoc */
+    public static function getInstance(): RouterContract
+    {
+        return new static();
+    }
+
+    /** @inheritDoc */
+    public function getRoutes(): Collection
+    {
+        return $this->routes;
+    }
+
+    protected function discover(PageContract $page): self
+    {
+        $route = new Route($page);
+        $this->routes->put($route->getRouteKey(), $route);
+
+        return $this;
+    }
+
+    protected function discoverRoutes(): self
+    {
+        $this->routes = new Collection();
+
+        $pages = [
+            BladePage::class,
+            MarkdownPage::class,
+            MarkdownPost::class,
+            DocumentationPage::class,
+        ];
+
+        foreach ($pages as $page) {
+            $this->discoverPageRoutes($page);
+        }
+
+        return $this;
+    }
+
+    protected function discoverPageRoutes(string $pageClass): void
+    {
+        /** @var PageContract $pageClass */
+        $pageClass::all()->each(function ($page) {
+            $this->discover($page);
+        });
+    }
+}

packages/framework/src/Modules/Routing/RouterContract.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Hyde\Framework\Modules\Routing;
+
+use Illuminate\Support\Collection;
+
+interface RouterContract
+{
+    /**
+     * Construct a new Router instance and discover all routes.
+     */
+    public function __construct();
+
+    /**
+     * Get the Singleton instance of the Router.
+     *
+     * @return \Hyde\Framework\Modules\Routing\RouterContract
+     */
+    public static function getInstance(): RouterContract;
+
+    /**
+     * Get the routes discovered by the router.
+     *
+     * @return \Illuminate\Support\Collection<\Hyde\Framework\Modules\Routing\RouteContract>
+     */
+    public function getRoutes(): Collection;
+}

packages/framework/tests/Feature/AbstractPageTest.php

@@ -184,6 +184,14 @@ public function test_get_output_path_returns_current_page_path_with_html_extensi
         $this->assertEquals('foo.html', $page->getOutputPath());
     }
 
+    public function test_get_source_path_returns_qualified_basename()
+    {
+        $this->assertEquals(
+            MarkdownPage::qualifyBasename('foo'),
+            (new MarkdownPage(slug: 'foo'))->getSourcePath()
+        );
+    }
+
     public function test_markdown_page_implements_page_contract()
     {
         $this->assertInstanceOf(PageContract::class, new class extends AbstractPage {});