@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.
- package/README.md +41 -12
- package/bin/qm +60 -12
- package/bin/qm-barra.swift +61 -23
- package/bin/qm-indicator +335 -27
- package/bin/qm-tray.ps1 +345 -57
- package/dist/adapters/barra.js +142 -31
- package/dist/adapters/barra.js.map +1 -1
- package/dist/adapters/codex.js +24 -0
- package/dist/adapters/codex.js.map +1 -1
- package/dist/adapters/opencode.js +31 -10
- package/dist/adapters/opencode.js.map +1 -1
- package/dist/adapters/zai.js +221 -0
- package/dist/adapters/zai.js.map +1 -0
- package/dist/cli/qm.js +228 -65
- package/dist/cli/qm.js.map +1 -1
- package/dist/core/relevancia.js +111 -0
- package/dist/core/relevancia.js.map +1 -0
- package/dist/render/tablero.html +19 -11
- package/extension/gnome43/quartermaster@legios/extension.js +261 -0
- package/extension/gnome43/quartermaster@legios/metadata.json +11 -0
- package/extension/gnome43/quartermaster@legios/stylesheet.css +10 -0
- package/extension/quartermaster@legios/extension.js +257 -0
- package/extension/quartermaster@legios/metadata.json +8 -0
- package/extension/quartermaster@legios/stylesheet.css +10 -0
- package/package.json +4 -2
- package/scripts/bumpear.mjs +9 -0
- package/scripts/gate-bandeja.ps1 +267 -19
- package/scripts/gate-presupuesto.py +433 -0
- package/scripts/gate-tarjetas.py +46 -1
- package/scripts/hacer-deb.sh +10 -1
- package/scripts/mandar-pr-winget.mjs +106 -21
- package/src/render/tablero.html +19 -11
|
@@ -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())
|
package/scripts/gate-tarjetas.py
CHANGED
|
@@ -1,7 +1,8 @@
|
|
|
1
|
-
"""
|
|
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
|
|
package/scripts/hacer-deb.sh
CHANGED
|
@@ -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
|
-
|
|
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
|