refactored server code as sub package

Author: JasperVanDenBosch

syrinx/cli.py

@@ -57,7 +57,7 @@ def main():
     config = configure(args)
 
     if args.command == 'serve':
-        from syrinx.dev_server import DevServer
+        from syrinx.server.dev_server import DevServer
         server = DevServer(root_dir, port=args.port)
         server.start()
         return

syrinx/dev_server.py

@@ -0,0 +1,5 @@
+"""Syrinx development server package.
+
+This subpackage provides development server functionality including
+file watching, live reload, and HTTP serving for Syrinx projects.
+"""

syrinx/server/__init__.py

@@ -0,0 +1,85 @@
+"""Development server module for Syrinx with file watching and live reload.
+
+This module provides a development server that watches for file changes in the
+parent directory hierarchy and automatically rebuilds the site when changes are
+detected. It includes an HTTP server to serve the built files.
+"""
+
+import os
+from socketserver import TCPServer
+from watchdog.observers import Observer
+from syrinx.build import build
+from syrinx.read import read
+from syrinx.preprocess import preprocess
+from syrinx.server.hot_reload_handler import HotReloadHandler
+from syrinx.server.rebuild_handler import RebuildHandler
+
+
+class DevServer:
+    """Development server with file watching and HTTP serving.
+    
+    Provides a complete development environment for Syrinx projects by:
+    - Watching parent directories for file changes
+    - Automatically rebuilding on changes
+    - Serving the built files via HTTP
+    
+    Attributes:
+        root_dir: The absolute path to the Syrinx project root.
+        port: The port number for the HTTP server.
+        reload_version: Version counter for triggering reloads.
+    """
+    def __init__(self, root_dir, port=8000):
+        self.root_dir = os.path.abspath(root_dir)
+        self.port = port
+        self.reload_version = 0
+        
+    def trigger_reload(self):
+        """Increment reload version to trigger browser reloads."""
+        self.reload_version += 1
+        
+    def start(self):
+        """Start the development server.
+        
+        Performs an initial build, sets up file watching on the parent
+        directory, and starts an HTTP server to serve the dist directory.
+        The server runs until interrupted with Ctrl+C.
+        """
+        # Determine parent directory to watch
+        watch_dir = os.path.dirname(self.root_dir)
+        print(f"[DEV] Watching for changes in: {watch_dir}")
+        print(f"[DEV] Building from: {self.root_dir}")
+        
+        # Initial build
+        print("[DEV] Initial build...")
+        preprocess(self.root_dir, clean=False)
+        root = read(self.root_dir)
+        build(root, self.root_dir)
+        print("[DEV] Initial build complete!")
+        
+        # Setup file watcher with reload callback
+        event_handler = RebuildHandler(self.root_dir, watch_dir, self.trigger_reload)
+        observer = Observer()
+        observer.schedule(event_handler, watch_dir, recursive=True)
+        observer.start()
+        
+        # Setup HTTP server
+        dist_dir = os.path.join(self.root_dir, 'dist')
+        
+        # Store original directory to restore later
+        original_dir = os.getcwd()
+        
+        # Configure the handler class attributes
+        HotReloadHandler.dev_server = self
+        HotReloadHandler.dist_dir = dist_dir
+        
+        try:
+            with TCPServer(("", self.port), HotReloadHandler) as httpd:
+                print(f"\n[DEV] Server running at http://localhost:{self.port}")
+                print("[DEV] Press Ctrl+C to stop\n")
+                httpd.serve_forever()
+        except KeyboardInterrupt:
+            print("\n[DEV] Shutting down...")
+            observer.stop()
+        finally:
+            observer.join()
+            os.chdir(original_dir)

syrinx/server/dev_server.py

@@ -0,0 +1,71 @@
+"""HTTP handler for development server with live reload functionality."""
+
+import os
+import json
+from http.server import SimpleHTTPRequestHandler
+
+
+class HotReloadHandler(SimpleHTTPRequestHandler):
+    """Custom HTTP handler that injects live reload script into HTML pages.
+    
+    This handler serves files from a specified directory and automatically
+    injects a live reload script into HTML pages to enable automatic page
+    refreshes during development.
+    
+    Attributes:
+        dev_server: Reference to the DevServer instance for reload version.
+        dist_dir: Directory to serve files from.
+    """
+    
+    dev_server: 'DevServer' = None  # type: ignore
+    dist_dir: str = None  # type: ignore
+    reload_script_content: str = None  # type: ignore
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, directory=self.dist_dir, **kwargs)
+        
+        # Read reload script once during initialization
+        if self.reload_script_content is None:
+            reload_js_path = os.path.join(os.path.dirname(__file__), 'reload_outdated.js')
+            with open(reload_js_path, 'r', encoding='utf-8') as f:
+                HotReloadHandler.reload_script_content = f.read()
+        
+    def do_GET(self):
+        """Handle GET requests with reload script injection for HTML files."""
+        # Handle reload check endpoint
+        if self.path == '/__dev_reload_check__':
+            self.send_response(200)
+            self.send_header('Content-Type', 'application/json')
+            self.send_header('Cache-Control', 'no-cache')
+            self.end_headers()
+            self.wfile.write(json.dumps({'version': self.dev_server.reload_version}).encode())
+            return
+            
+        # For HTML files, inject reload script
+        if self.path.endswith('.html') or self.path == '/':
+            file_path = os.path.join(self.dist_dir, self.path.lstrip('/'))
+            if self.path == '/':
+                file_path = os.path.join(self.dist_dir, 'index.html')
+                
+            if os.path.exists(file_path):
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                
+                # Use cached reload script and replace version placeholder
+                reload_script_content = self.reload_script_content.replace(
+                    '__CURRENT_VERSION__', 
+                    str(self.dev_server.reload_version)
+                )
+                
+                reload_script = f'<script>\n{reload_script_content}\n</script>\n</body>'
+                content = content.replace('</body>', reload_script)
+                
+                self.send_response(200)
+                self.send_header('Content-Type', 'text/html')
+                self.send_header('Content-Length', str(len(content.encode())))
+                self.end_headers()
+                self.wfile.write(content.encode())
+                return
+        
+        # Default behavior for other files
+        super().do_GET()