feat: Version aus einer Quelle (set_version.sh)

Bisher waren beim Release sechs Stellen von Hand zu ändern; vergisst man
eine, fällt es erst im Build oder beim Update-Dialog auf.

- `tools/set_version.sh <x.y.z>` schreibt alle Ableitungen aus
  `project.godot` config/version: Windows `x.y.z.0`, macOS/Android `x.y.z`,
  Android `version/code = major*10000+minor*100+patch`, NSIS-Fallbacks.
- `--check` prüft nur und schlägt bei Abweichung fehl; läuft jetzt in
  `./tools/test.sh` als erster Schritt.
- `version/code` ist damit abgeleitet (0.4.0 -> 400) statt handgezählt.
- Neu: `docs/deployment.md` beschreibt für Menschen die Regeln und den
  Ablauf über alle drei Build-Rechner (Version, Build, Upload, Endpunkt,
  Website, Nachkontrolle, häufige Fehler).
- `docs/updates.md` verweist für Version und Checkliste dorthin, statt die
  Stellen doppelt zu führen.
This commit is contained in:
torsten 2026-11-13 16:28:25 +01:00
parent 4f9bffb0e4
commit b189edfa00
5 changed files with 266 additions and 28 deletions

132
docs/deployment.md Normal file
View file

@ -0,0 +1,132 @@
# Deployment-Leitfaden
Stand: 2026-11-13. Diese Seite beschreibt, wie aus dem Repo eine
veröffentlichte Version wird: welche Zahl woher kommt, wer was baut, wohin es
geht und was danach auf der Website passiert.
Die Details der einzelnen Teile stehen in `docs/builds.md` (Builds),
`docs/updates.md` (Update-Endpunkt) und `docs/website.md` (Seite). Hier steht,
wie sie zusammenhängen.
## Die eine Quelle
> **`rinkplanner/project.godot` → `config/version` ist die einzige Wahrheit.**
Alles andere wird daraus abgeleitet. Die Laufzeit liest sie
(`UpdateInfo.current_version()`), `publish_version.sh` liest sie, und
`tools/set_version.sh` schreibt die Ableitungen.
| Stelle | Ableitung | Warum |
| :--- | :--- | :--- |
| `project.godot` → `config/version` | `x.y.z` | Quelle |
| Presets → `application/file_version`, `product_version` | `x.y.z.0` | Windows will vier Segmente |
| Presets → `application/short_version`, `application/version` | `x.y.z` | macOS |
| Presets → `version/name` | `x.y.z` | Android-Anzeige |
| Presets → `version/code` | `major×10000 + minor×100 + patch` | Android vergleicht nur „größer“ |
| `windows_installer.nsi` → `APP_VERSION` | `x.y.z.0` | Fallback, falls das Preset fehlt |
| `export_windows_installer.sh` → `VERSION`-Default | `x.y.z.0` | dito |
Beispiel: `0.4.0` → Windows `0.4.0.0`, Android-Code `400`; `0.4.1` → `401`;
`1.0.0` → `10000`.
## Version setzen und prüfen
```bash
./tools/set_version.sh 0.4.1 # schreibt alle Stellen
./tools/set_version.sh --check # prüft nur, Exit 1 bei Abweichung
```
`--check` läuft in `./tools/test.sh`. Wer die Version an einer Stelle von Hand
ändert und die anderen vergisst, bekommt also eine rote Suite statt eines
stillen Fehlers im Build.
## Der Ablauf eines Releases
Die Builds entstehen auf drei Rechnern: Linux (Windows, Android), Mac (macOS),
Tablet (Abnahme). Ein Skript für alles wäre eine Illusion — die Reihenfolge ist
deshalb bewusst zweistufig.
### 1. Vorbereiten
```bash
./tools/set_version.sh 0.5.0
./tools/test.sh # enthält set_version --check und check_rules.sh
```
### 2. Android (nur Testgerät, nicht im Endpunkt)
```bash
./tools/export_android.sh debug --install
```
Prüfen: `./tools/verify_apk.sh` (Paketname, Version, ABI, Landscape, Signatur).
Ein verteilbares APK braucht einen Release-Keystore — offen (Roadmap).
### 3. Windows (auf Linux)
```bash
./tools/export_windows_installer.sh
# hochladen nach <FTP_DIRECTORY>/download/rinkplanner-setup.exe
./tools/publish_version.sh --windows --notes "…"
```
Nur der Installer wird verteilt, nicht die `rinkplanner.exe` davor.
### 4. macOS (auf dem Mac)
```bash
./tools/export_macos_installer.sh
# DMG hochladen nach <FTP_DIRECTORY>/download/rinkplanner-setup.dmg
./tools/publish_version.sh --notes "…"
```
`publish_version.sh` übernimmt den Eintrag der jeweils anderen Plattform aus
dem Live-Endpunkt, **sofern die Version dort schon dieselbe ist**. Wer zuerst
veröffentlicht, hat also nur seine Plattform drin — das ist normal und wird
mit dem zweiten Lauf ergänzt.
### 5. Endpunkt prüfen
```bash
./tools/publish_version.sh --check
```
Erwartet: beide Plattformen, Prüfsummen, `notes`, `released` = heute. Ein
Gegencheck aus der App: `godot --headless --path rinkplanner --script
res://tests/manual/check_update.gd`.
### 6. Website
In `web/i18n.php` einen Block `release.N.*` **oben** einfügen (beide Sprachen),
die Zähler der bestehenden Blöcke nach unten schieben und das Badge
„Aktuell“/„Current“ mitnehmen. Datum in `hero.meta` und `downloads.lede`
nachziehen, Dateigrößen in `web/template.php` prüfen (stehen dort als Text).
```bash
./tools/deploy_web.sh --all
```
### 7. Nachkontrolle
- `https://rinkplanner.programmschmiede.de/version.json` zeigt beide
Plattformen (Browser, ohne Cache).
- Beide Download-URLs antworten mit `200` und der erwarteten
`Content-Length`.
- `deploy_web.sh --all` meldet „Alle Prüfungen bestanden“.
## Was bewusst Handarbeit bleibt
- **Die Stichpunkte im Website-Block und `notes` im Endpunkt.** Version und
Datum ließen sich erzeugen, die Aussage „was ist wirklich neu“ nicht.
- **Der Zeitpunkt der macOS-Veröffentlichung.** Sie hängt am Mac, nicht am
Repo.
## Häufige Fehler
| Symptom | Ursache |
| :--- | :--- |
| `set_version.sh --check` schlägt fehl | eine Stelle von Hand geändert — Skript laufen lassen |
| Update-Dialog nennt alte Neuerungen | `notes` beim zweiten `publish_version.sh` vergessen |
| Mac bekommt keinen Hinweis | 0.5.0 veröffentlicht, DMG fehlt im Endpunkt (`downloads.macos`) |
| „Prüfsumme stimmt nicht“ | Endpunkt und hochgeladener Installer passen nicht zusammen |
| Android installiert nicht | `version/code` nicht größer als die installierte Fassung |

View file

@ -22,22 +22,14 @@ der Rinkplanner-Subdomain. Es gibt keinen PHP-Dienst und keine Datenbank.
## Versionsquelle
Die Laufzeitversion steht in `rinkplanner/project.godot`:
Die Laufzeitversion steht in `rinkplanner/project.godot`
(`config/version="0.4.0"`) und ist die **einzige** Quelle. Alle Ableitungen —
Export-Presets für Windows, macOS und Android, Android-`version/code` sowie die
NSIS-Fallbacks — schreibt `./tools/set_version.sh <x.y.z>`;
`--check` prüft sie und läuft in `./tools/test.sh`.
```ini
config/version="0.2.2"
```
Beim Versionssprung **alle** Stellen anpassen:
1. `rinkplanner/project.godot`: `config/version`
2. `rinkplanner/export_presets.cfg`:
- Windows: `application/file_version` und `application/product_version`
(viersegmentig, z. B. `0.2.2.0`)
- macOS: `application/short_version` und `application/version`
- Android: `version/name`, außerdem `version/code` erhöhen
3. `tools/windows_installer.nsi` und `tools/export_windows_installer.sh`:
nur Fallback-Werte, falls das Preset nicht gelesen werden kann
Die Ableitungstabelle und der vollständige Release-Ablauf stehen in
`docs/deployment.md`.
`UpdateInfo.current_version()` liest `application/config/version` zur Laufzeit.
Die Tests prüfen, dass der Wert gesetzt und numerisch ist, aber nicht eine
@ -251,15 +243,13 @@ ist zweisprachig (`/de/`, `/en/`), Quelle im Repo unter `web/` (siehe
## Checkliste für das nächste Release
1. Version an allen Stellen erhöhen (siehe oben).
2. `./tools/sync_assets.sh --check` (Assets vorhanden?).
3. `./tools/test.sh`.
4. Installer bauen (`export_macos_installer.sh`, ggf.
`export_windows_installer.sh`).
5. Installer nach `programmschmiede.de/rinkplanner/download/` hochladen.
6. `./tools/publish_version.sh --notes "…"` (und `--windows`, falls gebaut).
Neu aufgenommen werden nur lokal gebaute Installer; Einträge anderer
Plattformen übernimmt das Skript bei gleicher Version aus dem Live-Endpunkt.
7. „Was ist neu“ auf der Website ergänzen (siehe unten).
8. `./tools/publish_version.sh --check` und
`tests/manual/check_update.gd` gegen den Live-Endpunkt laufen lassen.
Die vollständige Reihenfolge (Version, Builds je Plattform, Upload, Endpunkt,
Website, Nachkontrolle) steht in `docs/deployment.md`. Kurzfassung:
1. `./tools/set_version.sh <x.y.z>`
2. `./tools/test.sh` (enthält die Versionsprüfung und `check_rules.sh`)
3. Installer bauen und hochladen: Windows auf Linux, DMG auf dem Mac
4. `./tools/publish_version.sh [--windows] --notes "…"` je Plattform
5. Website-Block ergänzen, `./tools/deploy_web.sh --all`
6. `./tools/publish_version.sh --check` und
`tests/manual/check_update.gd` gegen den Live-Endpunkt

View file

@ -243,7 +243,7 @@ keystore/debug_password=""
keystore/release=""
keystore/release_user=""
keystore/release_password=""
version/code=6
version/code=400
version/name="0.4.0"
package/unique_name="de.rinkplanner.app"
package/name="Rinkplanner"

113
tools/set_version.sh Executable file
View file

@ -0,0 +1,113 @@
#!/usr/bin/env bash
# Hält alle Versionsangaben an einer Quelle ausgerichtet.
#
# ./tools/set_version.sh 0.4.1 # Version setzen (project.godot + Ableitungen)
# ./tools/set_version.sh --check # nur prüfen, Exit 1 bei Abweichung
#
# Quelle ist `rinkplanner/project.godot` (config/version); der Rest wird
# abgeleitet. `--check` läuft in ./tools/test.sh, damit eine vergessene Stelle
# sofort auffällt. Details: docs/deployment.md
set -euo pipefail
REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
usage() {
sed -n '2,10p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'
}
MODE="set"
VERSION=""
case "${1:-}" in
--check) MODE="check" ;;
-h|--help) usage; exit 0 ;;
"") usage; exit 2 ;;
*) VERSION="$1" ;;
esac
python3 - "$REPO_ROOT" "$MODE" "$VERSION" <<'PY'
import re
import sys
from pathlib import Path
root = Path(sys.argv[1])
mode = sys.argv[2]
version = sys.argv[3]
PROJECT = root / "rinkplanner" / "project.godot"
PRESETS = root / "rinkplanner" / "export_presets.cfg"
NSI = root / "tools" / "windows_installer.nsi"
WIN_EXPORT = root / "tools" / "export_windows_installer.sh"
if mode == "set" and not re.fullmatch(r"\d+\.\d+\.\d+", version):
sys.exit(f"Ungültige Version: {version} (erwartet x.y.z)")
major, minor, patch = (int(part) for part in (
version.split(".") if version else re.search(
r'config/version="([^"]+)"', PROJECT.read_text()
).group(1).split(".")
))
version = f"{major}.{minor}.{patch}"
four = f"{version}.0"
code = major * 10000 + minor * 100 + patch
# (Datei, Regex auf eine Zeile, erwarteter Inhalt der Zeile)
SPEC = [
(PROJECT, r'^config/version="[^"]*"$', f'config/version="{version}"'),
(PRESETS, r'^application/file_version="[^"]*"$',
f'application/file_version="{four}"'),
(PRESETS, r'^application/product_version="[^"]*"$',
f'application/product_version="{four}"'),
(PRESETS, r'^application/short_version="[^"]*"$',
f'application/short_version="{version}"'),
(PRESETS, r'^application/version="[^"]*"$',
f'application/version="{version}"'),
(PRESETS, r'^version/name="[^"]*"$', f'version/name="{version}"'),
(PRESETS, r'^version/code=\d+$', f"version/code={code}"),
(NSI, r'^\s*!define APP_VERSION "[^"]*"$',
f' !define APP_VERSION "{four}"'),
(WIN_EXPORT, r'^VERSION="\$\{VERSION:-[^}]*\}"$',
f'VERSION="${{VERSION:-{four}}}"'),
]
problems = []
for path, pattern, expected in SPEC:
text = path.read_text()
lines = text.split("\n")
matches = [i for i, line in enumerate(lines) if re.match(pattern, line)]
if len(matches) != 1:
problems.append(
f"{path.relative_to(root)}: erwartet genau eine Stelle für {pattern}, "
f"gefunden {len(matches)}"
)
continue
index = matches[0]
if lines[index] != expected:
if mode == "check":
problems.append(
f"{path.relative_to(root)}:{index + 1}: "
f"'{lines[index].strip()}' statt '{expected}'"
)
else:
lines[index] = expected
path.write_text("\n".join(lines))
if mode == "check":
if problems:
print("Versionsangaben weichen ab:")
for problem in problems:
print(f" {problem}")
print("Setzen mit ./tools/set_version.sh <x.y.z>")
sys.exit(1)
print(f"Version {version} ist an allen Stellen konsistent.")
sys.exit(0)
if problems:
print("Versionsangaben konnten nicht gesetzt werden:")
for problem in problems:
print(f" {problem}")
sys.exit(1)
print(f"Version {version} gesetzt:")
print(f" project.godot, Export-Presets (Windows {four}, macOS/Android {version})")
print(f" Android version/code = {code}")
print(f" NSIS-Fallbacks in tools/windows_installer.nsi, export_windows_installer.sh")
PY

View file

@ -24,6 +24,9 @@ if [[ ! -x "$GODOT" ]]; then
exit 1
fi
# Version consistency first: a forgotten place should fail fast.
"$REPO_ROOT/tools/set_version.sh" --check
# Import once so global class names and resources are registered.
"$GODOT" --headless --path "$PROJECT_DIR" --import >/dev/null