1use crate::{norm_name, Dep, Eco};
5use serde_json::Value;
6use std::collections::{BTreeMap, HashSet};
7use std::path::Path;
8
9pub 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
44pub 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
66pub 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 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 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 }
129 Ok(out)
130}
131
132fn strip_peer_suffix(v: &str) -> &str {
133 v.split('(').next().unwrap_or(v).trim()
134}
135
136fn 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 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 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
210fn 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 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 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 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
326pub 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
359fn 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
373pub 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
498pub 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
517pub 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
571fn 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}