Skip to main content

lockdocs_core/
lockfile.rs

1//! Lockfile and manifest parsers. Each parser is a pure function from file
2//! contents to exact versions, so they are easy to test.
3
4use crate::{norm_name, Dep, Eco};
5use serde_json::Value;
6use std::collections::{BTreeMap, HashSet};
7use std::path::Path;
8
9/// Lockfiles lockdocs reads, in priority order within an ecosystem.
10pub const LOCKFILES: &[(&str, Eco)] = &[
11    ("package-lock.json", Eco::Npm),
12    ("npm-shrinkwrap.json", Eco::Npm),
13    ("pnpm-lock.yaml", Eco::Npm),
14    ("bun.lock", Eco::Npm),
15    ("yarn.lock", Eco::Npm),
16    ("Cargo.lock", Eco::Cargo),
17    ("uv.lock", Eco::PyPI),
18    ("poetry.lock", Eco::PyPI),
19    ("pdm.lock", Eco::PyPI),
20    ("Pipfile.lock", Eco::PyPI),
21    ("go.mod", Eco::Go),
22];
23
24fn git_url(s: &str) -> bool {
25    s.contains("git+")
26        || s.contains("git://")
27        || s.contains("git@")
28        || s.contains("github:")
29        || s.contains(".git#")
30        || s.contains(".git?")
31        || s.ends_with(".git")
32}
33
34fn dep(eco: Eco, name: &str, version: &str, direct: bool, from: &str) -> Dep {
35    Dep {
36        eco,
37        name: name.to_string(),
38        version: version.trim().to_string(),
39        direct,
40        from: from.to_string(),
41    }
42}
43
44/// Parse one lockfile by file name. Returns `None` for unknown names.
45pub fn parse(file_name: &str, text: &str, dir: &Path) -> Option<anyhow::Result<Vec<Dep>>> {
46    let r = match file_name {
47        "package-lock.json" | "npm-shrinkwrap.json" => npm_lock(text, file_name),
48        "pnpm-lock.yaml" => pnpm_lock(text),
49        "bun.lock" => bun_lock(text),
50        "yarn.lock" => Ok(yarn_lock(text, &package_json_direct(dir))),
51        "Cargo.lock" => cargo_lock(text),
52        "uv.lock" => uv_lock(text),
53        "poetry.lock" | "pdm.lock" => poetry_lock(text, file_name, &pyproject_direct(dir)),
54        "Pipfile.lock" => pipfile_lock(text),
55        "go.mod" => Ok(go_mod(text)),
56        n if is_requirements(n) => Ok(requirements(text, n)),
57        _ => return None,
58    };
59    Some(r)
60}
61
62pub fn is_requirements(name: &str) -> bool {
63    name.starts_with("requirements") && name.ends_with(".txt")
64}
65
66// ---------------------------------------------------------------- npm
67
68/// Direct dependency names declared in `package.json`.
69pub fn package_json_direct(dir: &Path) -> HashSet<String> {
70    let mut out = HashSet::new();
71    if let Ok(t) = std::fs::read_to_string(dir.join("package.json")) {
72        if let Ok(v) = serde_json::from_str::<Value>(&t) {
73            collect_dep_keys(&v, &mut out);
74        }
75    }
76    out
77}
78
79fn collect_dep_keys(v: &Value, out: &mut HashSet<String>) {
80    for k in ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"] {
81        if let Some(m) = v.get(k).and_then(|m| m.as_object()) {
82            out.extend(m.keys().cloned());
83        }
84    }
85}
86
87pub fn npm_lock(text: &str, from: &str) -> anyhow::Result<Vec<Dep>> {
88    let v: Value = serde_json::from_str(text)?;
89    let mut out = Vec::new();
90    if let Some(pkgs) = v.get("packages").and_then(|p| p.as_object()) {
91        let mut direct = HashSet::new();
92        if let Some(root) = pkgs.get("") {
93            collect_dep_keys(root, &mut direct);
94        }
95        // Workspace members declare direct deps too.
96        for (k, p) in pkgs {
97            if !k.is_empty() && !k.contains("node_modules/") {
98                collect_dep_keys(p, &mut direct);
99            }
100        }
101        for (k, p) in pkgs {
102            let Some(name) = k.strip_prefix("node_modules/") else { continue };
103            if name.contains("/node_modules/") || p.get("link").and_then(|l| l.as_bool()) == Some(true) {
104                continue;
105            }
106            let Some(ver) = p.get("version").and_then(|v| v.as_str()) else { continue };
107            let name = p.get("name").and_then(|n| n.as_str()).unwrap_or(name);
108            let origin = if p.get("resolved").and_then(Value::as_str).is_some_and(git_url) || git_url(ver) {
109                format!("{from} (git)")
110            } else {
111                from.to_string()
112            };
113            out.push(dep(Eco::Npm, name, ver, direct.contains(name), &origin));
114        }
115    } else if let Some(deps) = v.get("dependencies").and_then(|d| d.as_object()) {
116        // lockfileVersion 1
117        for (name, p) in deps {
118            if let Some(ver) = p.get("version").and_then(|v| v.as_str()) {
119                let origin = if p.get("resolved").and_then(Value::as_str).is_some_and(git_url) || git_url(ver) {
120                    format!("{from} (git)")
121                } else {
122                    from.to_string()
123                };
124                out.push(dep(Eco::Npm, name, ver, true, &origin));
125            }
126        }
127        // v1 has no reliable direct marker: every top-level entry counts.
128    }
129    Ok(out)
130}
131
132fn strip_peer_suffix(v: &str) -> &str {
133    v.split('(').next().unwrap_or(v).trim()
134}
135
136/// Split `name@version` where the name may be scoped (`@a/b@1.0.0`).
137fn split_at_version(s: &str) -> Option<(&str, &str)> {
138    let start = if s.starts_with('@') { 1 } else { 0 };
139    let at = s[start..].find('@')? + start;
140    Some((&s[..at], &s[at + 1..]))
141}
142
143pub fn pnpm_lock(text: &str) -> anyhow::Result<Vec<Dep>> {
144    use yaml_rust2::{Yaml, YamlLoader};
145    let docs = YamlLoader::load_from_str(text)?;
146    let Some(doc) = docs.first() else { return Ok(Vec::new()) };
147    let mut direct: BTreeMap<String, String> = BTreeMap::new();
148    let mut read_importer = |imp: &Yaml| {
149        for sect in ["dependencies", "devDependencies", "optionalDependencies"] {
150            if let Some(h) = imp[sect].as_hash() {
151                for (k, v) in h {
152                    let Some(name) = k.as_str() else { continue };
153                    let ver = match v {
154                        Yaml::String(s) => s.clone(),
155                        Yaml::Real(s) => s.clone(),
156                        Yaml::Hash(_) => v["version"].as_str().map(String::from).unwrap_or_else(|| match &v["version"] {
157                            Yaml::Real(s) => s.clone(),
158                            _ => String::new(),
159                        }),
160                        _ => String::new(),
161                    };
162                    let ver = strip_peer_suffix(&ver).to_string();
163                    if ver.starts_with("link:") || ver.starts_with("file:") || ver.is_empty() {
164                        continue;
165                    }
166                    direct.entry(name.to_string()).or_insert(ver);
167                }
168            }
169        }
170    };
171    if let Some(imps) = doc["importers"].as_hash() {
172        for (_, imp) in imps {
173            read_importer(imp);
174        }
175    } else {
176        read_importer(doc);
177    }
178    let mut out: Vec<Dep> = Vec::new();
179    let mut seen = HashSet::new();
180    for (name, ver) in &direct {
181        // v5/v6 importers sometimes carry `/name/1.2.3` style versions.
182        let ver = ver.rsplit('/').next().unwrap_or(ver);
183        if seen.insert(format!("{name}@{ver}")) {
184            out.push(dep(Eco::Npm, name, ver, true, "pnpm-lock.yaml"));
185        }
186    }
187    let pkgs = doc["packages"].as_hash().or_else(|| doc["snapshots"].as_hash());
188    if let Some(pkgs) = pkgs {
189        for (k, _) in pkgs {
190            let Some(key) = k.as_str() else { continue };
191            let key = strip_peer_suffix(key.trim_start_matches('/'));
192            // v9/v6: name@version; v5: name/version
193            let parsed = split_at_version(key).or_else(|| {
194                let i = key.rfind('/')?;
195                Some((&key[..i], &key[i + 1..]))
196            });
197            let Some((name, ver)) = parsed else { continue };
198            let ver = strip_peer_suffix(ver);
199            if ver.contains(':') || name.is_empty() {
200                continue;
201            }
202            if seen.insert(format!("{name}@{ver}")) {
203                out.push(dep(Eco::Npm, name, ver, false, "pnpm-lock.yaml"));
204            }
205        }
206    }
207    Ok(out)
208}
209
210/// Remove trailing commas so bun's JSONC lockfile parses as JSON.
211fn strip_trailing_commas(text: &str) -> String {
212    let b = text.as_bytes();
213    let mut out = String::with_capacity(text.len());
214    let mut in_str = false;
215    let mut esc = false;
216    let mut i = 0;
217    while i < b.len() {
218        let c = b[i] as char;
219        if in_str {
220            if esc {
221                esc = false;
222            } else if c == '\\' {
223                esc = true;
224            } else if c == '"' {
225                in_str = false;
226            }
227        } else if c == '"' {
228            in_str = true;
229        } else if c == ',' {
230            let mut j = i + 1;
231            while j < b.len() && (b[j] as char).is_whitespace() {
232                j += 1;
233            }
234            if j < b.len() && (b[j] == b'}' || b[j] == b']') {
235                i += 1;
236                continue;
237            }
238        }
239        // Push the full UTF-8 char starting at i.
240        let ch = text[i..].chars().next().unwrap();
241        out.push(ch);
242        i += ch.len_utf8();
243    }
244    out
245}
246
247pub fn bun_lock(text: &str) -> anyhow::Result<Vec<Dep>> {
248    let v: Value = serde_json::from_str(&strip_trailing_commas(text))?;
249    let mut direct = HashSet::new();
250    if let Some(ws) = v.get("workspaces").and_then(|w| w.as_object()) {
251        for (_, w) in ws {
252            collect_dep_keys(w, &mut direct);
253        }
254    }
255    let mut out = Vec::new();
256    if let Some(pkgs) = v.get("packages").and_then(|p| p.as_object()) {
257        for (key, entry) in pkgs {
258            // Nested keys (`a/b`) are non-hoisted duplicates, except scoped names.
259            let nested = if key.starts_with('@') {
260                key.matches('/').count() > 1
261            } else {
262                key.contains('/')
263            };
264            if nested {
265                continue;
266            }
267            let Some(spec) = entry.get(0).and_then(|s| s.as_str()) else { continue };
268            let Some((name, ver)) = split_at_version(spec) else { continue };
269            if ver.contains(':') {
270                // workspace:, link:, github: ...
271                continue;
272            }
273            out.push(dep(Eco::Npm, name, ver, direct.contains(name), "bun.lock"));
274        }
275    }
276    Ok(out)
277}
278
279pub fn yarn_lock(text: &str, direct: &HashSet<String>) -> Vec<Dep> {
280    let mut out = Vec::new();
281    let mut seen = HashSet::new();
282    let mut names: Vec<String> = Vec::new();
283    let mut git_origin = false;
284    for line in text.lines() {
285        if line.is_empty() || line.starts_with('#') {
286            continue;
287        }
288        if !line.starts_with(' ') {
289            names.clear();
290            if line.starts_with("__metadata") {
291                continue;
292            }
293            let header = line.trim_end_matches(':');
294            git_origin = git_url(header);
295            for spec in header.split(", ") {
296                let spec = spec.trim().trim_matches('"');
297                if let Some((name, _)) = split_at_version(spec) {
298                    if !names.iter().any(|n| n == name) {
299                        names.push(name.to_string());
300                    }
301                }
302            }
303            continue;
304        }
305        let t = line.trim();
306        let ver = t.strip_prefix("version ").or_else(|| t.strip_prefix("version: "));
307        if let Some(ver) = ver {
308            let ver = ver.trim().trim_matches('"');
309            for n in &names {
310                if seen.insert(format!("{n}@{ver}")) {
311                    out.push(dep(
312                        Eco::Npm,
313                        n,
314                        ver,
315                        direct.contains(n),
316                        if git_origin { "yarn.lock (git)" } else { "yarn.lock" },
317                    ));
318                }
319            }
320            names.clear();
321        }
322    }
323    out
324}
325
326// ---------------------------------------------------------------- cargo
327
328pub fn cargo_lock(text: &str) -> anyhow::Result<Vec<Dep>> {
329    let v: toml::Table = toml::from_str(text)?;
330    let pkgs = v.get("package").and_then(|p| p.as_array()).map(Vec::as_slice).unwrap_or_default();
331    let mut direct = HashSet::new();
332    for p in pkgs {
333        if p.get("source").is_none() {
334            for d in p.get("dependencies").and_then(|d| d.as_array()).into_iter().flatten() {
335                if let Some(s) = d.as_str() {
336                    direct.insert(s.split(' ').next().unwrap_or(s).to_string());
337                }
338            }
339        }
340    }
341    let mut out = Vec::new();
342    for p in pkgs {
343        let (Some(name), Some(ver)) = (p.get("name").and_then(|n| n.as_str()), p.get("version").and_then(|n| n.as_str())) else {
344            continue;
345        };
346        let Some(src) = p.get("source").and_then(|s| s.as_str()) else { continue };
347        let from = if src.starts_with("registry+") || src.starts_with("sparse+") {
348            "Cargo.lock"
349        } else if src.starts_with("git+") {
350            "Cargo.lock (git)"
351        } else {
352            continue;
353        };
354        out.push(dep(Eco::Cargo, name, ver, direct.contains(name), from));
355    }
356    Ok(out)
357}
358
359// ---------------------------------------------------------------- python
360
361/// Requirement names from a PEP 508 string such as `pydantic[email]>=2`.
362fn req_name(s: &str) -> Option<String> {
363    let s = s.trim();
364    let end = s
365        .find(|c: char| !(c.is_ascii_alphanumeric() || c == '-' || c == '_' || c == '.'))
366        .unwrap_or(s.len());
367    if end == 0 {
368        return None;
369    }
370    Some(norm_name(Eco::PyPI, &s[..end]))
371}
372
373/// Direct dependency names from `pyproject.toml` (PEP 621, Poetry, PDM, uv groups).
374pub fn pyproject_direct(dir: &Path) -> HashSet<String> {
375    let mut out = HashSet::new();
376    let Ok(t) = std::fs::read_to_string(dir.join("pyproject.toml")) else {
377        return out;
378    };
379    let Ok(v) = toml::from_str::<toml::Table>(&t) else { return out };
380    let mut arr = |a: Option<&toml::Value>| {
381        for s in a.and_then(|a| a.as_array()).into_iter().flatten().filter_map(|x| x.as_str()) {
382            out.extend(req_name(s));
383        }
384    };
385    arr(v.get("project").and_then(|p| p.get("dependencies")));
386    if let Some(opt) = v.get("project").and_then(|p| p.get("optional-dependencies")).and_then(|o| o.as_table()) {
387        for (_, a) in opt {
388            arr(Some(a));
389        }
390    }
391    if let Some(groups) = v.get("dependency-groups").and_then(|o| o.as_table()) {
392        for (_, a) in groups {
393            arr(Some(a));
394        }
395    }
396    let poetry = v.get("tool").and_then(|t| t.get("poetry"));
397    for k in ["dependencies", "dev-dependencies"] {
398        if let Some(m) = poetry.and_then(|p| p.get(k)).and_then(|m| m.as_table()) {
399            out.extend(m.keys().map(|k| norm_name(Eco::PyPI, k)));
400        }
401    }
402    if let Some(groups) = poetry.and_then(|p| p.get("group")).and_then(|g| g.as_table()) {
403        for (_, g) in groups {
404            if let Some(m) = g.get("dependencies").and_then(|m| m.as_table()) {
405                out.extend(m.keys().map(|k| norm_name(Eco::PyPI, k)));
406            }
407        }
408    }
409    out.remove("python");
410    out
411}
412
413pub fn uv_lock(text: &str) -> anyhow::Result<Vec<Dep>> {
414    let v: toml::Table = toml::from_str(text)?;
415    let pkgs = v.get("package").and_then(|p| p.as_array()).map(Vec::as_slice).unwrap_or_default();
416    let mut direct = HashSet::new();
417    let mut local = HashSet::new();
418    for p in pkgs {
419        let src = p.get("source");
420        let is_local = src.is_some_and(|s| s.get("editable").is_some() || s.get("virtual").is_some() || s.get("directory").is_some());
421        if is_local {
422            local.insert(p.get("name").and_then(|n| n.as_str()).unwrap_or("").to_string());
423            let mut add = |a: Option<&toml::Value>| {
424                for d in a.and_then(|a| a.as_array()).into_iter().flatten() {
425                    if let Some(n) = d.get("name").and_then(|n| n.as_str()) {
426                        direct.insert(norm_name(Eco::PyPI, n));
427                    }
428                }
429            };
430            add(p.get("dependencies"));
431            for k in ["optional-dependencies", "dev-dependencies"] {
432                if let Some(t) = p.get(k).and_then(|t| t.as_table()) {
433                    for (_, a) in t {
434                        add(Some(a));
435                    }
436                }
437            }
438        }
439    }
440    let mut out = Vec::new();
441    for p in pkgs {
442        let (Some(name), Some(ver)) = (p.get("name").and_then(|n| n.as_str()), p.get("version").and_then(|n| n.as_str())) else {
443            continue;
444        };
445        if local.contains(name) {
446            continue;
447        }
448        let from = if p.get("source").is_some_and(|s| s.get("git").is_some()) {
449            "uv.lock (git)"
450        } else {
451            "uv.lock"
452        };
453        out.push(dep(Eco::PyPI, name, ver, direct.contains(&norm_name(Eco::PyPI, name)), from));
454    }
455    Ok(out)
456}
457
458pub fn poetry_lock(text: &str, from: &str, direct: &HashSet<String>) -> anyhow::Result<Vec<Dep>> {
459    let v: toml::Table = toml::from_str(text)?;
460    let mut out = Vec::new();
461    for p in v.get("package").and_then(|p| p.as_array()).into_iter().flatten() {
462        let (Some(name), Some(ver)) = (p.get("name").and_then(|n| n.as_str()), p.get("version").and_then(|n| n.as_str())) else {
463            continue;
464        };
465        let is_direct = direct.is_empty() || direct.contains(&norm_name(Eco::PyPI, name));
466        let origin = if p
467            .get("source")
468            .is_some_and(|s| s.get("git").is_some() || s.get("type").and_then(toml::Value::as_str) == Some("git"))
469        {
470            format!("{from} (git)")
471        } else {
472            from.to_string()
473        };
474        out.push(dep(Eco::PyPI, name, ver, is_direct, &origin));
475    }
476    Ok(out)
477}
478
479pub fn pipfile_lock(text: &str) -> anyhow::Result<Vec<Dep>> {
480    let v: Value = serde_json::from_str(text)?;
481    let mut out = Vec::new();
482    for sect in ["default", "develop"] {
483        for (name, p) in v.get(sect).and_then(|s| s.as_object()).into_iter().flatten() {
484            if let Some(ver) = p.get("version").and_then(|v| v.as_str()) {
485                out.push(dep(
486                    Eco::PyPI,
487                    name,
488                    ver.trim_start_matches("=="),
489                    true,
490                    if p.get("git").is_some() { "Pipfile.lock (git)" } else { "Pipfile.lock" },
491                ));
492            }
493        }
494    }
495    Ok(out)
496}
497
498/// Pinned lines (`name==1.2.3`) from a requirements file.
499pub fn requirements(text: &str, from: &str) -> Vec<Dep> {
500    let mut out = Vec::new();
501    for line in text.lines() {
502        let line = line.split(" #").next().unwrap_or(line).trim();
503        if line.is_empty() || line.starts_with('#') || line.starts_with('-') {
504            continue;
505        }
506        let line = line.split(';').next().unwrap_or(line);
507        let Some((lhs, ver)) = line.split_once("==") else { continue };
508        let name = lhs.split('[').next().unwrap_or(lhs).trim();
509        let ver = ver.trim().split([',', ' ', '\\']).next().unwrap_or("").trim_start_matches('=');
510        if !name.is_empty() && !ver.is_empty() {
511            out.push(dep(Eco::PyPI, name, ver, true, from));
512        }
513    }
514    out
515}
516
517// ---------------------------------------------------------------- go
518
519pub fn go_mod(text: &str) -> Vec<Dep> {
520    let mut out = Vec::new();
521    let mut in_block = false;
522    let mut replaced: BTreeMap<String, String> = BTreeMap::new();
523    let mut in_replace = false;
524    for raw in text.lines() {
525        let line = raw.trim();
526        if in_replace {
527            if line == ")" {
528                in_replace = false;
529            } else {
530                parse_replace(line, &mut replaced);
531            }
532            continue;
533        }
534        if let Some(r) = line.strip_prefix("replace ") {
535            if r.trim() == "(" {
536                in_replace = true;
537            } else {
538                parse_replace(r, &mut replaced);
539            }
540            continue;
541        }
542        let spec = if in_block {
543            if line == ")" {
544                in_block = false;
545                continue;
546            }
547            line
548        } else if let Some(r) = line.strip_prefix("require ") {
549            if r.trim() == "(" {
550                in_block = true;
551                continue;
552            }
553            r
554        } else {
555            continue;
556        };
557        let indirect = spec.contains("// indirect");
558        let spec = spec.split("//").next().unwrap_or(spec).trim();
559        let mut parts = spec.split_whitespace();
560        let (Some(m), Some(v)) = (parts.next(), parts.next()) else { continue };
561        out.push(dep(Eco::Go, m, v, !indirect, "go.mod"));
562    }
563    for d in &mut out {
564        if let Some(v) = replaced.get(&d.name) {
565            d.version = v.clone();
566        }
567    }
568    out
569}
570
571/// `old [v] => new v` where new is the same module: keep the version override.
572fn parse_replace(line: &str, out: &mut BTreeMap<String, String>) {
573    let Some((lhs, rhs)) = line.split_once("=>") else { return };
574    let old = lhs.split_whitespace().next().unwrap_or("");
575    let mut r = rhs.split_whitespace();
576    if let (Some(new), Some(ver)) = (r.next(), r.next()) {
577        if new == old {
578            out.insert(old.to_string(), ver.to_string());
579        }
580    }
581}
582
583#[cfg(test)]
584mod tests {
585    use super::*;
586
587    #[test]
588    fn toml_package_arrays_preserve_origins_and_direct_dependencies() {
589        let cargo = r#"version = 4
590[[package]]
591name = "workspace"
592version = "0.1.0"
593dependencies = ["registry-lib 1.2.3", "git-lib"]
594[[package]]
595name = "registry-lib"
596version = "1.2.3"
597source = "sparse+https://index.crates.io/"
598[[package]]
599name = "git-lib"
600version = "2.0.0"
601source = "git+https://github.com/example/lib#01234567"
602[[package]]
603name = "transitive"
604version = "3.0.0"
605source = "registry+https://github.com/rust-lang/crates.io-index"
606[[package]]
607name = "local"
608version = "0.1.0"
609source = "path+file:///local"
610"#;
611        assert_eq!(
612            cargo_lock(cargo).unwrap(),
613            vec![
614                dep(Eco::Cargo, "registry-lib", "1.2.3", true, "Cargo.lock"),
615                dep(Eco::Cargo, "git-lib", "2.0.0", true, "Cargo.lock (git)"),
616                dep(Eco::Cargo, "transitive", "3.0.0", false, "Cargo.lock"),
617            ]
618        );
619        let uv = r#"version = 1
620[[package]]
621name = "workspace"
622version = "0.1.0"
623source = { virtual = "." }
624dependencies = [{ name = "Registry_Lib" }]
625[package.optional-dependencies]
626extra = [{ name = "git-lib" }]
627[[package]]
628name = "editable"
629version = "0.1.0"
630source = { editable = "editable" }
631[package.dev-dependencies]
632test = [{ name = "dev-lib" }]
633[[package]]
634name = "directory"
635version = "0.1.0"
636source = { directory = "directory" }
637[[package]]
638name = "registry-lib"
639version = "1.2.3"
640source = { registry = "https://pypi.org/simple" }
641wheels = [{ url = "https://example.org/lib.whl", hash = "sha256:abc", size = 123 }]
642[[package]]
643name = "git-lib"
644version = "2.0.0"
645source = { git = "https://github.com/example/lib#01234567" }
646[[package]]
647name = "dev-lib"
648version = "3.0.0"
649[[package]]
650name = "transitive"
651version = "4.0.0"
652"#;
653        assert_eq!(
654            uv_lock(uv).unwrap(),
655            vec![
656                dep(Eco::PyPI, "registry-lib", "1.2.3", true, "uv.lock"),
657                dep(Eco::PyPI, "git-lib", "2.0.0", true, "uv.lock (git)"),
658                dep(Eco::PyPI, "dev-lib", "3.0.0", true, "uv.lock"),
659                dep(Eco::PyPI, "transitive", "4.0.0", false, "uv.lock"),
660            ]
661        );
662    }
663
664    #[test]
665    fn toml_package_arrays_handle_empty_missing_and_invalid_input() {
666        for parse in [cargo_lock, uv_lock] {
667            for text in ["", "version = 1", "package = []", "package = 1"] {
668                assert!(parse(text).unwrap().is_empty(), "{text}");
669            }
670            assert!(parse("[[package]\nname =").is_err());
671        }
672    }
673
674    #[test]
675    fn python_and_npm_git_origins_are_not_registry_releases() {
676        let uv = r#"[[package]]
677name = "git-lib"
678version = "1.2.3"
679source = { git = "https://github.com/o/r?rev=abc#01234567" }
680"#;
681        assert_eq!(uv_lock(uv).unwrap()[0].from, "uv.lock (git)");
682        let poetry = r#"[[package]]
683name = "git-lib"
684version = "1.2.3"
685[package.source]
686type = "git"
687url = "https://github.com/o/r"
688"#;
689        assert_eq!(poetry_lock(poetry, "poetry.lock", &HashSet::new()).unwrap()[0].from, "poetry.lock (git)");
690        let npm = r#"{"packages":{"node_modules/git-lib":{"version":"1.2.3","resolved":"git+https://github.com/o/r.git#abc"}}}"#;
691        assert_eq!(npm_lock(npm, "package-lock.json").unwrap()[0].from, "package-lock.json (git)");
692    }
693
694    #[test]
695    fn npm_v3() {
696        let t = r#"{"lockfileVersion":3,"packages":{"":{"dependencies":{"zod":"^3.23.0"},"devDependencies":{"@types/node":"^20"}},
697          "node_modules/zod":{"version":"3.23.8"},
698          "node_modules/@types/node":{"version":"20.1.0","dev":true},
699          "node_modules/a/node_modules/zod":{"version":"3.0.0"},
700          "node_modules/ws-pkg":{"resolved":"packages/x","link":true}}}"#;
701        let d = npm_lock(t, "package-lock.json").unwrap();
702        assert_eq!(d.len(), 2);
703        assert!(d.iter().any(|d| d.name == "zod" && d.version == "3.23.8" && d.direct));
704        assert!(d.iter().any(|d| d.name == "@types/node" && d.direct));
705    }
706
707    #[test]
708    fn pnpm_v9_and_v6() {
709        let v9 = "lockfileVersion: '9.0'\nimporters:\n  .:\n    dependencies:\n      next:\n        specifier: ^15.0.0\n        version: 15.0.3(react@19.0.0)\n      '@tanstack/react-query':\n        specifier: ^5\n        version: 5.59.0(react@19.0.0)\npackages:\n  next@15.0.3:\n    resolution: {integrity: x}\n  '@swc/helpers@0.5.13':\n    resolution: {integrity: y}\n";
710        let d = pnpm_lock(v9).unwrap();
711        assert!(d.iter().any(|d| d.name == "next" && d.version == "15.0.3" && d.direct));
712        assert!(d.iter().any(|d| d.name == "@tanstack/react-query" && d.version == "5.59.0"));
713        assert!(d.iter().any(|d| d.name == "@swc/helpers" && d.version == "0.5.13" && !d.direct));
714        let v5 = "lockfileVersion: 5.4\nspecifiers:\n  zod: ^3.0.0\ndependencies:\n  zod: 3.21.4\npackages:\n  /zod/3.21.4:\n    resolution: {integrity: z}\n";
715        let d = pnpm_lock(v5).unwrap();
716        assert_eq!(d.iter().filter(|d| d.name == "zod").count(), 1);
717        assert_eq!(d[0].version, "3.21.4");
718    }
719
720    #[test]
721    fn bun_and_yarn() {
722        let bun = r#"{
723  "lockfileVersion": 1,
724  "workspaces": { "": { "name": "app", "dependencies": { "zod": "^4.0.0", }, }, },
725  "packages": {
726    "zod": ["zod@4.1.5", "", {}, "sha512-x"],
727    "@types/react": ["@types/react@19.0.1", "", {}, "sha512-y"],
728    "a/zod": ["zod@3.0.0", "", {}, "sha512-z"],
729  }
730}"#;
731        let d = bun_lock(bun).unwrap();
732        assert_eq!(d.len(), 2);
733        assert!(d.iter().any(|d| d.name == "zod" && d.version == "4.1.5" && d.direct));
734        let y1 = "# yarn lockfile v1\n\n\"@babel/core@^7.0.0\", \"@babel/core@^7.1.0\":\n  version \"7.24.0\"\n  resolved \"x\"\n\nzod@^3.22.0:\n  version \"3.22.4\"\n";
735        let direct: HashSet<String> = ["zod".to_string()].into();
736        let d = yarn_lock(y1, &direct);
737        assert_eq!(d.len(), 2);
738        assert!(d.iter().any(|d| d.name == "@babel/core" && d.version == "7.24.0"));
739        let berry = "__metadata:\n  version: 8\n\n\"zod@npm:^3.22.0\":\n  version: 3.23.8\n  resolution: \"zod@npm:3.23.8\"\n";
740        let d = yarn_lock(berry, &direct);
741        assert_eq!(d, vec![dep(Eco::Npm, "zod", "3.23.8", true, "yarn.lock")]);
742    }
743
744    #[test]
745    fn cargo_and_python_and_go() {
746        let c = "version = 4\n[[package]]\nname = \"app\"\nversion = \"0.1.0\"\ndependencies = [\"tokio\", \"axum 0.8.1\"]\n\n[[package]]\nname = \"tokio\"\nversion = \"1.47.1\"\nsource = \"registry+https://github.com/rust-lang/crates.io-index\"\n\n[[package]]\nname = \"axum\"\nversion = \"0.8.1\"\nsource = \"registry+https://github.com/rust-lang/crates.io-index\"\n\n[[package]]\nname = \"bytes\"\nversion = \"1.0.0\"\nsource = \"registry+https://github.com/rust-lang/crates.io-index\"\n";
747        let d = cargo_lock(c).unwrap();
748        assert_eq!(d.len(), 3);
749        assert!(d.iter().any(|d| d.name == "axum" && d.direct));
750        assert!(d.iter().any(|d| d.name == "bytes" && !d.direct));
751        let g = "version = 4\n[[package]]\nname = \"app\"\nversion = \"0.1.0\"\ndependencies = [\"mygit\"]\n\n[[package]]\nname = \"mygit\"\nversion = \"0.2.0\"\nsource = \"git+https://github.com/o/r?branch=main#0123456789abcdef\"\n\n[[package]]\nname = \"local\"\nversion = \"0.1.0\"\nsource = \"path+file:///x\"\n";
752        let d = cargo_lock(g).unwrap();
753        assert_eq!(d.len(), 1);
754        assert_eq!(d[0].from, "Cargo.lock (git)");
755        assert!(d[0].direct);
756
757        let uv = "version = 1\n[[package]]\nname = \"app\"\nversion = \"0.1.0\"\nsource = { editable = \".\" }\ndependencies = [{ name = \"pydantic\" }]\n\n[[package]]\nname = \"pydantic\"\nversion = \"2.9.2\"\nsource = { registry = \"https://pypi.org/simple\" }\n\n[[package]]\nname = \"annotated-types\"\nversion = \"0.7.0\"\nsource = { registry = \"https://pypi.org/simple\" }\n";
758        let d = uv_lock(uv).unwrap();
759        assert_eq!(d.len(), 2);
760        assert!(d.iter().any(|d| d.name == "pydantic" && d.version == "2.9.2" && d.direct));
761
762        let r = requirements(
763            "pydantic==1.10.18  # pinned\nfastapi[all]==0.110.0 ; python_version>'3'\n-r other.txt\nrequests>=2\n",
764            "requirements.txt",
765        );
766        assert_eq!(r.len(), 2);
767        assert_eq!(r[1].name, "fastapi");
768
769        let g = go_mod("module x\n\ngo 1.22\n\nrequire github.com/gin-gonic/gin v1.10.0\n\nrequire (\n\tgithub.com/spf13/cobra v1.8.1\n\tgolang.org/x/sys v0.20.0 // indirect\n)\n\nreplace github.com/spf13/cobra => github.com/spf13/cobra v1.8.0\n");
770        assert_eq!(g.len(), 3);
771        assert!(g.iter().any(|d| d.name == "github.com/spf13/cobra" && d.version == "v1.8.0" && d.direct));
772        assert!(g.iter().any(|d| d.name == "golang.org/x/sys" && !d.direct));
773    }
774}