muntjac 0.1.0

Translate uv.lock into Buck2 build rules
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

use std::fs;
use std::path::Path;
use std::str::FromStr;

use anyhow::{Context, Result};

use crate::cli::Globals;
use crate::cli::debug::PrintDepsArgs;
use crate::config::Config;
use crate::lock;

pub fn run(args: PrintDepsArgs, globals: &Globals) -> Result<()> {
    let cwd = globals.workdir().context("resolving working directory")?;
    let cfg_path = cwd.join("muntjac.toml");
    let cfg_bytes =
        fs::read_to_string(&cfg_path).with_context(|| format!("reading {}", cfg_path.display()))?;
    let config =
        Config::from_str(&cfg_bytes).with_context(|| format!("parsing {}", cfg_path.display()))?;
    config.validate()?;

    let tree = pick_tree(&config, args.tree.as_deref())?;

    // Resolve the lockfile path: relative to the directory containing
    // muntjac.toml, joined to (manifest_path.parent or ".").
    let cfg_dir = cfg_path.parent().unwrap_or(Path::new("."));
    let manifest_dir = cfg_dir.join(tree.manifest_path.parent().unwrap_or(Path::new("")));
    let lockfile_path = manifest_dir.join("uv.lock");
    let lock_bytes = fs::read_to_string(&lockfile_path)
        .with_context(|| format!("reading {}", lockfile_path.display()))?;
    let lockfile = lock::parser::parse(&lock_bytes)
        .with_context(|| format!("parsing {}", lockfile_path.display()))?;

    let graph = lock::graph::build(&lockfile)?;
    lock::graph::detect_cycles(&graph)?;

    let view = lock::resolved::project(&graph, &config, tree);

    let json = if args.pretty {
        serde_json::to_string_pretty(&view)?
    } else {
        serde_json::to_string(&view)?
    };
    println!("{json}");
    Ok(())
}

fn pick_tree<'a>(config: &'a Config, requested: Option<&str>) -> Result<&'a crate::config::Tree> {
    match requested {
        Some(name) => config
            .trees
            .iter()
            .find(|t| t.name == name)
            .ok_or_else(|| anyhow::anyhow!("no tree named `{name}` in muntjac.toml")),
        None => {
            if config.trees.len() == 1 {
                Ok(&config.trees[0])
            } else {
                anyhow::bail!(
                    "multi-tree config: pass --tree <name> (available: {})",
                    config
                        .trees
                        .iter()
                        .map(|t| t.name.as_str())
                        .collect::<Vec<_>>()
                        .join(", ")
                )
            }
        }
    }
}