215 lines
9.7 KiB
Python
215 lines
9.7 KiB
Python
#!/usr/bin/env python3
|
|
"""OneBSpace (OneCAD) — build the SolidCraft wasm bundle into the one_cad Odoo addon.
|
|
|
|
Stdlib-only build chain (python3 scripts/build_onecad_addon.py [--dry-run]):
|
|
|
|
1. optional clean: ODA_CLEAN=1 wipes the dist target before building
|
|
2. build: prefer trunk (apps/solidcraft-web/Trunk.toml); fallback is
|
|
onepixel's tools/cargo-run chain verbatim:
|
|
cargo build --release --target wasm32-unknown-unknown -p solidcraft-web
|
|
wasm-bindgen --target web --out-dir <dist> --out-name onecad <wasm>
|
|
wasm-opt -Oz (when on PATH)
|
|
plus index.html + static assets copied into <dist>
|
|
3. rebrand: <title>OneCAD</title> + data-app-name="OneCAD" in index.html;
|
|
drop sw.js / manifest.webmanifest / build.json / icon files
|
|
4. verify gate: FAIL on absolute /(assets|fonts|blobs)/ references in any text
|
|
file of the dist; require index.html, a *_bg.wasm and a
|
|
wasm-bindgen glue .js — exits non-zero on failure
|
|
5. mirror-copy: dist -> /home/z/my-project/one-os-dev/core-components/one_cad/static/onecad/
|
|
(rsync-like: stale files in the destination are removed)
|
|
6. reminder: bump bundleVersion (static/src/one_cad_app.js) + addon manifest version
|
|
|
|
Exit codes: 0 ok, 1 gate failure, 2 build environment problem.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import os
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
REPO = Path(__file__).resolve().parents[1]
|
|
APP = REPO / "apps" / "solidcraft-web"
|
|
DIST = REPO / "dist" / "web"
|
|
DEST = Path("/home/z/my-project/one-os-dev/core-components/one_cad/static/onecad")
|
|
WASM_TARGET = "wasm32-unknown-unknown"
|
|
WASM_ARTIFACT = REPO / "target" / WASM_TARGET / "release" / "solidcraft_web.wasm"
|
|
OUT_NAME = "onecad"
|
|
|
|
TEXT_SUFFIXES = {".html", ".js", ".mjs", ".css", ".json", ".svg", ".txt", ".webmanifest", ".map"}
|
|
ABS_REF = re.compile(r"""["'=(]/(?:assets|fonts|blobs)/""")
|
|
ICON_FILE = re.compile(r"^(icon|apple-touch-icon|favicon).*", re.I)
|
|
DROP_FILES = {"sw.js", "manifest.webmanifest", "site.webmanifest", "build.json"}
|
|
|
|
|
|
def log(message: str) -> None:
|
|
print(f"[onecad] {message}")
|
|
|
|
|
|
def sh(cmd: list[str], cwd: Path | None = None) -> None:
|
|
log("$ " + " ".join(cmd) + (f" (cwd={cwd})" if cwd else ""))
|
|
try:
|
|
subprocess.run([str(c) for c in cmd], cwd=str(cwd) if cwd else None, check=True)
|
|
except FileNotFoundError as exc:
|
|
sys.exit(f"[onecad] tool not found: {exc.filename}")
|
|
except subprocess.CalledProcessError as exc:
|
|
sys.exit(f"[onecad] command failed with exit code {exc.returncode}: {' '.join(str(c) for c in cmd)}")
|
|
|
|
|
|
def clean_dist() -> None:
|
|
if DIST.exists():
|
|
log(f"ODA_CLEAN=1: wiping {DIST}")
|
|
shutil.rmtree(DIST, ignore_errors=True)
|
|
|
|
|
|
def build() -> Path:
|
|
"""Build the wasm bundle; return the dist directory that holds index.html."""
|
|
if shutil.which("trunk"):
|
|
sh(["trunk", "build", "--release", "--public-url", "./"], cwd=APP)
|
|
else:
|
|
log("trunk not on PATH — using the cargo + wasm-bindgen chain (onepixel convention)")
|
|
sh(["cargo", "build", "--release", "--target", WASM_TARGET, "-p", "solidcraft-web"], cwd=REPO)
|
|
if not WASM_ARTIFACT.exists():
|
|
sys.exit(f"[onecad] expected wasm artifact missing: {WASM_ARTIFACT}")
|
|
DIST.mkdir(parents=True, exist_ok=True)
|
|
sh(["wasm-bindgen", "--target", "web", "--out-dir", DIST, "--out-name", OUT_NAME, WASM_ARTIFACT])
|
|
if shutil.which("wasm-opt"):
|
|
optimized = DIST / f"{OUT_NAME}_bg.wasm.opt"
|
|
sh(["wasm-opt", "-Oz", DIST / f"{OUT_NAME}_bg.wasm", "-o", optimized])
|
|
os.replace(optimized, DIST / f"{OUT_NAME}_bg.wasm")
|
|
else:
|
|
log("wasm-opt not on PATH — skipping -Oz (larger bundle, still correct)")
|
|
# Static assets trunk would have copied: index.html + the assets tree.
|
|
if (APP / "index.html").exists():
|
|
shutil.copy2(APP / "index.html", DIST / "index.html")
|
|
if (APP / "assets").is_dir():
|
|
shutil.copytree(APP / "assets", DIST / "assets", dirs_exist_ok=True)
|
|
for candidate in (DIST, APP / "dist"):
|
|
if (candidate / "index.html").is_file():
|
|
return candidate
|
|
sys.exit("[onecad] build produced no index.html in dist/web or apps/solidcraft-web/dist")
|
|
|
|
|
|
def rebrand(dist: Path) -> None:
|
|
index = dist / "index.html"
|
|
html = index.read_text(encoding="utf-8")
|
|
html, n_title = re.subn(r"<title\b[^>]*>.*?</title>", "<title>OneCAD</title>", html, flags=re.S | re.I)
|
|
if 'data-app-name="' in html:
|
|
html = re.sub(r'data-app-name="[^"]*"', 'data-app-name="OneCAD"', html)
|
|
else:
|
|
html = re.sub(r"<html\b", '<html data-app-name="OneCAD"', html, count=1)
|
|
# Service worker, PWA manifest and icon links have no meaning inside the
|
|
# Odoo iframe — drop the tags along with the files.
|
|
html = re.sub(r"<link[^>]+rel=[\"']manifest[\"'][^>]*>\s*", "", html, flags=re.I)
|
|
html = re.sub(r"<link[^>]+rel=[\"'][^\"']*(icon|apple-touch)[^\"']*[\"'][^>]*>\s*", "", html, flags=re.I)
|
|
index.write_text(html, encoding="utf-8")
|
|
log(f"rebranded {index} (title replacements: {n_title})")
|
|
dropped = 0
|
|
for path in sorted(dist.rglob("*")):
|
|
if not path.is_file():
|
|
continue
|
|
if path.name in DROP_FILES or ICON_FILE.match(path.name):
|
|
path.unlink()
|
|
dropped += 1
|
|
log(f"dropped {dropped} sw/manifest/icon files from the bundle")
|
|
|
|
|
|
def verify(dist: Path) -> list[str]:
|
|
"""The gate: absolute /(assets|fonts|blobs)/ refs fail; glue + wasm must exist."""
|
|
errors: list[str] = []
|
|
if not (dist / "index.html").is_file():
|
|
errors.append("missing index.html")
|
|
wasm_files = [p for p in dist.rglob("*.wasm")]
|
|
if not any(p.name.endswith("_bg.wasm") for p in wasm_files):
|
|
errors.append("no *_bg.wasm (wasm-bindgen output) in dist")
|
|
glue = [
|
|
p
|
|
for p in dist.rglob("*.js")
|
|
if "wasm_bindgen" in p.read_text(encoding="utf-8", errors="ignore")
|
|
or "wasm-bindgen" in p.read_text(encoding="utf-8", errors="ignore")
|
|
]
|
|
if not glue:
|
|
errors.append("no wasm-bindgen glue .js in dist")
|
|
offenders: list[str] = []
|
|
for path in sorted(dist.rglob("*")):
|
|
if not path.is_file() or path.suffix.lower() not in TEXT_SUFFIXES:
|
|
continue
|
|
text = path.read_text(encoding="utf-8", errors="ignore")
|
|
if ABS_REF.search(text):
|
|
offenders.append(str(path.relative_to(dist)))
|
|
if offenders:
|
|
errors.append(
|
|
"absolute /(assets|fonts|blobs)/ references (must be relative — the bundle is served "
|
|
f"from /one_cad/static/onecad/): {', '.join(offenders[:10])}"
|
|
+ (f" … (+{len(offenders) - 10} more)" if len(offenders) > 10 else "")
|
|
)
|
|
if errors:
|
|
for error in errors:
|
|
log(f"GATE FAIL: {error}")
|
|
else:
|
|
log(f"GATE PASS: {len(wasm_files)} wasm, {len(glue)} glue js, all references relative")
|
|
return errors
|
|
|
|
|
|
def mirror(src: Path, dst: Path) -> None:
|
|
"""rsync-like: make dst exactly src (extra files in dst are removed)."""
|
|
src_files = {p.relative_to(src) for p in src.rglob("*") if p.is_file()}
|
|
src_dirs = {p.relative_to(src) for p in src.rglob("*") if p.is_dir()}
|
|
dst.mkdir(parents=True, exist_ok=True)
|
|
removed = 0
|
|
for path in sorted(dst.rglob("*"), key=lambda p: len(p.parts), reverse=True):
|
|
rel = path.relative_to(dst)
|
|
if path.is_dir() and rel not in src_dirs:
|
|
shutil.rmtree(path)
|
|
removed += 1
|
|
elif path.is_file() and rel not in src_files:
|
|
path.unlink()
|
|
removed += 1
|
|
for rel in sorted(src_dirs):
|
|
(dst / rel).mkdir(parents=True, exist_ok=True)
|
|
for rel in sorted(src_files):
|
|
shutil.copy2(src / rel, dst / rel)
|
|
log(f"mirrored {len(src_files)} files -> {dst} ({removed} stale entries removed)")
|
|
|
|
|
|
def main() -> int:
|
|
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
parser.add_argument("--dry-run", action="store_true", help="print the plan, no builds/writes; gates run read-only against an existing dist")
|
|
args = parser.parse_args()
|
|
|
|
tools = {name: bool(shutil.which(name)) for name in ("trunk", "cargo", "wasm-bindgen", "wasm-opt")}
|
|
tool_report = ", ".join(f"{name}={'yes' if present else 'no'}" for name, present in tools.items())
|
|
log(f"tools: {tool_report}")
|
|
if not args.dry_run and not (tools["trunk"] or (tools["cargo"] and tools["wasm-bindgen"])):
|
|
log("need trunk, or cargo + wasm-bindgen, on PATH")
|
|
return 2
|
|
|
|
if args.dry_run:
|
|
log(f"DRY RUN: clean={'yes' if os.environ.get('ODA_CLEAN') == '1' else 'no'} -> build ({'trunk' if tools['trunk'] else 'cargo chain'}) -> {DIST} -> rebrand -> gate -> mirror {DEST}")
|
|
if (DIST / "index.html").is_file():
|
|
log("an existing dist was found; running the verification gate read-only")
|
|
return 1 if verify(DIST) else 0
|
|
log("no dist yet — plan only")
|
|
return 0
|
|
|
|
if os.environ.get("ODA_CLEAN") == "1":
|
|
clean_dist()
|
|
dist = build()
|
|
rebrand(dist)
|
|
if verify(dist):
|
|
return 1
|
|
mirror(dist, DEST)
|
|
log("NEXT STEPS:")
|
|
log(" 1. bump bundleVersion in one-os-dev/core-components/one_cad/static/src/one_cad_app.js (cache-busts the iframe bundle)")
|
|
log(" 2. bump the version in one-os-dev/core-components/one_cad/__manifest__.py to match the addon release")
|
|
log(" 3. upgrade the module (odoo -u one_cad) so the new static bundle is served")
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|