stout 0.2.0

A fast, Rust-based Homebrew-compatible package manager
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! Uses command - show packages that depend on a given package

use anyhow::{bail, Context, Result};
use stout_index::Database;
use stout_state::{InstalledPackages, Paths};
use clap::Args as ClapArgs;
use console::style;

#[derive(ClapArgs)]
pub struct Args {
    /// Formula to find dependents for
    pub formula: String,

    /// Only show installed packages that use this formula
    #[arg(long)]
    pub installed: bool,

    /// Include packages where this is a build dependency
    #[arg(long)]
    pub include_build: bool,

    /// Include packages where this is a test dependency
    #[arg(long)]
    pub include_test: bool,

    /// Include packages where this is an optional dependency
    #[arg(long)]
    pub include_optional: bool,

    /// Recursively find all dependents
    #[arg(long, short = 'r')]
    pub recursive: bool,
}

pub async fn run(args: Args) -> Result<()> {
    let paths = Paths::default();

    let db = Database::open(paths.index_db())
        .context("Failed to open index. Run 'stout update' first.")?;

    if !db.is_initialized()? {
        bail!("Index not initialized. Run 'stout update' first.");
    }

    // Verify the formula exists
    if db.get_formula(&args.formula)?.is_none() {
        bail!("Formula '{}' not found", args.formula);
    }

    let installed = InstalledPackages::load(&paths)?;

    // Find all packages that depend on this formula
    let mut dependents: Vec<String> = Vec::new();

    if args.installed {
        // Check only installed packages
        for name in installed.names() {
            let pkg = installed.get(name)
                .with_context(|| format!("package '{}' is in installed list but not found", name))?;
            if pkg.dependencies.contains(&args.formula) {
                dependents.push(name.to_string());
            }
        }
    } else {
        // Check all formulas in the index
        // This would require iterating all formulas - for now we'll check installed
        // and note this limitation
        for name in installed.names() {
            let pkg = installed.get(name)
                .with_context(|| format!("package '{}' is in installed list but not found", name))?;
            if pkg.dependencies.contains(&args.formula) {
                dependents.push(name.to_string());
            }
        }

        // Note: A full implementation would scan all formulas in the database
        // which requires a different query pattern
    }

    dependents.sort();

    if dependents.is_empty() {
        println!(
            "No {} packages depend on {}",
            if args.installed { "installed" } else { "" },
            style(&args.formula).cyan()
        );
        return Ok(());
    }

    println!(
        "{} {} {} package{} that {} {}:",
        style("==>").blue().bold(),
        dependents.len(),
        if args.installed { "installed" } else { "" },
        if dependents.len() == 1 { "" } else { "s" },
        if dependents.len() == 1 { "uses" } else { "use" },
        style(&args.formula).cyan()
    );

    for dep in &dependents {
        let version = installed
            .get(dep)
            .map(|p| p.version.as_str())
            .unwrap_or_default();
        println!(
            "  {} {} {}",
            style("•").dim(),
            dep,
            style(version).dim()
        );
    }

    Ok(())
}