plain.pages 0.0.0__tar.gz

plain_pages-0.0.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, Dropseed, LLC
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

plain_pages-0.0.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: plain.pages
+Version: 0.0.0
+Summary: 
+Author: Dave Gaeddert
+Author-email: dave.gaeddert@dropseed.dev
+Requires-Python: >=3.8,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: mistune (>=3.0.0,<4.0.0)
+Requires-Dist: python-frontmatter (>=1.0.0,<2.0.0)

plain_pages-0.0.0/plain/pages/README.md

@@ -0,0 +1 @@
+# Pages

plain_pages-0.0.0/plain/pages/__init__.py

@@ -0,0 +1,5 @@
+from .views import PageView
+
+__all__ = [
+    "PageView",
+]

plain_pages-0.0.0/plain/pages/config.py

@@ -0,0 +1,18 @@
+import os
+
+from plain.packages import PackageConfig, packages
+from plain.runtime import APP_PATH
+
+from .registry import registry
+
+
+class PlainPagesConfig(PackageConfig):
+    name = "plain.pages"
+
+    def ready(self):
+        for pacakge_config in packages.get_package_configs():
+            registry.discover_pages(
+                os.path.join(pacakge_config.path, "templates", "pages")
+            )
+
+        registry.discover_pages(os.path.join(APP_PATH, "templates", "pages"))

plain_pages-0.0.0/plain/pages/default_settings.py

@@ -0,0 +1 @@
+PAGES_VIEW_CLASS = "plain.pages.PageView"

plain_pages-0.0.0/plain/pages/exceptions.py

@@ -0,0 +1,6 @@
+class PageNotFoundError(Exception):
+    pass
+
+
+class RedirectPageError(Exception):
+    pass

plain_pages-0.0.0/plain/pages/markdown.py

@@ -0,0 +1,34 @@
+import mistune
+from pygments import highlight
+from pygments.formatters import html
+from pygments.lexers import get_lexer_by_name
+
+from plain.utils.text import slugify
+
+
+class PagesRenderer(mistune.HTMLRenderer):
+    def heading(self, text, level, **attrs):
+        """Automatically add an ID to headings if one is not provided."""
+
+        if "id" not in attrs:
+            attrs["id"] = slugify(text)
+
+        return super().heading(text, level, **attrs)
+
+    def block_code(self, code, info=None):
+        """Highlight code blocks using Pygments."""
+
+        if info:
+            lexer = get_lexer_by_name(info, stripall=True)
+            formatter = html.HtmlFormatter(wrapcode=True)
+            return highlight(code, lexer, formatter)
+
+        return "<pre><code>" + mistune.escape(code) + "</code></pre>"
+
+
+def render_markdown(content):
+    renderer = PagesRenderer(escape=False)
+    markdown = mistune.create_markdown(
+        renderer=renderer, plugins=["strikethrough", "table"]
+    )
+    return markdown(content)

plain_pages-0.0.0/plain/pages/pages.py

@@ -0,0 +1,68 @@
+import os
+
+import frontmatter
+
+from plain.templates import Template
+from plain.utils.functional import cached_property
+
+from .markdown import render_markdown
+
+
+class Page:
+    def __init__(self, url_path, relative_path, absolute_path):
+        self.url_path = url_path
+        self.relative_path = relative_path
+        self.absolute_path = absolute_path
+
+    @cached_property
+    def _frontmatter(self):
+        with open(self.absolute_path) as f:
+            return frontmatter.load(f)
+
+    @cached_property
+    def vars(self):
+        return self._frontmatter.metadata
+
+    @cached_property
+    def title(self):
+        default_title = os.path.splitext(os.path.basename(self.relative_path))[0]
+        return self.vars.get("title", default_title)
+
+    @cached_property
+    def content(self):
+        # Strip the frontmatter
+        content = self._frontmatter.content
+
+        if not self.vars.get("render_plain", False):
+            template = Template(os.path.join("pages", self.relative_path))
+            content = template.render({})
+            # Strip the frontmatter again, since it was in the template file itself
+            _, content = frontmatter.parse(content)
+
+        if self.content_type == "markdown":
+            content = render_markdown(content)
+
+        return content
+
+    @property
+    def content_type(self):
+        extension = os.path.splitext(self.absolute_path)[1]
+
+        # Explicitly define the known content types that we intend to handle
+        # (others will still pass through)
+        if extension == ".md":
+            return "markdown"
+
+        if extension == ".html":
+            return "html"
+
+        if extension == ".redirect":
+            return "redirect"
+
+        return extension.lstrip(".")
+
+    def get_template_name(self):
+        if template_name := self.vars.get("template_name"):
+            return template_name
+
+        return f"{self.content_type}.html"

plain_pages-0.0.0/plain/pages/registry.py

@@ -0,0 +1,45 @@
+import os
+
+from .exceptions import PageNotFoundError
+from .pages import Page
+
+
+class PagesRegistry:
+    """
+    The registry loads up all the pages at once, so we only have to do a
+    dict key lookup at runtime to get a page.
+    """
+
+    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 url_paths(self):
+        return self.registered_pages.keys()
+
+    def discover_pages(self, pages_dir):
+        for root, dirs, 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)
+
+                if os.path.basename(url_path) == "index":
+                    url_path = os.path.dirname(url_path)
+
+                self.register_page(url_path, relative_path, absolute_path)
+
+    def get_page(self, url_path):
+        try:
+            url_path, relative_path, absolute_path = 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)
+        except KeyError:
+            raise PageNotFoundError(f"Could not find a page for {url_path}")
+
+
+registry = PagesRegistry()

plain_pages-0.0.0/plain/pages/templates/page.html

@@ -0,0 +1,9 @@
+{% extends "base.html" %}
+
+{% block title %}{{ page.title }}{% endblock %}
+
+{% block content %}
+
+{{ page.content|safe }}
+
+{% endblock %}

plain_pages-0.0.0/plain/pages/urls.py

@@ -0,0 +1,44 @@
+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())),
+]

plain_pages-0.0.0/plain/pages/views.py

@@ -0,0 +1,48 @@
+from plain.http import Http404, ResponsePermanentRedirect, ResponseRedirect
+from plain.utils.functional import cached_property
+from plain.views import TemplateView
+
+from .exceptions import PageNotFoundError, RedirectPageError
+from .registry import registry
+
+
+class PageView(TemplateView):
+    template_name = "page.html"
+
+    @cached_property
+    def page(self):
+        # Passed manually by the kwargs in the path definition
+        url_path = self.url_kwargs.get("url_path", "index")
+
+        try:
+            return registry.get_page(url_path)
+        except PageNotFoundError:
+            raise Http404()
+
+    def get_template_names(self) -> list[str]:
+        """
+        Allow for more specific user templates like
+        markdown.html or html.html
+        """
+        return [self.page.get_template_name()] + super().get_template_names()
+
+    def get_template_context(self):
+        context = super().get_template_context()
+        context["page"] = self.page
+        return context
+
+    def get(self):
+        if self.page.content_type == "redirect":
+            url = self.page.vars.get("url")
+
+            if not url:
+                raise RedirectPageError(
+                    f"Redirect page {self.page.url_path} is missing a url"
+                )
+
+            if self.page.vars.get("temporary", True):
+                return ResponseRedirect(url)
+            else:
+                return ResponsePermanentRedirect(url)
+
+        return super().get()

plain_pages-0.0.0/pyproject.toml

@@ -0,0 +1,25 @@
+[tool.poetry]
+name = "plain.pages"
+packages = [
+    { include = "plain" },
+]
+
+version = "0.0.0"
+description = ""
+authors = ["Dave Gaeddert <dave.gaeddert@dropseed.dev>"]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+mistune = "^3.0.0"
+python-frontmatter = "^1.0.0"
+
+[tool.poetry.dev-dependencies]
+pytest = "^7.1.2"
+ipdb = "^0.13.9"
+isort = "^5.10.1"
+black = "^23.1.0"
+pytest-django = "^4.5.2"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"