@legios/quartermaster 0.1.11 → 0.1.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,433 @@
1
+ """Las cinco frases de presupuesto tienen que decir los mismos números.
2
+
3
+ 0.1.11 arregló en cinco lugares a la vez el mismo error: `porDia` sale del
4
+ porcentaje de AHORA, que ya tiene adentro lo gastado hoy, y las cinco pantallas
5
+ le restaban lo gastado otra vez. El núcleo pasó a mandar la resta hecha
6
+ (`porDiaHoy` y `restanteMedido`) y las cinco pasaron a leerla.
7
+
8
+ Lo que quedó sin comprobar es que sigan leyéndola. Medido el 2026-09-14, con el
9
+ árbol en `c910137`: se volvió a poner en `bin/qm-indicator` exactamente el doble
10
+ descuento que 0.1.11 había sacado —`porDia` en vez de `porDiaHoy`, la resta a
11
+ mano en vez de `restanteMedido`— y `make gate-dibujo`, `gate-tarjetas` y los 148
12
+ tests quedaron en verde. La regresión que costó una release entera volvía a
13
+ entrar sin que nada se pusiera rojo, porque `test/fixtures/panel.json` no traía
14
+ los campos nuevos: los tres gates que dibujan entraban siempre por la rama de
15
+ respaldo, la del `qm` anterior.
16
+
17
+ Es la misma historia que `gate-duraciones`: una regla escrita en cinco
18
+ comentarios y en ningún lado comprobada. Ahí convivieron dos convenciones
19
+ durante meses; acá el número que se compara es el que dice cuánto podés gastar.
20
+ Y en la primera corrida de verdad este gate encontró que la bandeja de Windows
21
+ contestaba «te queda 0.0 %» donde las otras cuatro decían 0.3.
22
+
23
+ El canon está congelado en test/fixtures/presupuesto.json, sacado corriendo el
24
+ núcleo. Cada implementación se EJECUTA con el mismo JSON y se compara contra esa
25
+ tabla. Las que no tienen intérprete en esta máquina se saltean diciéndolo —
26
+ nunca se dan por buenas en silencio—, y `QM_GATE_EXIGE` convierte el salteo en
27
+ rojo en los jobs cuyo runner sí los trae.
28
+
29
+ Dos cosas que no se comparan letra por letra, y se dicen en la salida en vez de
30
+ esconderlas:
31
+
32
+ - **el separador decimal.** El tablero escribe «16,1» y las otras cuatro
33
+ «16.1». Los números se comparan como números; que el tablero use coma es una
34
+ diferencia de dibujo que hay que decidir, no un rojo que este gate invente.
35
+ - **el respaldo de un `qm` anterior en la barra de macOS.** En las otras
36
+ pantallas el `?? porDia` está adentro de la función que escribe; en Swift
37
+ está en el parseo del JSON, una función más arriba. Ese caso se saltea ahí,
38
+ diciéndolo.
39
+
40
+ La hora de `medidoDesde` la escribe cada pantalla con el reloj de la máquina, así
41
+ que no se compara contra un string congelado: se exige que las pantallas digan
42
+ LA MISMA, que es la invariante que importa. El tablero llegó a decir «11:54 a.
43
+ m.» mientras las otras cuatro decían «11:54».
44
+ """
45
+
46
+ import importlib.machinery
47
+ import importlib.util
48
+ import json
49
+ import os
50
+ import pathlib
51
+ import re
52
+ import shutil
53
+ import subprocess
54
+ import sys
55
+ import tempfile
56
+ from datetime import datetime
57
+
58
+ # La salida va en UTF-8 aunque la consola no lo sea. En el runner de Windows la
59
+ # codepage es cp1252 y el `✓` la rompe con un UnicodeEncodeError: el gate se
60
+ # moría al IMPRIMIR el verde, después de haber comparado bien. Un gate que
61
+ # revienta contando lo que le salió bien es indistinguible de uno que falló.
62
+ for _salida in (sys.stdout, sys.stderr):
63
+ try:
64
+ _salida.reconfigure(encoding="utf-8", errors="replace")
65
+ except (AttributeError, ValueError): # una salida que no es un archivo de texto
66
+ pass
67
+
68
+ RAIZ = pathlib.Path(__file__).resolve().parent.parent
69
+ TABLA = json.loads((RAIZ / "test/fixtures/presupuesto.json").read_text(encoding="utf-8"))
70
+ CASOS = TABLA["casos"]
71
+
72
+ # Lo que devuelve una pantalla para un caso que no le toca contestar.
73
+ SALTEADO = "—"
74
+
75
+
76
+ def bloque(ruta: pathlib.Path, arranque: str, abre: str = "{", cierra: str = "}") -> str:
77
+ """El cuerpo de una función, contando llaves desde su primera línea."""
78
+ texto = ruta.read_text(encoding="utf-8")
79
+ i = texto.index(arranque)
80
+ nivel, j = 0, i
81
+ while True:
82
+ if texto[j] == abre:
83
+ nivel += 1
84
+ elif texto[j] == cierra:
85
+ nivel -= 1
86
+ if nivel == 0:
87
+ return texto[i:j + 1]
88
+ j += 1
89
+
90
+
91
+ # ── cómo se compara ──────────────────────────────────────────────────────
92
+ #
93
+ # El núcleo escribe UN renglón; los que dibujan escriben DOS, y le pegan al
94
+ # primero el nombre de la ventana («· weekly_all») porque la tarjeta muestra
95
+ # tres barras y el número reparte una sola. Ninguna de las dos cosas es una
96
+ # diferencia de lo que se DICE: se normalizan y se compara la frase.
97
+ HORA = re.compile(r"\d{2}:\d{2}")
98
+
99
+
100
+ def frase(renglones, barra) -> str:
101
+ texto = " · ".join(r for r in renglones if r)
102
+ if barra:
103
+ texto = texto.replace(f" · {barra}", "")
104
+ return " ".join(texto.split())
105
+
106
+
107
+ def numeros(texto: str) -> list[float]:
108
+ """Los números de la frase, en orden, con coma o con punto."""
109
+ return [float(n.replace(",", ".")) for n in re.findall(r"\d+[.,]\d", HORA.sub("", texto))]
110
+
111
+
112
+ def rama(texto: str) -> str:
113
+ if "de acá a medianoche" in texto:
114
+ return "reparto"
115
+ if "desde las" in texto:
116
+ return "medido"
117
+ if "hoy" in texto:
118
+ return "hoy"
119
+ return "?"
120
+
121
+
122
+ def sin_campos_nuevos(entrada: dict) -> bool:
123
+ """El JSON de un `qm` anterior a 0.1.11."""
124
+ return entrada.get("porDiaHoy") is None and entrada.get("restanteMedido") is None
125
+
126
+
127
+ # ── las implementaciones ─────────────────────────────────────────────────
128
+ #
129
+ # Todas leen la salida del hijo con encoding="utf-8" explícito. Sin eso Python
130
+ # la decodifica con la codepage de la máquina, que en Windows no es UTF-8: las
131
+ # cinco frases volvían con `é` y `·` rotos y el gate comparaba mojibake contra
132
+ # el canon. Medido en el CI el 2026-09-14, no supuesto.
133
+ def por_typescript() -> list[str]:
134
+ """El núcleo. `frasePresupuesto` come el Presupuesto de adentro, no el JSON,
135
+ así que se le arma uno con los campos que la frase usa. Un caso sin
136
+ `porDiaHoy` es un JSON que el núcleo NUNCA emite —es el de un qm anterior—,
137
+ y ahí no se lo llama: contestar por él sería inventar."""
138
+ entradas = []
139
+ for c in CASOS:
140
+ e = c["entrada"]
141
+ entradas.append(None if sin_campos_nuevos(e) else {
142
+ "estado": e["estado"], "motivo": e.get("motivo"),
143
+ "porDiaHoy": e["porDiaHoy"], "quedaHoy": e["quedaHoy"],
144
+ "gastadoHoy": e["gastadoHoy"], "restanteHoy": e["restanteHoy"],
145
+ "gastadoMedido": e["gastadoMedido"], "restanteMedido": e["restanteMedido"],
146
+ "medidoDesde": e["medidoDesde"],
147
+ })
148
+ guion = (
149
+ "import {frasePresupuesto} from './src/core/presupuesto.ts';"
150
+ f"const cs={json.dumps(entradas)};"
151
+ "console.log(JSON.stringify(cs.map(c=>c===null?null:frasePresupuesto("
152
+ "{...c, medidoDesde: c.medidoDesde===null?null:new Date(c.medidoDesde).getTime()}))));"
153
+ )
154
+ r = subprocess.run(["node", "--experimental-strip-types", "-e", guion],
155
+ cwd=RAIZ, capture_output=True, text=True, encoding="utf-8", timeout=60)
156
+ if r.returncode != 0:
157
+ raise RuntimeError(r.stderr.strip().splitlines()[-1] if r.stderr else "node falló")
158
+ return [SALTEADO if s is None else s for s in json.loads(r.stdout)]
159
+
160
+
161
+ def por_python() -> list[str]:
162
+ """El indicador de GNOME."""
163
+ spec = importlib.util.spec_from_loader(
164
+ "qmi", importlib.machinery.SourceFileLoader("qmi", str(RAIZ / "bin/qm-indicator")))
165
+ m = importlib.util.module_from_spec(spec)
166
+ spec.loader.exec_module(m)
167
+ return [frase(m.renglones_presupuesto(c["entrada"]), c["entrada"].get("barra")) for c in CASOS]
168
+
169
+
170
+ def por_powershell() -> list[str]:
171
+ """La bandeja de Windows. Con StrictMode, como corre de verdad: leer una
172
+ propiedad que no está es una excepción, y es justo lo que pasa con el JSON
173
+ de un qm anterior."""
174
+ fn = bloque(RAIZ / "bin/qm-tray.ps1", "function RenglonesPresupuesto($pre) {")
175
+ with tempfile.TemporaryDirectory() as d:
176
+ guion, datos, dicho = (pathlib.Path(d) / n for n in ("p.ps1", "casos.json", "dicho.txt"))
177
+ datos.write_text(json.dumps([c["entrada"] for c in CASOS]), encoding="utf-8")
178
+ # Un renglón por caso, a un archivo en UTF-8. Ni JSON ni stdout, y las
179
+ # dos cosas medidas en el CI y no supuestas: el ConvertTo-Json del
180
+ # PowerShell 5.1 envuelve cada arreglo en {value, Count}, y la consola de
181
+ # Windows escribe en la codepage de la máquina, así que el `·` y los
182
+ # acentos volvían rotos.
183
+ guion.write_text(
184
+ "Set-StrictMode -Version Latest\n"
185
+ "$ErrorActionPreference = 'Stop'\n"
186
+ f"{fn}\n"
187
+ f"$casos = Get-Content -Raw -Encoding UTF8 '{datos}' | ConvertFrom-Json\n"
188
+ "$dicho = foreach ($c in $casos) { (RenglonesPresupuesto $c) -join ' · ' }\n"
189
+ f"[System.IO.File]::WriteAllLines('{dicho}', [string[]]$dicho, "
190
+ "(New-Object System.Text.UTF8Encoding $false))\n",
191
+ # Con BOM: el Windows PowerShell 5.1 lee un .ps1 sin BOM en la
192
+ # codepage de la máquina, no en UTF-8, así que el `·` y los acentos
193
+ # del guión —los de la frase, justamente— le llegaban rotos y la
194
+ # bandeja «decía» otra cosa que las demás. Medido en el CI el
195
+ # 2026-09-14. scripts/gate-bandeja.ps1 ya arranca con BOM por esto.
196
+ encoding="utf-8-sig")
197
+ orden = [EXE_PS, "-NoProfile"]
198
+ if sys.platform == "win32":
199
+ # Sólo existe en Windows: en el pwsh de Linux el proceso ni arranca.
200
+ orden += ["-ExecutionPolicy", "Bypass"]
201
+ r = subprocess.run(orden + ["-File", str(guion)],
202
+ capture_output=True, text=True, encoding="utf-8", timeout=120)
203
+ if r.returncode != 0:
204
+ raise RuntimeError(r.stderr.strip().splitlines()[-1] if r.stderr else "powershell falló")
205
+ lineas = dicho.read_text(encoding="utf-8").splitlines()
206
+ if len(lineas) != len(CASOS):
207
+ raise RuntimeError(f"contestó {len(lineas)} renglones y esperaba {len(CASOS)}")
208
+ return [frase([l], c["entrada"].get("barra")) for l, c in zip(lineas, CASOS)]
209
+
210
+
211
+ def por_tablero() -> list[str]:
212
+ """El tablero web. Dibuja pares clave/valor en HTML, no una frase: de él se
213
+ comparan los números y la rama, que es lo que tiene que coincidir."""
214
+ fn = bloque(RAIZ / "src/render/tablero.html", "function presupuesto(pre) {")
215
+ guion = (
216
+ "const esc = (s) => String(s);\n"
217
+ "const unDecimal = (n) => Number(n).toFixed(1).replace('.', ',');\n"
218
+ f"{fn}\n"
219
+ f"const cs={json.dumps([c['entrada'] for c in CASOS])};\n"
220
+ "console.log(JSON.stringify(cs.map(c=>presupuesto(c))));"
221
+ )
222
+ with tempfile.TemporaryDirectory() as d:
223
+ p = pathlib.Path(d) / "t.mjs"
224
+ p.write_text(guion, encoding="utf-8")
225
+ r = subprocess.run(["node", str(p)], capture_output=True, text=True, encoding="utf-8", timeout=60)
226
+ if r.returncode != 0:
227
+ raise RuntimeError(r.stderr.strip().splitlines()[-1] if r.stderr else "node falló")
228
+ salidas = []
229
+ for html in json.loads(r.stdout):
230
+ # El globo lleva el JSON adentro de un atributo, con sus propios números.
231
+ limpio = re.sub(r"<[^>]+>", " ", re.sub(r"data-tip='[^']*'", "", html))
232
+ salidas.append(" ".join(limpio.split()))
233
+ return salidas
234
+
235
+
236
+ def por_swift() -> list[str]:
237
+ """La barra de macOS. Su frase no está en una función sino adentro de un
238
+ `switch`, así que se le saca el cuerpo del `case` y se lo envuelve en una:
239
+ `self.presupuesto = …` pasa a ser la salida y los valores del patrón pasan a
240
+ ser parámetros. Es el mismo código con el `switch` de alrededor sacado.
241
+
242
+ El caso del `qm` anterior no entra: en la barra el `?? porDia` está en el
243
+ parseo del JSON, no acá."""
244
+ texto = (RAIZ / "bin/qm-barra.swift").read_text(encoding="utf-8")
245
+ i = texto.index("case .reparte(_, let porDiaHoy")
246
+ cuerpo = texto[texto.index(":", i) + 1:texto.index("case .no(let motivo)", i)]
247
+ cuerpo = cuerpo.replace("self.presupuesto", "salida")
248
+ entradas = []
249
+ for c in CASOS:
250
+ e = c["entrada"]
251
+ if sin_campos_nuevos(e):
252
+ entradas.append(None)
253
+ continue
254
+ entradas.append({
255
+ "porDiaHoy": e["porDiaHoy"], "quedaHoy": e["quedaHoy"],
256
+ "gastado": e["gastadoHoy"] if e["cubreElDia"] else e["gastadoMedido"],
257
+ "restante": e["restanteMedido"], "cubreElDia": e["cubreElDia"],
258
+ # El mismo instante que el ISO: la hora que dibuja tiene que ser la
259
+ # misma que dicen las otras pantallas.
260
+ "desde": None if e["medidoDesde"] is None else datetime.fromisoformat(
261
+ e["medidoDesde"].replace("Z", "+00:00")).timestamp(),
262
+ })
263
+ with tempfile.TemporaryDirectory() as d:
264
+ p, datos = pathlib.Path(d) / "b.swift", pathlib.Path(d) / "casos.json"
265
+ datos.write_text(json.dumps([e for e in entradas if e is not None]), encoding="utf-8")
266
+ p.write_text(
267
+ "import Foundation\n"
268
+ "func renglones(_ porDiaHoy: Double, _ quedaHoy: Double, _ gastado: Double?,\n"
269
+ " _ restante: Double?, _ desde: Date?, _ cubreElDia: Bool) -> [String] {\n"
270
+ " var salida: [String] = []\n"
271
+ f"{cuerpo}\n"
272
+ " return salida\n"
273
+ "}\n"
274
+ "struct Caso: Decodable { let porDiaHoy: Double; let quedaHoy: Double\n"
275
+ " let gastado: Double?; let restante: Double?; let desde: Double?\n"
276
+ " let cubreElDia: Bool }\n"
277
+ f'let d = try! Data(contentsOf: URL(fileURLWithPath: "{datos}"))\n'
278
+ "for c in try! JSONDecoder().decode([Caso].self, from: d) {\n"
279
+ " print(renglones(c.porDiaHoy, c.quedaHoy, c.gastado, c.restante,\n"
280
+ " c.desde.map { Date(timeIntervalSince1970: $0) }, c.cubreElDia)\n"
281
+ ' .joined(separator: " · "))\n'
282
+ "}\n", encoding="utf-8")
283
+ r = subprocess.run(["swift", str(p)], capture_output=True, text=True, encoding="utf-8", timeout=300)
284
+ if r.returncode != 0:
285
+ raise RuntimeError(r.stderr.strip().splitlines()[-1] if r.stderr else "swift falló")
286
+ dichas = iter(r.stdout.strip().split("\n"))
287
+ return [SALTEADO if e is None else next(dichas) for e in entradas]
288
+
289
+
290
+ def redaccion_swift() -> list[str]:
291
+ """Sin swiftc no se puede ejecutar, pero la REDACCIÓN se lee igual: los
292
+ `String(format:)` de la rama `.reparte` tienen que ser los del canon."""
293
+ texto = (RAIZ / "bin/qm-barra.swift").read_text(encoding="utf-8")
294
+ i = texto.index("case .reparte(_, let porDiaHoy")
295
+ return re.findall(r'String\(format: "([^"]+)"', texto[i:texto.index("case .no(let motivo)", i)])
296
+
297
+
298
+ def canon_a_formato(esperado: str) -> list[str]:
299
+ """El canon partido en los dos pedazos que la barra escribe por separado, en
300
+ el dialecto de `String(format:)`."""
301
+ partes = esperado.split(" · ")
302
+ fmt = []
303
+ for p in (partes[0], " · ".join(partes[1:])):
304
+ # El orden importa: primero se escapan los `%` que son literales, y
305
+ # recién después se ponen los huecos, que traen `%` propios.
306
+ f = re.sub(r"\d+\.\d", "%.1f", p.replace("%", "%%"))
307
+ fmt.append(f.replace("{desde}", "%@"))
308
+ return fmt
309
+
310
+
311
+ # ── el gate ──────────────────────────────────────────────────────────────
312
+ # En Windows, `powershell` PRIMERO: la bandeja corre con el Windows PowerShell
313
+ # 5.1, que es lo que hay en una máquina sin instalar nada, y es el mismo motivo
314
+ # por el que gate-bandeja.ps1 no va con pwsh. Fuera de Windows el único que hay
315
+ # es pwsh.
316
+ EXE_PS = shutil.which("powershell") or shutil.which("pwsh") or ""
317
+
318
+ def hay(requisito: str | None) -> bool:
319
+ """Si en esta máquina se puede correr esa pantalla.
320
+
321
+ `cairo` no es un binario en el PATH: el indicador de GNOME importa gi y
322
+ cairo al cargarse, así que en el runner de Windows —donde la bandeja SÍ se
323
+ puede correr— importarlo revienta. Eso es una pantalla que no se puede
324
+ comprobar acá, no un gate roto."""
325
+ if requisito is None:
326
+ return True
327
+ if requisito == "cairo":
328
+ try:
329
+ import gi # noqa: F401
330
+ import cairo # noqa: F401
331
+ except Exception: # noqa: BLE001 — sin gi/cairo no hay indicador que correr
332
+ return False
333
+ return True
334
+ return shutil.which(requisito) is not None
335
+
336
+
337
+ IMPLEMENTACIONES = [
338
+ ("TypeScript · el núcleo", por_typescript, "node"),
339
+ ("Python · el indicador de GNOME", por_python, "cairo"),
340
+ ("Swift · la barra de macOS", por_swift, "swift"),
341
+ ("PowerShell · la bandeja", por_powershell, "powershell" if sys.platform == "win32" else "pwsh"),
342
+ ("JavaScript · el tablero", por_tablero, "node"),
343
+ ]
344
+
345
+
346
+ def main() -> int:
347
+ # QM_GATE_EXIGE lista los intérpretes que TIENEN que estar, igual que en
348
+ # gate-duraciones: en una laptop saltear swift y pwsh es lo razonable; en un
349
+ # runner que los trae, saltear en silencio convierte al gate en un adorno.
350
+ exigidos = {x for x in os.environ.get("QM_GATE_EXIGE", "").split(",") if x}
351
+ fallas: list[str] = []
352
+ salteadas: list[str] = []
353
+ corridas: dict[str, list[str]] = {}
354
+
355
+ for nombre, correr, binario in IMPLEMENTACIONES:
356
+ if not hay(binario):
357
+ if binario in exigidos:
358
+ fallas.append(f"falta {binario}, y este job lo exige "
359
+ f"(QM_GATE_EXIGE={','.join(sorted(exigidos))})")
360
+ continue
361
+ falta = "python3-gi y cairo" if binario == "cairo" else binario
362
+ salteadas.append(f"{nombre} (no hay {falta} en esta máquina)")
363
+ continue
364
+ try:
365
+ salida = correr()
366
+ except Exception as e: # noqa: BLE001 — un adaptador roto es un rojo, no un salteo
367
+ fallas.append(f"no pude correr {nombre}: {e}")
368
+ continue
369
+ if len(salida) != len(CASOS):
370
+ fallas.append(f"{nombre} devolvió {len(salida)} frases y esperaba {len(CASOS)}")
371
+ continue
372
+ corridas[nombre] = salida
373
+
374
+ if not corridas and not fallas:
375
+ fallas.append("no se pudo correr NINGUNA pantalla")
376
+
377
+ for i, caso in enumerate(CASOS):
378
+ esperado = caso["esperado"]
379
+ horas: dict[str, str] = {}
380
+ for nombre, salidas in corridas.items():
381
+ dicho = salidas[i]
382
+ if dicho == SALTEADO:
383
+ continue
384
+ hora = HORA.search(dicho)
385
+ if hora:
386
+ horas[nombre] = hora.group(0)
387
+ # El tablero dibuja pares clave/valor: de él se comparan los números
388
+ # y la rama. De los que escriben una frase, la frase entera.
389
+ if "tablero" in nombre:
390
+ if numeros(dicho) != numeros(esperado) or rama(dicho) != rama(esperado):
391
+ fallas.append(f"caso {i + 1} «{caso['nombre']}»\n {nombre}\n"
392
+ f" esperaba {rama(esperado)} {numeros(esperado)}\n"
393
+ f" dijo {rama(dicho)} {numeros(dicho)}")
394
+ continue
395
+ comparable = HORA.sub("{desde}", dicho)
396
+ if comparable != esperado:
397
+ fallas.append(f"caso {i + 1} «{caso['nombre']}»\n {nombre}\n"
398
+ f" esperaba {esperado}\n dijo {comparable}")
399
+ if len(set(horas.values())) > 1:
400
+ fallas.append(f"caso {i + 1}: la hora de medidoDesde no coincide entre pantallas: "
401
+ + ", ".join(f"{n} dice {h}" for n, h in horas.items()))
402
+
403
+ # Sin swiftc la barra no se ejecuta, pero su redacción se lee igual.
404
+ corrio_swift = any("Swift" in n for n in corridas)
405
+ if not corrio_swift:
406
+ dichos = redaccion_swift()
407
+ for f in sorted({f for c in CASOS for f in canon_a_formato(c["esperado"])} - set(dichos)):
408
+ fallas.append("la barra de macOS no escribe esta frase del canon:\n"
409
+ f" {f}\n escribe: " + " | ".join(dichos))
410
+
411
+ if fallas:
412
+ for f in fallas:
413
+ print(f"GATE ROJO: {f}", file=sys.stderr)
414
+ return 1
415
+
416
+ for nombre, salidas in corridas.items():
417
+ salteados = sum(1 for s in salidas if s == SALTEADO)
418
+ cola = f" · {salteados} salteado: el qm anterior no pasa por esta función" if salteados else ""
419
+ print(f" ✓ {nombre}: {len(CASOS) - salteados}/{len(CASOS)}{cola}")
420
+ for s in salteadas:
421
+ print(f" · salteada: {s}")
422
+ if salteadas:
423
+ print(f"presupuesto: {len(CASOS)} casos, coinciden las pantallas que se pudieron correr acá")
424
+ else:
425
+ print(f"presupuesto: {len(CASOS)} casos, las cinco pantallas dicen lo mismo")
426
+ if not corrio_swift:
427
+ print(" · de la barra de macOS se comprobó la redacción, no la ejecución")
428
+ print(" · el tablero escribe los números con coma; se comparan como números")
429
+ return 0
430
+
431
+
432
+ if __name__ == "__main__":
433
+ raise SystemExit(main())
@@ -1,7 +1,8 @@
1
- """Dos invariantes del panel que no avisan cuando se rompen.
1
+ """Tres invariantes del panel que no avisan cuando se rompen.
2
2
 
3
3
  1 · Ninguna tarjeta puede ser más alta que una pantalla.
4
4
  2 · Nada se dibuja fuera de la tarjeta.
5
+ 3 · La cabecera existe, y no la encabeza una cuenta dormida.
5
6
 
6
7
  El panel de GNOME es un `Gtk.Menu`, y un menú rueda ITEM por item: con un solo
7
8
  item más alto que la pantalla no hay nada que rodar y el menú directamente no
@@ -42,11 +43,55 @@ def main() -> int:
42
43
  if not margen_limpio(m):
43
44
  return 1
44
45
 
46
+ if not cabecera_correcta(m):
47
+ return 1
48
+
45
49
  print(f"tarjetas: la más alta es {nombre} con {alto} px, bajo el techo de {TECHO}; "
46
50
  f"y nada se sale del margen")
51
+ print("cabecera: está, y la encabeza una cuenta despierta")
47
52
  return 0
48
53
 
49
54
 
55
+ def cabecera_correcta(m) -> bool:
56
+ """Que el panel tenga cabecera, y que no la encabece una cuenta dormida.
57
+
58
+ Las dos mitades existen porque las dos se rompieron de verdad, en silencio:
59
+
60
+ · La cabecera DESAPARECIÓ entera el día que dejó de calcularse acá y pasó a
61
+ leerse de `frenaPrimero`. Los fixtures todavía no traían ese campo, así
62
+ que `VistaResumen.desde()` devolvía None y el panel se dibujaba sin
63
+ encabezado. Los gates siguieron verdes: ninguno miraba si estaba.
64
+
65
+ · Y encabezarla con una cuenta dormida es el bug que originó todo el cambio.
66
+ Una cuenta free abandonada y clavada en 100 % gana por porcentaje siempre,
67
+ porque 100 es el máximo posible.
68
+ """
69
+ cabecera, _ = m.modelo_panel(m.leer_desde("test/fixtures/panel.json"))
70
+ if cabecera is None:
71
+ print("GATE ROJO: el panel se dibujó SIN cabecera. El fixture no trae "
72
+ "`frenaPrimero`, o el renderer dejó de leerlo.", file=sys.stderr)
73
+ return False
74
+
75
+ datos = m.leer_desde("test/fixtures/panel-dormida.json")
76
+ cabecera, _ = m.modelo_panel(datos)
77
+ if cabecera is None:
78
+ print("GATE ROJO: sin cabecera en el fixture de la cuenta dormida",
79
+ file=sys.stderr)
80
+ return False
81
+ dormidas = {p.get("perfil") for p in datos.get("perfiles", [])
82
+ if (p.get("relevancia") or {}).get("dormida")}
83
+ if not dormidas:
84
+ print("GATE ROJO: el fixture panel-dormida.json perdió su cuenta dormida, "
85
+ "así que no prueba nada", file=sys.stderr)
86
+ return False
87
+ if cabecera.cuenta in {m.corto(x) for x in dormidas}:
88
+ print(f"GATE ROJO: encabeza «{cabecera.cuenta}», que está dormida. Una "
89
+ f"cuenta que nadie usa no puede ser «lo primero que te frena».",
90
+ file=sys.stderr)
91
+ return False
92
+ return True
93
+
94
+
50
95
  def margen_limpio(m) -> bool:
51
96
  """Que ningún texto se dibuje fuera de la tarjeta.
52
97
 
@@ -31,7 +31,16 @@ cp -r bin src scripts extension Makefile package.json "$arma/usr/lib/quartermast
31
31
  cp README.md LICENSE "$arma/usr/share/doc/quartermaster/"
32
32
  # El lanzador sigue los symlinks para encontrar el src/, así que un enlace
33
33
  # alcanza y no hay que duplicar el árbol.
34
- ln -sf /usr/lib/quartermaster/bin/qm "$arma/usr/bin/qm"
34
+ #
35
+ # Los tres que da npm, y no sólo `qm`: `qm-web` es el tablero para una máquina
36
+ # sin barra de GNOME, y `qm-indicator` es el que instala el item y el arranque
37
+ # automático —`--instalar-extension`, `--instalar-arranque`—. Sin el enlace esas
38
+ # banderas quedaban a una ruta de /usr/lib que nadie tiene por qué saber, y los
39
+ # READMEs las documentaban como si estuvieran en el PATH. `qm-barra` no: es de
40
+ # macOS y adentro de un .deb no tiene nada que hacer.
41
+ for enlace in qm qm-web qm-indicator; do
42
+ ln -sf "/usr/lib/quartermaster/bin/$enlace" "$arma/usr/bin/$enlace"
43
+ done
35
44
  find "$arma/usr/lib/quartermaster" -name '__pycache__' -prune -exec rm -rf {} +
36
45
  # Lo de Windows no tiene nada que hacer adentro de un .deb: los lanzadores .cmd,
37
46
  # la bandeja y el ícono del instalador. Son ~150 kB de archivos que en esta