sergio/takana

1//! Importador `Alpine APKBUILD → receta takana` (Etapa G, fuente #2).
2//!
3//! **Por qué Alpine y no sólo nix:** Alpine ya porta miles de paquetes a **musl** (y a menudo
4//! estático), CON los parches de portabilidad. Eso es justo lo que un import de nixpkgs PIERDE (los
5//! parches de nix viven aparte y asumen glibc). Por eso Alpine es la mejor respuesta a "¿qué si el
6//! build falla en musl?": su APKBUILD trae el `source=` con los `.patch` que lo hacen compilar.
7//!
8//! Este importador PARSEA el APKBUILD (no lo ejecuta — es shell; sourcearlo correría código ajeno)
9//! y extrae: pkgname/pkgver, la URL de la fuente, **los `.patch` (los carga a `source.patches`)**,
10//! makedepends → deps, y `build()/package()` → fases (best-effort: son shell de abuild con CHOST/
11//! --shared/etc. ⇒ necesitan adaptación al lab estático de takana). Es un PUNTO DE PARTIDA, pero
12//! uno que YA incluye el trabajo de musl — mucho más cerca de compilar que un import crudo.
13
14use std::collections::BTreeMap;
15
16/// Convierte el texto de un APKBUILD en el TOML de una receta takana.
17pub fn recipe_from_apkbuild(text: &str) -> Result<String, String> {
18    let vars = parse_vars(text);
19    let get = |k: &str| vars.get(k).cloned().unwrap_or_default();
20
21    let pkgname = get("pkgname");
22    if pkgname.is_empty() {
23        return Err("APKBUILD sin pkgname".into());
24    }
25    let pkgver = get("pkgver");
26    let version = if pkgver.is_empty() { "0".into() } else { pkgver };
27
28    // source=: tokens separados por espacios/saltos. Cada uno: `[name::]url-o-fichero`.
29    // El primero con esquema (://) es el tarball; los `.patch` se cargan como parches.
30    let mut tarball = String::new();
31    let mut patches: Vec<String> = Vec::new();
32    for tok in get("source").split_whitespace() {
33        let (name, url) = match tok.split_once("::") {
34            Some((n, u)) => (n.to_string(), Some(u.to_string())),
35            None => {
36                let base = tok.rsplit('/').next().unwrap_or(tok).to_string();
37                let url = if tok.contains("://") { Some(tok.to_string()) } else { None };
38                (base, url)
39            }
40        };
41        if name.ends_with(".patch") || name.ends_with(".diff") {
42            patches.push(name);
43        } else if tarball.is_empty() {
44            if let Some(u) = url {
45                tarball = u;
46            }
47        }
48    }
49
50    let source_block = if tarball.is_empty() {
51        // Sin tarball (paquetes git-based usan $_commit + snapshot); dejamos un FIXME claro.
52        "# FIXME: no detecté tarball; fijá `tarball+sha256` o `repo+commit` a mano\ntarball = \"\"\nsha256  = \"\"\n".to_string()
53    } else {
54        let sha512 = first_sha(&get("sha512sums"));
55        format!(
56            "tarball = \"{tarball}\"\n\
57             # FIXME sha256: el wrapper lo calcula (Alpine publica sha512). sha512 de Alpine:\n\
58             # sha512 = \"{sha512}\"\n\
59             sha256  = \"FIXME-sha256\"\n"
60        )
61    };
62
63    // build-deps: SÓLO `makedepends`. El `depends` de abuild es RUNTIME (p.ej. gzip depends="less"
64    // para `zless`) — no hace falta para compilar y rompería `takana build` (busca recipes/less.toml).
65    // Lo emitimos como comentario de provenance, no como `[deps] build`. (checkdepends ni se lee: no
66    // corremos la suite de tests del paquete.)
67    let self_prefix = format!("{pkgname}-");
68    let normalize = |src: &str| -> Vec<String> {
69        let mut v: Vec<String> = Vec::new();
70        for d in src.split_whitespace() {
71            let d = d.trim();
72            // Saltamos: negados (!x), variables sin expandir ($x), pins versionados a subpaquetes
73            // (`foo=1.2-r3`), y auto-referencias al propio paquete/subpaquetes (`pkgname-...`).
74            if d.is_empty()
75                || d.starts_with('!')
76                || d.starts_with('$')
77                || d.contains('=')
78                || d.starts_with(&self_prefix)
79                || d == pkgname
80            {
81                continue;
82            }
83            // Alpine usa `foo-dev`, `cmd:make`, `pc:libfoo`, `so:libbar.so` — normalizamos lo común.
84            let name = d
85                .strip_prefix("cmd:")
86                .or_else(|| d.strip_prefix("pc:"))
87                .unwrap_or(d)
88                .trim_end_matches("-dev")
89                .to_string();
90            // El TOOLCHAIN no es un paquete a materializar: lo provee el lab (cargo/rustc = el flujo
91            // BuildSys::Cargo; make/cmake/meson = los detectores). Una receta que los pusiera en
92            // `[deps] build` abortaría buscando `cargo.toml`. El path nix ya los filtra; acá igual.
93            const TOOLCHAIN: &[&str] = &[
94                "cargo", "cargo-auditable", "rust", "rustc", "go", "make", "cmake", "meson", "ninja",
95            ];
96            if !name.is_empty()
97                && !name.starts_with("so:")
98                && !TOOLCHAIN.contains(&name.as_str())
99                && !v.contains(&name)
100            {
101                v.push(name);
102            }
103        }
104        v
105    };
106    let deps = normalize(&get("makedepends"));
107    let runtime = normalize(&get("depends"));
108    let mut deps_block = String::new();
109    if !runtime.is_empty() {
110        deps_block.push_str(&format!("\n# depends de runtime de Alpine (NO build-deps): {}\n", runtime.join(", ")));
111    }
112    if !deps.is_empty() {
113        let list = deps.iter().map(|d| format!("\"{d}\"")).collect::<Vec<_>>().join(", ");
114        deps_block.push_str(&format!("\n[deps]\nbuild = [{list}]\n"));
115    }
116
117    // build()/package() → fases (best-effort, comentadas como abuild-shell a adaptar).
118    let phases_block = {
119        let compile = func_body(text, "build");
120        let install = func_body(text, "package");
121        if compile.is_none() && install.is_none() {
122            String::new()
123        } else {
124            let mut s = String::from("\n[build.phases]\n");
125            if let Some(b) = compile {
126                let t = translate_abuild(&b, &pkgname, &version);
127                s.push_str(&format!("# de build() de Alpine (traducido; el lab provee $CBUILD/$CHOST — Etapa G Fase 3; revisá --shared para estático):\ncompile = {}\n", toml_multiline(&t)));
128            }
129            if let Some(p) = install {
130                let t = translate_abuild(&p, &pkgname, &version);
131                s.push_str(&format!("# de package() de Alpine (traducido $pkgdir→/out):\ninstall = {}\n", toml_multiline(&t)));
132            }
133            s
134        }
135    };
136
137    let patches_line = if patches.is_empty() {
138        String::new()
139    } else {
140        let list = patches.iter().map(|p| format!("\"{p}\"")).collect::<Vec<_>>().join(", ");
141        format!("patches = [{list}]\n")
142    };
143
144    let toml = format!(
145        "# Importada de Alpine aports por `hammer import-alpine` (Etapa G). PUNTO DE PARTIDA — pero\n\
146         # YA trae los parches de musl de Alpine (lo que un import de nix pierde). Pendiente: el\n\
147         # sha256 del tarball (el wrapper lo calcula), y adaptar build/install del shell de abuild.\n\
148         name    = \"{pkgname}\"\n\
149         version = \"{version}\"\n\
150         \n\
151         [source]\n\
152         {source_block}{patches_line}\
153         \n\
154         [build]\n\
155         compiler = \"zig-cc\"\n\
156         target   = \"x86_64-linux-musl\"\n\
157         link     = \"static\"\n\
158         flags    = []\n\
159         {phases_block}{deps_block}"
160    );
161    Ok(toml)
162}
163
164/// Recoge asignaciones `clave=valor` y `clave="...multilínea..."` del APKBUILD (ignora funciones y
165/// comentarios). Suficiente para los campos de metadatos; expande `$var`/`${var}` conocidas.
166fn parse_vars(text: &str) -> BTreeMap<String, String> {
167    let mut raw: BTreeMap<String, String> = BTreeMap::new();
168    let bytes: Vec<&str> = text.lines().collect();
169    let mut i = 0;
170    while i < bytes.len() {
171        let line = bytes[i];
172        let trimmed = line.trim_start();
173        // Asignación simple `key=...` al inicio de línea (no dentro de función: heurística por '=').
174        if let Some(eq) = simple_assign(trimmed) {
175            let key = trimmed[..eq].to_string();
176            let mut val = trimmed[eq + 1..].to_string();
177            // Valor multilínea entre comillas dobles: acumular hasta cerrar.
178            if let Some(rest) = val.strip_prefix('"') {
179                if let Some(end) = rest.find('"') {
180                    val = rest[..end].to_string();
181                } else {
182                    let mut acc = rest.to_string();
183                    i += 1;
184                    while i < bytes.len() {
185                        if let Some(end) = bytes[i].find('"') {
186                            acc.push('\n');
187                            acc.push_str(&bytes[i][..end]);
188                            break;
189                        } else {
190                            acc.push('\n');
191                            acc.push_str(bytes[i]);
192                        }
193                        i += 1;
194                    }
195                    val = acc;
196                }
197            } else {
198                // valor sin comillas: hasta fin de línea, sin comentario.
199                val = val.split('#').next().unwrap_or("").trim().to_string();
200                val = val.trim_matches('\'').to_string();
201            }
202            raw.insert(key, val);
203        }
204        i += 1;
205    }
206    // Expansión de variables (varias pasadas para anidamiento simple).
207    let keys: Vec<String> = raw.keys().cloned().collect();
208    for _ in 0..3 {
209        for k in &keys {
210            let mut v = raw[k].clone();
211            for k2 in &keys {
212                let val2 = raw[k2].clone();
213                v = v.replace(&format!("${{{k2}}}"), &val2).replace(&format!("${k2}"), &val2);
214            }
215            raw.insert(k.clone(), v);
216        }
217    }
218    raw
219}
220
221/// `Some(pos_del_=)` si la línea es una asignación `nombre=...` válida (nombre shell). Evita
222/// confundir `foo() {`, comparaciones, o `export X=Y`.
223fn simple_assign(line: &str) -> Option<usize> {
224    let eq = line.find('=')?;
225    if eq == 0 {
226        return None;
227    }
228    let name = &line[..eq];
229    if name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') && name.chars().next()?.is_ascii_alphabetic() || name.starts_with('_') {
230        // siguiente char no debe ser '=' (==) ni la asignación es vacía rara.
231        if line.as_bytes().get(eq + 1) == Some(&b'=') {
232            return None;
233        }
234        return Some(eq);
235    }
236    None
237}
238
239/// Extrae el cuerpo de una función shell `name() { ... }`: el texto entre la primera `{` y la `}`
240/// que la cierra a nivel 0. Best-effort (no parsea shell de verdad; cuenta llaves).
241fn func_body(text: &str, name: &str) -> Option<String> {
242    let pat_a = format!("{name}()");
243    let start = text.find(&pat_a)?;
244    let brace = text[start..].find('{')? + start;
245    let mut depth = 0i32;
246    let mut end = None;
247    for (idx, ch) in text[brace..].char_indices() {
248        match ch {
249            '{' => depth += 1,
250            '}' => {
251                depth -= 1;
252                if depth == 0 {
253                    end = Some(brace + idx);
254                    break;
255                }
256            }
257            _ => {}
258        }
259    }
260    let body = text[brace + 1..end?].trim().to_string();
261    if body.is_empty() {
262        None
263    } else {
264        Some(body)
265    }
266}
267
268/// Traduce las variables de abuild a su equivalente en el lab de takana. Substituciones SEGURAS
269/// (inequívocas): `$pkgdir`→`/out` (el DESTDIR del lab), `$pkgname`→nombre, `$pkgver`→versión.
270/// NO toca `$CBUILD/$CHOST/$srcdir/$builddir` ni `--shared`. `$CBUILD/$CHOST` los RESUELVE el lab en
271/// runtime (env con el triple nativo saneado, Etapa G Fase 3 — `takana-build`); `$srcdir/$builddir` y
272/// `--shared` quedan para el humano. `make DESTDIR="$pkgdir"` → `make DESTDIR="/out"`.
273///
274/// Además ENVUELVE el cuerpo en una función shell: abuild ejecuta `build()/package()` COMO funciones,
275/// donde `local i; …` es válido; el lab corre la fase bajo `sh -c "<cuerpo>"` plano, donde `local`
276/// fuera de función es error (rompía gzip al instalar). Envolver restaura el contexto de abuild sin
277/// tocar el sandbox ni las fases planas escritas a mano del corpus (sólo se envuelve lo importado).
278fn translate_abuild(body: &str, name: &str, version: &str) -> String {
279    let subst = body
280        .replace("${pkgdir}", "/out")
281        .replace("$pkgdir", "/out")
282        .replace("${pkgname}", name)
283        .replace("$pkgname", name)
284        .replace("${pkgver}", version)
285        .replace("$pkgver", version);
286    format!("_abuild_phase() {{\n{subst}\n}}\n_abuild_phase")
287}
288
289/// Primer hash de un bloque `sha512sums="<hash>  <fichero>\n..."`.
290fn first_sha(block: &str) -> String {
291    block
292        .split_whitespace()
293        .next()
294        .unwrap_or("")
295        .to_string()
296}
297
298/// Serializa un cuerpo multilínea como string TOML (literal multi-línea `'''…'''` si tiene saltos).
299fn toml_multiline(s: &str) -> String {
300    if s.contains('\n') {
301        format!("'''\n{s}\n'''")
302    } else {
303        format!("\"{}\"", s.replace('"', "\\\""))
304    }
305}
306
307#[cfg(test)]
308mod tests {
309    use super::*;
310
311    const APKBUILD_PATCHED: &str = r#"
312pkgname=foo
313pkgver=2.5
314pkgrel=1
315url="https://example.com/foo"
316makedepends="zlib-dev openssl-dev linux-headers"
317depends="bar"
318source="https://example.com/foo-$pkgver.tar.gz
319	foo-musl-fix.patch
320	foo-static.patch
321	"
322sha512sums="abc123  foo-2.5.tar.gz"
323
324build() {
325	./configure --prefix=/usr
326	make
327}
328
329package() {
330	make DESTDIR="$pkgdir" install
331}
332"#;
333
334    #[test]
335    fn extracts_source_patches_deps_phases() {
336        let toml = recipe_from_apkbuild(APKBUILD_PATCHED).unwrap();
337        let recipe = takana_core::Recipe::from_toml(&toml).expect("recipe válida");
338        assert_eq!(recipe.name, "foo");
339        assert_eq!(recipe.version, "2.5");
340        // tarball con $pkgver expandido:
341        assert_eq!(recipe.source.tarball.as_deref(), Some("https://example.com/foo-2.5.tar.gz"));
342        // LOS PARCHES DE MUSL cargados (el punto central):
343        assert_eq!(recipe.source.patches, vec!["foo-musl-fix.patch", "foo-static.patch"]);
344        // build-deps: SÓLO makedepends, sin `-dev`. El runtime `depends="bar"` NO entra como
345        // build-dep (rompería `hammer build`); queda como comentario de provenance.
346        assert!(recipe.deps.build.contains(&"zlib".to_string()));
347        assert!(recipe.deps.build.contains(&"openssl".to_string()));
348        assert!(recipe.deps.build.contains(&"linux-headers".to_string()));
349        assert!(!recipe.deps.build.contains(&"bar".to_string()), "depends de runtime no es build-dep");
350        assert!(toml.contains("# depends de runtime de Alpine (NO build-deps): bar"), "provenance: {toml}");
351        // fases capturadas de build()/package() y TRADUCIDAS: $pkgdir → /out.
352        assert!(recipe.build.phases.compile.as_deref().unwrap().contains("./configure"));
353        let install = recipe.build.phases.install.as_deref().unwrap();
354        assert!(install.contains("DESTDIR=\"/out\""), "instala a /out: {install}");
355        assert!(!install.contains("$pkgdir"), "no debe quedar $pkgdir: {install}");
356    }
357
358    #[test]
359    fn translate_abuild_substitutes_vars() {
360        let body = "make DESTDIR=\"$pkgdir\" install\ncp x ${pkgdir}/usr/share/$pkgname/\necho $pkgver";
361        let t = translate_abuild(body, "foo", "2.5");
362        assert!(t.contains("DESTDIR=\"/out\""));
363        assert!(t.contains("/out/usr/share/foo/"));
364        assert!(t.contains("echo 2.5"));
365        assert!(!t.contains("$pkg"));
366    }
367
368    #[test]
369    fn translate_wraps_body_in_function_for_local() {
370        // abuild package() usa `local i;` (válido en función); el lab corre la fase plana ⇒ hay que
371        // envolverla o `local` rompe (gzip). El cuerpo queda DENTRO de la función, invocada al final.
372        let t = translate_abuild("local i; for i in a b; do mv $i /out/; done", "p", "1");
373        assert!(t.starts_with("_abuild_phase() {"), "{t}");
374        assert!(t.trim_end().ends_with("_abuild_phase"), "se invoca al final: {t}");
375        assert!(t.contains("local i;"), "el `local` se preserva dentro de la función: {t}");
376    }
377
378    #[test]
379    fn no_patches_is_empty() {
380        let apk = "pkgname=zlib\npkgver=1.3\nsource=\"https://zlib.net/zlib-$pkgver.tar.gz\"\nsha512sums=\"x  z\"\n";
381        let recipe = takana_core::Recipe::from_toml(&recipe_from_apkbuild(apk).unwrap()).unwrap();
382        assert_eq!(recipe.name, "zlib");
383        assert!(recipe.source.patches.is_empty());
384        assert_eq!(recipe.source.tarball.as_deref(), Some("https://zlib.net/zlib-1.3.tar.gz"));
385    }
386
387    #[test]
388    fn rejects_no_pkgname() {
389        assert!(recipe_from_apkbuild("pkgver=1\n").is_err());
390    }
391}