williamandClaude Sonnet 5
1289079da5
Fonctionnalité mise de côté depuis le tout début de ce chantier
("jouable en toute autonomie"). Nouveau bouton "📦 Publier" dans la barre
de navigation du jeu (après "▶️ Jouer") : construit un zip contenant un
Python portable + Flask embarqués, une copie figée du moteur de rendu
(screens/db/filters + le strict minimum de core/) et des données du jeu
(game.db + uploads/), lancé en double-cliquant sur run.bat — aucune
installation requise, 100% hors-ligne (voir le commit précédent qui a
auto-hébergé polices/animate.css, dernière dépendance CDN de l'app).
Exploration préalable a confirmé que screens/ et db/ sont déjà
totalement découplés de auth/routes/core (seul lien : un try/except
optionnel dans db/connection.py) et que templates/play.html n'appelle
que 4 endpoints "purs" (aucune logique d'auth mélangée dedans) — ce qui
a permis de réutiliser ces routes quasiment telles quelles dans un
mini-serveur Flask séparé plutôt que de les réécrire.
- db/constants.py : PROJECTS_DIR devient surchargeable via
FORGE_PROJECTS_DIR (même schéma que auth/connection.py) — le serveur
joueur autonome pointe ainsi vers son propre dossier "projects/"
embarqué.
- publish/vendor_runtime.py : télécharge (une fois par poste, mis en
cache sous data/publish_vendor/ — déjà ignoré par git) le ZIP Python
embeddable officiel (python.org) et vendore Flask via pip --target ;
fonctions séparées et mockables pour ne jamais déclencher de vrai
téléchargement dans les tests.
- publish/player_app_template.py : mini-Flask autonome, réutilise
core/flask_app.py et core/jinja_filters.py tels quels (SLUG figé en
dur au moment de la publication, csrf_token() factice puisqu'aucune
session n'existe dans cet export). sys.path doit être complété
manuellement au démarrage : le python311._pth de la distribution
embeddable ne référence que le dossier de python.exe lui-même, jamais
celui du script lancé.
- publish/build_package.py : assemble le zip dans un dossier temporaire
(jamais les vrais fichiers de l'app), copié/nettoyé après envoi de la
réponse HTTP (routes/publish/publish_game.py, déjà protégée par la
garde d'accès existante — aucune vérification supplémentaire).
- templates/base.html : bouton + modale (avancement séquentiel, jamais
de suivi serveur réel — le build est rapide) qui déclenche le
téléchargement du zip via un blob, comme la modale des codes de
récupération déjà en place (posée À L'INTÉRIEUR de <main> pour que
pjax.js la remplace et rejoue son script à chaque navigation).
Vérifié pour de vrai (pas seulement via les tests) : zip construit,
extrait, lancé avec le Python embeddable réel — /, /game/test/play,
/game/test/runtime-payload et /static/style.css répondent tous 200.
tests/test_publish.py (nouveau, vendor mocké) : structure du zip,
SLUG correctement substitué, route protégée par la même isolation par
projet que le reste de l'app. 203 tests au total.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
114 lines
4.7 KiB
Python
114 lines
4.7 KiB
Python
"""Assemble le zip exporté d'un jeu (bouton "Publier", voir
|
|
routes/publish/publish_game.py) : un dossier autonome contenant Python
|
|
portable + Flask (vendorés une fois, voir vendor_runtime.py), une copie
|
|
figée du jeu (screens/db/filters/core minimal + templates/play.html +
|
|
le sous-ensemble utile de static/), sa base SQLite et ses fichiers
|
|
envoyés (uploads/), et les scripts de lancement (player_app.py/run.bat).
|
|
|
|
Ne modifie JAMAIS les fichiers réels de l'app (tout se passe dans un
|
|
dossier de travail temporaire, supprimé après envoi de la réponse) ni la
|
|
vraie base de données du jeu (copiée, jamais déplacée)."""
|
|
import os
|
|
import shutil
|
|
import tempfile
|
|
import zipfile
|
|
|
|
import db
|
|
|
|
from . import vendor_runtime
|
|
|
|
_PUBLISH_DIR = os.path.dirname(os.path.abspath(__file__))
|
|
_BASE_DIR = os.path.dirname(_PUBLISH_DIR)
|
|
|
|
# Sous-ensemble de static/ réellement nécessaire au mode jouable (voir
|
|
# templates/play.html) — jamais les assets propres à l'éditeur seul
|
|
# (icônes de l'interface de l'éditeur mises à part, déjà dans icons/).
|
|
_STATIC_ITEMS = ["style.css", "csrf_fetch.js", "icons", "branding", "vendor/fonts", "vendor/animate.min.css"]
|
|
|
|
_SLUG_PLACEHOLDER = "_SLUG_PLACEHOLDER"
|
|
|
|
|
|
def _copy_engine_sources(staging_dir):
|
|
"""Copie la partie du moteur nécessaire au mode jouable SEUL (jamais
|
|
l'éditeur ni l'authentification — voir le constat d'exploration dans
|
|
le plan : screens/ et db/ sont déjà totalement découplés de auth//
|
|
routes/, core/flask_app.py et core/jinja_filters.py sont les 2 SEULS
|
|
fichiers de core/ dont ils dépendent réellement)."""
|
|
for pkg in ("screens", "db", "filters"):
|
|
shutil.copytree(os.path.join(_BASE_DIR, pkg), os.path.join(staging_dir, pkg),
|
|
ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
|
|
|
|
core_dir = os.path.join(staging_dir, "core")
|
|
os.makedirs(core_dir, exist_ok=True)
|
|
for fname in ("__init__.py", "flask_app.py", "jinja_filters.py"):
|
|
shutil.copy2(os.path.join(_BASE_DIR, "core", fname), os.path.join(core_dir, fname))
|
|
|
|
templates_dir = os.path.join(staging_dir, "templates")
|
|
os.makedirs(templates_dir, exist_ok=True)
|
|
shutil.copy2(os.path.join(_BASE_DIR, "templates", "play.html"), os.path.join(templates_dir, "play.html"))
|
|
|
|
static_dir = os.path.join(staging_dir, "static")
|
|
for item in _STATIC_ITEMS:
|
|
src = os.path.join(_BASE_DIR, "static", item)
|
|
dst = os.path.join(static_dir, item)
|
|
os.makedirs(os.path.dirname(dst), exist_ok=True)
|
|
if os.path.isdir(src):
|
|
shutil.copytree(src, dst)
|
|
else:
|
|
shutil.copy2(src, dst)
|
|
|
|
|
|
def _copy_game_data(staging_dir, slug):
|
|
"""Copie le dossier RÉEL du jeu (game.db + uploads/, voir
|
|
db.game_dir) tel quel — jamais déplacé, jamais modifié."""
|
|
src = db.game_dir(slug)
|
|
dst = os.path.join(staging_dir, "projects", slug)
|
|
shutil.copytree(src, dst, ignore=shutil.ignore_patterns("index.html", "index.css", "index.js"))
|
|
|
|
|
|
def _write_player_app(staging_dir, slug):
|
|
template_path = os.path.join(_PUBLISH_DIR, "player_app_template.py")
|
|
with open(template_path, encoding="utf-8") as f:
|
|
content = f.read()
|
|
content = content.replace(_SLUG_PLACEHOLDER, slug)
|
|
with open(os.path.join(staging_dir, "player_app.py"), "w", encoding="utf-8") as f:
|
|
f.write(content)
|
|
|
|
|
|
def _write_run_bat(staging_dir):
|
|
src = os.path.join(_PUBLISH_DIR, "run_bat_template.bat")
|
|
shutil.copy2(src, os.path.join(staging_dir, "run.bat"))
|
|
|
|
|
|
def _zip_dir(staging_dir, zip_path):
|
|
with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
|
|
for root, _dirs, files in os.walk(staging_dir):
|
|
for name in files:
|
|
full = os.path.join(root, name)
|
|
rel = os.path.relpath(full, staging_dir)
|
|
zf.write(full, rel)
|
|
|
|
|
|
def build_game_zip(slug):
|
|
"""Construit le zip et renvoie son chemin (dans un dossier temporaire
|
|
— à l'appelant de le supprimer une fois la réponse HTTP envoyée, voir
|
|
routes/publish/publish_game.py)."""
|
|
game = db.game_meta(slug)
|
|
python_dir, pylibs_dir = vendor_runtime.ensure_vendor_ready()
|
|
|
|
staging_dir = tempfile.mkdtemp(prefix="forge_publish_")
|
|
try:
|
|
shutil.copytree(python_dir, os.path.join(staging_dir, "python-embed"))
|
|
shutil.copytree(pylibs_dir, os.path.join(staging_dir, "python-embed", "pylibs"))
|
|
_copy_engine_sources(staging_dir)
|
|
_copy_game_data(staging_dir, slug)
|
|
_write_player_app(staging_dir, slug)
|
|
_write_run_bat(staging_dir)
|
|
|
|
zip_fd, zip_path = tempfile.mkstemp(prefix="forge_publish_", suffix=".zip")
|
|
os.close(zip_fd)
|
|
_zip_dir(staging_dir, zip_path)
|
|
finally:
|
|
shutil.rmtree(staging_dir, ignore_errors=True)
|
|
return zip_path, game["name"]
|