Refactor plain pages and add asset handling to it

Author: davegaeddert

plain-pages/plain/pages/default_settings.py

@@ -9,8 +9,7 @@
 
 
 class Page:
-    def __init__(self, url_path, relative_path, absolute_path):
-        self.url_path = url_path
+    def __init__(self, relative_path, absolute_path):
         self.relative_path = relative_path
         self.absolute_path = absolute_path
 
@@ -39,30 +38,64 @@ def content(self):
             # Strip the frontmatter again, since it was in the template file itself
             _, content = frontmatter.parse(content)
 
-        if self.content_type == "markdown":
+        if self.is_markdown():
             content = render_markdown(content)
 
         return content
 
-    @property
-    def content_type(self):
+    def is_markdown(self):
         extension = os.path.splitext(self.absolute_path)[1]
+        return extension == ".md"
 
-        # Explicitly define the known content types that we intend to handle
-        # (others will still pass through)
-        if extension == ".md":
-            return "markdown"
+    def is_template(self):
+        return ".template." in os.path.basename(self.absolute_path)
 
-        if extension == ".html":
-            return "html"
+    def is_asset(self):
+        extension = os.path.splitext(self.absolute_path)[1]
+        return extension.lower() in (
+            ".jpg",
+            ".jpeg",
+            ".png",
+            ".gif",
+            ".webp",
+            ".svg",
+            ".js",
+            ".css",
+            ".ico",
+        )
+
+    def is_redirect(self):
+        extension = os.path.splitext(self.absolute_path)[1]
+        return extension == ".redirect"
+
+    def get_url_path(self) -> str | None:
+        if self.is_template():
+            return None
+
+        if self.is_asset():
+            return self.relative_path
+
+        url_path = os.path.splitext(self.relative_path)[0]
 
-        if extension == ".redirect":
-            return "redirect"
+        # If it's an index.html or something, the url is the parent dir
+        if os.path.basename(url_path) == "index":
+            url_path = os.path.dirname(url_path)
 
-        return extension.lstrip(".")
+        return url_path + "/"  # With trailing slash
 
     def get_template_name(self):
         if template_name := self.vars.get("template_name"):
             return template_name
 
-        return f"{self.content_type}.html"
+        return ""
+
+    def get_view_class(self):
+        from .views import PageAssetView, PageRedirectView, PageView
+
+        if self.is_redirect():
+            return PageRedirectView
+
+        if self.is_asset():
+            return PageAssetView
+
+        return PageView

plain-pages/plain/pages/pages.py

@@ -1,5 +1,7 @@
 import os
 
+from plain.urls import path
+
 from .exceptions import PageNotFoundError
 from .pages import Page
 
@@ -14,34 +16,59 @@ def __init__(self):
         # url path -> file path
         self.registered_pages = {}
 
-    def register_page(self, url_path, relative_path, absolute_path):
-        self.registered_pages[url_path] = (url_path, relative_path, absolute_path)
+    def get_page_urls(self):
+        """
+        Generate a list of real urls based on the files that exist.
+        This way, you get a concrete url reversingerror if you try
+        to refer to a page/url that isn't going to work.
+        """
+        paths = []
+
+        for url_path in self.registered_pages.keys():
+            if url_path == "":
+                # The root index is a special case and should be
+                # referred to as pages:index
+                url = ""
+                name = "index"
+            else:
+                url = url_path
+                name = url_path
+
+            page = self.get_page(url_path)
+            view_class = page.get_view_class()
 
-    def url_paths(self):
-        return self.registered_pages.keys()
+            paths.append(
+                path(
+                    url,
+                    view_class,
+                    name=name,
+                    kwargs={"url_path": url_path},
+                )
+            )
+
+        return paths
 
     def discover_pages(self, pages_dir):
-        for root, dirs, files in os.walk(pages_dir):
+        for root, _, files in os.walk(pages_dir):
             for file in files:
                 relative_path = os.path.relpath(os.path.join(root, file), pages_dir)
-                url_path = os.path.splitext(relative_path)[0]
                 absolute_path = os.path.join(root, file)
 
-                # Skip template files
-                if ".template." in absolute_path:
-                    continue
+                page_args = (relative_path, absolute_path)
+                url_path = Page(*page_args).get_url_path()
 
-                if os.path.basename(url_path) == "index":
-                    url_path = os.path.dirname(url_path)
+                # Some pages don't get a url (like templates)
+                if url_path is None:
+                    continue
 
-                self.register_page(url_path, relative_path, absolute_path)
+                self.registered_pages[url_path] = page_args
 
     def get_page(self, url_path):
         try:
-            url_path, relative_path, absolute_path = self.registered_pages[url_path]
+            page_args = self.registered_pages[url_path]
             # Instantiate the page here, so we don't store a ton of cached data over time
             # as we render all the pages
-            return Page(url_path, relative_path, absolute_path)
+            return Page(*page_args)
         except KeyError:
             raise PageNotFoundError(f"Could not find a page for {url_path}")
 

plain-pages/plain/pages/registry.py

@@ -1,44 +1,10 @@
-from plain.runtime import settings
 from plain.urls import include, path
-from plain.utils.module_loading import import_string
 
 from .registry import registry
 
 default_namespace = "pages"
 
 
-def get_page_urls():
-    """
-    Generate a list of real urls based on the files that exist.
-    This way, you get a concrete url reversingerror if you try
-    to refer to a page/url that isn't going to work.
-    """
-    paths = []
-
-    view_class = import_string(settings.PAGES_VIEW_CLASS)
-
-    for url_path in registry.url_paths():
-        if url_path == "":
-            # The root index is a special case and should be
-            # referred to as pages:index
-            url = ""
-            name = "index"
-        else:
-            url = url_path + "/"
-            name = url_path
-
-        paths.append(
-            path(
-                url,
-                view_class,
-                name=name,
-                kwargs={"url_path": url_path},
-            )
-        )
-
-    return paths
-
-
 urlpatterns = [
-    path("", include(get_page_urls())),
+    path("", include(registry.get_page_urls())),
 ]

plain-pages/plain/pages/urls.py

@@ -1,14 +1,13 @@
+from plain.assets.views import AssetView
 from plain.http import Http404, ResponsePermanentRedirect, ResponseRedirect
 from plain.utils.functional import cached_property
-from plain.views import TemplateView
+from plain.views import TemplateView, View
 
 from .exceptions import PageNotFoundError, RedirectPageError
 from .registry import registry
 
 
-class PageView(TemplateView):
-    template_name = "page.html"
-
+class PageViewMixin:
     @cached_property
     def page(self):
         # Passed manually by the kwargs in the path definition
@@ -19,6 +18,10 @@ def page(self):
         except PageNotFoundError:
             raise Http404()
 
+
+class PageView(PageViewMixin, TemplateView):
+    template_name = "page.html"
+
     def get_template_names(self) -> list[str]:
         """
         Allow for more specific user templates like
@@ -31,18 +34,29 @@ def get_template_context(self):
         context["page"] = self.page
         return context
 
+
+class PageRedirectView(PageViewMixin, View):
     def get(self):
-        if self.page.content_type == "redirect":
-            url = self.page.vars.get("url")
+        # Passed manually by the kwargs in the path definition
+        url_path = self.url_kwargs.get("url_path", "index")
+
+        url = self.page.vars.get("url")
+
+        if not url:
+            raise RedirectPageError(f"Redirect page {url_path} is missing a url")
+
+        if self.page.vars.get("temporary", True):
+            return ResponseRedirect(url)
+        else:
+            return ResponsePermanentRedirect(url)
+
 
-            if not url:
-                raise RedirectPageError(
-                    f"Redirect page {self.page.url_path} is missing a url"
-                )
+class PageAssetView(PageViewMixin, AssetView):
+    def get_url_path(self):
+        return self.url_kwargs["url_path"]
 
-            if self.page.vars.get("temporary", True):
-                return ResponseRedirect(url)
-            else:
-                return ResponsePermanentRedirect(url)
+    def get_asset_path(self, path):
+        return self.page.absolute_path
 
-        return super().get()
+    def get_debug_asset_path(self, path):
+        return self.page.absolute_path