Enhance app functionality with dynamic stylesheet registration and improved error handling

Author: apiad

examples/hello_world_app.py

@@ -0,0 +1,17 @@
+# main.py
+from violetear import App
+from violetear.markup import Document, Element
+
+app = App()
+
+@app.route("/")
+def index():
+    doc = Document(title="Hello Violetear")
+    doc.body.extend(
+        Element("h1", text="Hello World!"),
+        Element("p", text="Served via Violetear App Engine."),
+    )
+    return doc
+
+if __name__ == "__main__":
+    app.run()

violetear/app.py

@@ -1,19 +1,26 @@
 import os
-from typing import Any, Callable, Dict, Optional, List
+import inspect
+from typing import Any, Callable, Dict, List, Union
+
 
 # --- Optional Server Dependencies ---
 try:
-    from fastapi import FastAPI, APIRouter, Request
-    from fastapi.responses import HTMLResponse, Response
+    from fastapi import FastAPI, APIRouter, Request, Response
+    from fastapi.responses import HTMLResponse
     from fastapi.staticfiles import StaticFiles
-
+    import uvicorn
     HAS_SERVER = True
 except ImportError:
     HAS_SERVER = False
-    # Dummy classes for type hinting if dependencies are missing
-    # FastAPI = object  # type: ignore
-    # APIRouter = object  # type: ignore
-    # Request = object  # type: ignore
+    # Dummy classes for type hinting
+    FastAPI = object  # type: ignore
+    APIRouter = object  # type: ignore
+    Request = object  # type: ignore
+    Response = object # type: ignore
+
+
+from .stylesheet import StyleSheet
+from .markup import Document, StyleResource
 
 
 class App:
@@ -26,27 +33,78 @@ def __init__(self, title: str = "Violetear App"):
         if not HAS_SERVER:
             raise ImportError(
                 "Violetear Server dependencies are missing. "
-                "Please install them using `pip install violetear[server]`"
+                "Please install them with: uv add --extra server 'fastapi[standard]'"
             )
 
         self.title = title
         self.api = FastAPI(title=title)
-        self._routes: List[Dict[str, Any]] = []
 
-        # We will add the Asset Registry here in Phase 2.2
-        self.styles = {}
+        # Registry of served styles to prevent duplicate route registration
+        self.served_styles: Dict[str, StyleSheet] = {}
+
+    def add_style(self, path: str, sheet: StyleSheet):
+        """
+        Registers a stylesheet to be served by the app at a specific path.
+
+        Overrides any previous stylesheet at that path.
+        """
+        if path not in self.served_styles:
+            # Register the route dynamically (just once)
+            @self.api.get(path)
+            def serve_css():
+                # Render the full CSS content
+                css_content = self.served_styles[path]
+                return Response(content=css_content, media_type="text/css")
+
+        # Set the stylesheet, overrides if existing
+        # This means we can change stylesheets dynamically
+        self.served_styles[path] = sheet
+
+    def _register_document_styles(self, doc: Document):
+        """
+        Scans a Document for external stylesheets defined in Python
+        and registers their routes on the fly.
+        """
+        for resource in doc.head.styles:
+            if isinstance(resource, StyleResource):
+                # If it has a sheet object AND a URL, it needs to be served
+                if resource.sheet and resource.href and not resource.inline:
+                    self.add_style(resource.href, resource.sheet)
 
     def route(self, path: str, methods: List[str] = ["GET"]):
         """
         Decorator to register a route.
-        Supports standard SSR (returning Documents) out of the box.
         """
-
         def decorator(func: Callable):
-            # We will implement the wrapper logic in Phase 2.2
-            self.api.add_api_route(path, func, methods=methods)
-            return func
+            @self.api.api_route(path, methods=methods)
+            async def wrapper(request: Request):
+                # 1. Handle Request (POST/GET)
+                if request.method == "POST":
+                    form_data = await request.form()
+                    # Simple check if function accepts arguments
+                    if inspect.signature(func).parameters:
+                        response = func(form_data)
+                    else:
+                        response = func()
+                else:
+                    response = func()
+
+                # Await if async
+                if inspect.isawaitable(response):
+                    response = await response
 
+                # 2. Handle Document Rendering
+                if isinstance(response, Document):
+                    # JIT: Check if this doc uses any new stylesheets we need to serve
+                    self._register_document_styles(response)
+
+                    # Render the HTML (which will contain <link href="..."> tags)
+                    return HTMLResponse(response.render())
+
+                # 3. Return raw response (JSON, Dict, etc.)
+                return response
+
+            return wrapper
         return decorator
 
     def mount_static(self, directory: str, path: str = "/static"):
@@ -56,6 +114,4 @@ def mount_static(self, directory: str, path: str = "/static"):
 
     def run(self, host="0.0.0.0", port=8000, **kwargs):
         """Helper to run via uvicorn programmatically."""
-        import uvicorn
-
         uvicorn.run(self.api, host=host, port=port, **kwargs)

violetear/markup.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import abc
+from dataclasses import dataclass
 import io
 from pathlib import Path
 from typing import (
@@ -231,23 +232,39 @@ def root(self) -> Element:
         return self._parent.root()
 
 
+@dataclass
+class StyleResource:
+    """
+    Represents a CSS resource attached to a document.
+    """
+    sheet: StyleSheet | None = None
+    href: str | None = None
+    inline: bool = False
+
+
 class Document(Markup):
     def __init__(self, lang: str = "en", **head_kwargs) -> None:
         self.lang = lang
         self.head = Head(**head_kwargs)
         self.body = Body()
-        self.styles = []
 
     def style(
-        self, sheet: StyleSheet, inline: bool = False, href: str = None
+        self, sheet: StyleSheet | None = None, inline: bool = False, href: str | None = None
     ) -> Document:
+        if sheet is None and href is None:
+            raise ValueError("Need either a sheet or an external href")
+
         if not inline and href is None:
-            raise ValueError("Need an href when inline is false")
+            raise ValueError("Need an href when inline is False")
 
-        if inline:
-            self.styles.append(sheet)
-        else:
-            self.head.styles.append(href)
+        if inline and sheet is None:
+            raise ValueError("Need a sheet when inline is True")
+
+        self.head.styles.append(StyleResource(
+            sheet=sheet,
+            href=href,
+            inline=inline,
+        ))
 
         return self
 
@@ -263,7 +280,7 @@ class Head(Markup):
     def __init__(self, charset: str = "UTF-8", title: str = "") -> None:
         self.charset = charset
         self.title = title
-        self.styles = []
+        self.styles: list[StyleResource] = []
 
     def _render(self, fp, indent: int):
         self._write_line(fp, "<head>", indent)
@@ -278,8 +295,16 @@ def _render(self, fp, indent: int):
         )
         self._write_line(fp, f"<title>{self.title}</title>", indent + 1)
 
-        for href in self.styles:
-            self._write_line(fp, f'<link rel="stylesheet" href="{href}">', indent + 1)
+        for resource in self.styles:
+            if resource.inline and resource.sheet:
+                # Render Inline
+                self._write_line(fp, '<style>', indent + 1)
+                resource.sheet.render(fp)
+                self._write_line(fp, '</style>', indent + 1)
+
+            elif resource.href:
+                # Render Link
+                self._write_line(fp, f'<link rel="stylesheet" href="{resource.href}">', indent + 1)
 
         self._write_line(fp, "</head>", indent)