skrift 0.1.0a14__py3-none-any.whl → 0.1.0a16__py3-none-any.whl

skrift/lib/hooks.py

@@ -0,0 +1,292 @@
+"""WordPress-like hook/filter system for Skrift CMS extensibility.
+
+This module provides an async-first hook system that allows registering
+callbacks to be executed at specific points in the application lifecycle.
+
+Actions: Execute callbacks without modifying a value (side effects)
+Filters: Execute callbacks that can modify a value (transformations)
+
+Usage:
+    from skrift.lib.hooks import hooks, action, filter
+
+    # Using decorators (auto-registered on import)
+    @action("after_page_save", priority=10)
+    async def notify_on_page_save(page):
+        print(f"Page saved: {page.title}")
+
+    @filter("page_seo_meta", priority=10)
+    async def add_custom_meta(meta, page):
+        meta["author"] = "Custom Author"
+        return meta
+
+    # Using direct registration
+    hooks.add_action("before_page_save", my_callback)
+    hooks.add_filter("page_og_meta", my_modifier)
+
+    # Triggering hooks
+    await hooks.do_action("after_page_save", page)
+    meta = await hooks.apply_filters("page_seo_meta", {}, page)
+"""
+
+import asyncio
+from collections import defaultdict
+from dataclasses import dataclass, field
+from functools import wraps
+from typing import Any, Callable, TypeVar
+
+T = TypeVar("T")
+
+
+@dataclass(order=True)
+class HookHandler:
+    """A registered hook handler with priority."""
+
+    priority: int
+    callback: Callable = field(compare=False)
+
+    async def call(self, *args: Any, **kwargs: Any) -> Any:
+        """Call the handler, handling both sync and async callbacks."""
+        result = self.callback(*args, **kwargs)
+        if asyncio.iscoroutine(result):
+            return await result
+        return result
+
+
+class HookRegistry:
+    """Central registry for all hooks (actions and filters)."""
+
+    def __init__(self) -> None:
+        self._actions: dict[str, list[HookHandler]] = defaultdict(list)
+        self._filters: dict[str, list[HookHandler]] = defaultdict(list)
+
+    def add_action(
+        self,
+        hook_name: str,
+        callback: Callable[..., Any],
+        priority: int = 10,
+    ) -> None:
+        """Register an action callback.
+
+        Args:
+            hook_name: Name of the action hook
+            callback: Function to call when action is triggered
+            priority: Lower numbers execute first (default: 10)
+        """
+        handler = HookHandler(priority=priority, callback=callback)
+        self._actions[hook_name].append(handler)
+        self._actions[hook_name].sort()
+
+    def add_filter(
+        self,
+        hook_name: str,
+        callback: Callable[..., T],
+        priority: int = 10,
+    ) -> None:
+        """Register a filter callback.
+
+        Args:
+            hook_name: Name of the filter hook
+            callback: Function to call to modify value
+            priority: Lower numbers execute first (default: 10)
+        """
+        handler = HookHandler(priority=priority, callback=callback)
+        self._filters[hook_name].append(handler)
+        self._filters[hook_name].sort()
+
+    def remove_action(
+        self,
+        hook_name: str,
+        callback: Callable[..., Any],
+    ) -> bool:
+        """Remove an action callback.
+
+        Args:
+            hook_name: Name of the action hook
+            callback: Function to remove
+
+        Returns:
+            True if callback was found and removed
+        """
+        handlers = self._actions.get(hook_name, [])
+        for i, handler in enumerate(handlers):
+            if handler.callback is callback:
+                handlers.pop(i)
+                return True
+        return False
+
+    def remove_filter(
+        self,
+        hook_name: str,
+        callback: Callable[..., Any],
+    ) -> bool:
+        """Remove a filter callback.
+
+        Args:
+            hook_name: Name of the filter hook
+            callback: Function to remove
+
+        Returns:
+            True if callback was found and removed
+        """
+        handlers = self._filters.get(hook_name, [])
+        for i, handler in enumerate(handlers):
+            if handler.callback is callback:
+                handlers.pop(i)
+                return True
+        return False
+
+    def has_action(self, hook_name: str) -> bool:
+        """Check if any actions are registered for a hook."""
+        return bool(self._actions.get(hook_name))
+
+    def has_filter(self, hook_name: str) -> bool:
+        """Check if any filters are registered for a hook."""
+        return bool(self._filters.get(hook_name))
+
+    async def do_action(
+        self,
+        hook_name: str,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """Execute all registered action callbacks.
+
+        Args:
+            hook_name: Name of the action hook
+            *args: Positional arguments to pass to callbacks
+            **kwargs: Keyword arguments to pass to callbacks
+        """
+        handlers = self._actions.get(hook_name, [])
+        for handler in handlers:
+            await handler.call(*args, **kwargs)
+
+    async def apply_filters(
+        self,
+        hook_name: str,
+        value: T,
+        *args: Any,
+        **kwargs: Any,
+    ) -> T:
+        """Apply all registered filter callbacks to a value.
+
+        Args:
+            hook_name: Name of the filter hook
+            value: Initial value to filter
+            *args: Additional positional arguments to pass to callbacks
+            **kwargs: Keyword arguments to pass to callbacks
+
+        Returns:
+            The filtered value after all callbacks have been applied
+        """
+        handlers = self._filters.get(hook_name, [])
+        for handler in handlers:
+            value = await handler.call(value, *args, **kwargs)
+        return value
+
+    def clear(self) -> None:
+        """Clear all registered hooks. Useful for testing."""
+        self._actions.clear()
+        self._filters.clear()
+
+
+# Global singleton registry
+hooks = HookRegistry()
+
+
+# Convenience functions that use the global registry
+def add_action(
+    hook_name: str,
+    callback: Callable[..., Any],
+    priority: int = 10,
+) -> None:
+    """Register an action callback to the global registry."""
+    hooks.add_action(hook_name, callback, priority)
+
+
+def add_filter(
+    hook_name: str,
+    callback: Callable[..., T],
+    priority: int = 10,
+) -> None:
+    """Register a filter callback to the global registry."""
+    hooks.add_filter(hook_name, callback, priority)
+
+
+def remove_action(hook_name: str, callback: Callable[..., Any]) -> bool:
+    """Remove an action callback from the global registry."""
+    return hooks.remove_action(hook_name, callback)
+
+
+def remove_filter(hook_name: str, callback: Callable[..., Any]) -> bool:
+    """Remove a filter callback from the global registry."""
+    return hooks.remove_filter(hook_name, callback)
+
+
+async def do_action(hook_name: str, *args: Any, **kwargs: Any) -> None:
+    """Execute all registered action callbacks via the global registry."""
+    await hooks.do_action(hook_name, *args, **kwargs)
+
+
+async def apply_filters(hook_name: str, value: T, *args: Any, **kwargs: Any) -> T:
+    """Apply all registered filter callbacks via the global registry."""
+    return await hooks.apply_filters(hook_name, value, *args, **kwargs)
+
+
+# Decorator factories for auto-registration
+def action(hook_name: str, priority: int = 10) -> Callable[[Callable], Callable]:
+    """Decorator to register a function as an action handler.
+
+    Usage:
+        @action("after_page_save", priority=5)
+        async def my_handler(page):
+            ...
+    """
+
+    def decorator(func: Callable) -> Callable:
+        hooks.add_action(hook_name, func, priority)
+
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def filter(hook_name: str, priority: int = 10) -> Callable[[Callable], Callable]:
+    """Decorator to register a function as a filter handler.
+
+    Usage:
+        @filter("page_seo_meta", priority=5)
+        async def my_filter(meta, page):
+            meta["custom"] = "value"
+            return meta
+    """
+
+    def decorator(func: Callable) -> Callable:
+        hooks.add_filter(hook_name, func, priority)
+
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+# Define standard hook names as constants for discoverability
+# Actions
+BEFORE_PAGE_SAVE = "before_page_save"
+AFTER_PAGE_SAVE = "after_page_save"
+BEFORE_PAGE_DELETE = "before_page_delete"
+AFTER_PAGE_DELETE = "after_page_delete"
+
+# Filters
+PAGE_SEO_META = "page_seo_meta"
+PAGE_OG_META = "page_og_meta"
+SITEMAP_URLS = "sitemap_urls"
+SITEMAP_PAGE = "sitemap_page"
+ROBOTS_TXT = "robots_txt"
+TEMPLATE_CONTEXT = "template_context"

skrift/lib/seo.py

@@ -0,0 +1,103 @@
+"""SEO utilities for generating page metadata."""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from skrift.lib.hooks import hooks, PAGE_SEO_META, PAGE_OG_META
+
+if TYPE_CHECKING:
+    from skrift.db.models import Page
+
+
+@dataclass
+class SEOMeta:
+    """Standard SEO metadata for a page."""
+
+    title: str
+    description: str | None
+    canonical_url: str
+    robots: str | None
+
+
+@dataclass
+class OpenGraphMeta:
+    """OpenGraph metadata for social sharing."""
+
+    title: str
+    description: str | None
+    image: str | None
+    url: str
+    site_name: str
+    type: str = "website"
+
+
+async def get_page_seo_meta(
+    page: "Page",
+    site_name: str,
+    base_url: str,
+) -> SEOMeta:
+    """Generate SEO metadata for a page.
+
+    Args:
+        page: The page to generate metadata for
+        site_name: The site name for title suffix
+        base_url: Base URL for canonical URL generation
+
+    Returns:
+        SEOMeta dataclass with the metadata
+    """
+    # Build canonical URL
+    slug = page.slug.strip("/")
+    canonical_url = f"{base_url.rstrip('/')}/{slug}" if slug else base_url.rstrip("/")
+
+    # Build title with site name suffix
+    title = f"{page.title} | {site_name}" if site_name else page.title
+
+    meta = SEOMeta(
+        title=title,
+        description=page.meta_description,
+        canonical_url=canonical_url,
+        robots=page.meta_robots,
+    )
+
+    # Apply filter for extensibility
+    meta = await hooks.apply_filters(PAGE_SEO_META, meta, page, site_name, base_url)
+
+    return meta
+
+
+async def get_page_og_meta(
+    page: "Page",
+    site_name: str,
+    base_url: str,
+) -> OpenGraphMeta:
+    """Generate OpenGraph metadata for a page.
+
+    Args:
+        page: The page to generate metadata for
+        site_name: The site name
+        base_url: Base URL for URL generation
+
+    Returns:
+        OpenGraphMeta dataclass with the metadata
+    """
+    # Build URL
+    slug = page.slug.strip("/")
+    url = f"{base_url.rstrip('/')}/{slug}" if slug else base_url.rstrip("/")
+
+    # Use og_* fields if set, otherwise fall back to page fields
+    og_title = page.og_title or page.title
+    og_description = page.og_description or page.meta_description
+
+    meta = OpenGraphMeta(
+        title=og_title,
+        description=og_description,
+        image=page.og_image,
+        url=url,
+        site_name=site_name,
+    )
+
+    # Apply filter for extensibility
+    meta = await hooks.apply_filters(PAGE_OG_META, meta, page, site_name, base_url)
+
+    return meta

skrift/static/css/style.css

@@ -630,11 +630,96 @@ article footer {
 
 /* Flash messages */
 .flash-messages {
-    margin-bottom: var(--spacing-lg);
+    position: fixed;
+    top: var(--spacing-md);
+    right: var(--spacing-md);
+    z-index: 1000;
+    max-width: 400px;
 }
 
-.flash-messages [role="alert"] {
+.flash {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.75rem 1rem;
     margin-bottom: var(--spacing-sm);
+    border-radius: var(--radius-md);
+    box-shadow: var(--shadow-md);
+    animation: flash-slide-in 0.3s ease;
+    transition: opacity 0.3s ease;
+}
+
+.flash-success {
+    background-color: #d4edda;
+    border-left: 4px solid #28a745;
+    color: #155724;
+}
+
+.flash-error {
+    background-color: #f8d7da;
+    border-left: 4px solid #dc3545;
+    color: #721c24;
+}
+
+.flash-warning {
+    background-color: #fff3cd;
+    border-left: 4px solid #ffc107;
+    color: #856404;
+}
+
+.flash-info {
+    background-color: #d1ecf1;
+    border-left: 4px solid #17a2b8;
+    color: #0c5460;
+}
+
+/* Dark mode flash colors */
+@media (prefers-color-scheme: dark) {
+    .flash-success { background-color: #1a3d24; color: #9ae6b4; }
+    .flash-error { background-color: #3d1a1a; color: #feb2b2; }
+    .flash-warning { background-color: #3d3d1a; color: #faf089; }
+    .flash-info { background-color: #1a3d3d; color: #90cdf4; }
+}
+
+[data-theme="dark"] .flash-success { background-color: #1a3d24; color: #9ae6b4; }
+[data-theme="dark"] .flash-error { background-color: #3d1a1a; color: #feb2b2; }
+[data-theme="dark"] .flash-warning { background-color: #3d3d1a; color: #faf089; }
+[data-theme="dark"] .flash-info { background-color: #1a3d3d; color: #90cdf4; }
+
+.flash-message {
+    flex: 1;
+}
+
+.flash-dismiss {
+    background: none;
+    border: none;
+    font-size: 1.25rem;
+    cursor: pointer;
+    opacity: 0.5;
+    margin-left: var(--spacing-sm);
+    padding: 0;
+    line-height: 1;
+    color: inherit;
+    box-shadow: none;
+    border-radius: 0;
+}
+
+.flash-dismiss:hover {
+    opacity: 1;
+    background: none;
+    box-shadow: none;
+    transform: none;
+}
+
+@keyframes flash-slide-in {
+    from {
+        transform: translateX(100%);
+        opacity: 0;
+    }
+    to {
+        transform: translateX(0);
+        opacity: 1;
+    }
 }
 
 /* ========================================
@@ -936,6 +1021,11 @@ main.container.admin-layout {
     color: var(--color-text-muted);
 }
 
+.status-scheduled {
+    background-color: #ffc107;
+    color: #856404;
+}
+
 .type-badge {
     display: inline-block;
     padding: 0.125rem 0.5rem;

skrift/templates/admin/pages/edit.html

@@ -19,14 +19,54 @@
     <label for="content">Content</label>
     <textarea id="content" name="content" rows="15">{{ page.content if page else '' }}</textarea>
 
-    <label>
-        <input type="checkbox" name="is_published" {% if page and page.is_published %}checked{% endif %}>
-        Published
-    </label>
+    <fieldset class="form-group">
+        <legend>Publication</legend>
+
+        <label>
+            <input type="checkbox" name="is_published" {% if page and page.is_published %}checked{% endif %}>
+            Published
+        </label>
+
+        <label for="order">Display Order</label>
+        <input type="number" id="order" name="order" value="{{ page.order if page else 0 }}" min="0">
+        <small class="text-muted">Lower numbers appear first (default: 0)</small>
+
+        <label for="publish_at">Schedule Publish</label>
+        <input type="datetime-local" id="publish_at" name="publish_at" value="{{ page.publish_at.strftime('%Y-%m-%dT%H:%M') if page and page.publish_at else '' }}">
+        <small class="text-muted">Leave empty to publish immediately when published is checked</small>
+    </fieldset>
+
+    <details class="seo-settings">
+        <summary>SEO Settings</summary>
+        <fieldset>
+            <label for="meta_description">Meta Description</label>
+            <textarea id="meta_description" name="meta_description" rows="3" maxlength="320" placeholder="Brief description for search engines (max 320 chars)">{{ page.meta_description if page else '' }}</textarea>
+
+            <label for="meta_robots">Meta Robots</label>
+            <select id="meta_robots" name="meta_robots">
+                <option value="">Default (index, follow)</option>
+                <option value="noindex" {% if page and page.meta_robots == 'noindex' %}selected{% endif %}>noindex</option>
+                <option value="nofollow" {% if page and page.meta_robots == 'nofollow' %}selected{% endif %}>nofollow</option>
+                <option value="noindex, nofollow" {% if page and page.meta_robots == 'noindex, nofollow' %}selected{% endif %}>noindex, nofollow</option>
+            </select>
+
+            <label for="og_title">OpenGraph Title</label>
+            <input type="text" id="og_title" name="og_title" value="{{ page.og_title if page else '' }}" placeholder="Custom title for social sharing (uses page title if empty)">
+
+            <label for="og_description">OpenGraph Description</label>
+            <textarea id="og_description" name="og_description" rows="2" placeholder="Custom description for social sharing">{{ page.og_description if page else '' }}</textarea>
+
+            <label for="og_image">OpenGraph Image URL</label>
+            <input type="url" id="og_image" name="og_image" value="{{ page.og_image if page else '' }}" placeholder="https://example.com/image.jpg">
+        </fieldset>
+    </details>
 
     <div class="form-actions">
         <button type="submit">{{ "Update" if page else "Create" }} Page</button>
         <a href="/admin/pages" role="button" class="outline">Cancel</a>
+        {% if page %}
+        <a href="/admin/pages/{{ page.id }}/revisions" role="button" class="outline secondary">View History</a>
+        {% endif %}
     </div>
 </form>
 {% endblock %}

skrift/templates/admin/pages/list.html

@@ -14,6 +14,7 @@
 <table class="admin-table">
     <thead>
         <tr>
+            <th>Order</th>
             <th>Title</th>
             <th>Slug</th>
             <th>Status</th>
@@ -24,13 +25,19 @@
     <tbody>
         {% for page in pages %}
         <tr>
+            <td class="text-muted">{{ page.order }}</td>
             <td>
                 <a href="/{{ page.slug }}">{{ page.title }}</a>
             </td>
             <td class="text-muted">/{{ page.slug }}</td>
             <td>
                 {% if page.is_published %}
-                    <span class="status-badge status-published">Published</span>
+                    {% if page.publish_at and page.publish_at > now() %}
+                        <span class="status-badge status-scheduled">Scheduled</span>
+                        <small class="text-muted">{{ page.publish_at.strftime('%b %d, %Y %H:%M') }}</small>
+                    {% else %}
+                        <span class="status-badge status-published">Published</span>
+                    {% endif %}
                 {% else %}
                     <span class="status-badge status-draft">Draft</span>
                 {% endif %}

skrift/templates/admin/pages/revisions.html

@@ -0,0 +1,59 @@
+{% extends "admin/base.html" %}
+
+{% block title %}Revision History - {{ page.title }} - Admin - {{ site_name() }}{% endblock %}
+
+{% block admin_content %}
+<hgroup>
+    <h1>Revision History</h1>
+    <p>{{ page.title }}</p>
+</hgroup>
+
+<div class="form-actions" style="margin-bottom: 1rem;">
+    <a href="/admin/pages/{{ page.id }}/edit" role="button" class="outline">&larr; Back to Edit</a>
+</div>
+
+{% if revisions %}
+<table class="admin-table">
+    <thead>
+        <tr>
+            <th>#</th>
+            <th>Title</th>
+            <th>Changed By</th>
+            <th>Date</th>
+            <th>Actions</th>
+        </tr>
+    </thead>
+    <tbody>
+        {% for revision in revisions %}
+        <tr>
+            <td>{{ revision.revision_number }}</td>
+            <td>{{ revision.title }}</td>
+            <td>
+                {% if revision.user %}
+                    {{ revision.user.name or revision.user.email }}
+                {% else %}
+                    <span class="text-muted">System</span>
+                {% endif %}
+            </td>
+            <td>{{ revision.created_at.strftime('%Y-%m-%d %H:%M') }}</td>
+            <td class="actions-cell">
+                <form method="post" action="/admin/pages/{{ page.id }}/revisions/{{ revision.id }}/restore" class="inline-form" onsubmit="return confirm('Restore to revision #{{ revision.revision_number }}? This will create a new revision of the current state first.');">
+                    <button type="submit" class="outline small">Restore</button>
+                </form>
+            </td>
+        </tr>
+        {% endfor %}
+    </tbody>
+</table>
+{% else %}
+<p class="no-items">No revisions yet. Revisions are created when you save changes to a page.</p>
+{% endif %}
+
+<details style="margin-top: 2rem;">
+    <summary>Current Content Preview</summary>
+    <div class="revision-preview" style="background: var(--surface-color); padding: 1rem; border-radius: 4px; margin-top: 0.5rem;">
+        <h3>{{ page.title }}</h3>
+        <div>{{ page.content | markdown | safe }}</div>
+    </div>
+</details>
+{% endblock %}