pkgx 2.11.0

Run anything
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

mod args;
mod dump;
mod execve;
mod help;
mod query;
mod resolve;
mod spinner;
#[cfg(test)]
mod tests;
mod which;
mod x;

use execve::execve;
use libpkgx::{config::Config, sync};
use spinner::Spinner;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args::Args {
        plus,
        mut args,
        mode,
        flags,
        find_program,
    } = args::parse();

    if let Some(dir) = &flags.chdir {
        std::env::set_current_dir(dir)?;
    }

    if flags.version_n_continue {
        eprintln!("{}", get_version_string(flags.json.is_some()));
    }

    match mode {
        args::Mode::Help => {
            println!("{}", help::usage());
            Ok(())
        }
        args::Mode::Version => {
            println!("{}", get_version_string(flags.json.is_some()));
            Ok(())
        }
        args::Mode::Query => {
            let (conn, _, config, _) = setup(&flags).await?;
            query::query(&args, &flags, &conn, &config).await
        }
        args::Mode::X => {
            let (mut conn, did_sync, config, mut spinner) = setup(&flags).await?;
            let (installations, graph) = resolve::resolve(
                &mut args,
                &plus,
                find_program,
                &config,
                &mut conn,
                did_sync,
                &mut spinner,
            )
            .await?;

            if !args.is_empty() {
                let env = libpkgx::env::map(&installations);
                let (cmd, args, env) =
                    x::exec(find_program, args, installations, env, flags, conn, graph).await?;
                spinner.finish_and_clear();
                execve(cmd, args, env)?;
                Ok(())
            } else if !plus.is_empty() {
                spinner.finish_and_clear();
                dump::dump(conn, installations, &flags)?;
                Ok(())
            } else if flags.version_n_continue || flags.sync {
                Ok(())
            } else {
                spinner.finish_and_clear();
                eprintln!("{}", help::usage());
                std::process::exit(2);
            }
        }
    }
}

async fn setup(
    flags: &args::Flags,
) -> Result<(rusqlite::Connection, bool, Config, Spinner), Box<dyn std::error::Error>> {
    let config = Config::new()?;

    std::fs::create_dir_all(config.pantry_db_file.parent().unwrap())?;
    let mut conn = rusqlite::Connection::open(&config.pantry_db_file)?;

    let mut spinner = Spinner::new(flags.quiet, flags.silent);

    let did_sync = if flags.sync || sync::should(&config)? {
        spinner.set_message("syncing pkg-db…");
        sync::ensure(&config, &mut conn).await?;
        true
    } else {
        false
    };

    Ok((conn, did_sync, config, spinner))
}

fn get_version_string(json: bool) -> String {
    if !json {
        format!("pkgx {}", env!("CARGO_PKG_VERSION"))
    } else {
        format!(
            "{{\"program\": \"pkgx\", \"version\": \"{}\"}}",
            env!("CARGO_PKG_VERSION")
        )
    }
}