pixi 0.15.2

A package management and workflow tool
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
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
116
117
118
119
120
121
122
123
124
125
126
127
128

use std::collections::HashSet;
use std::str::FromStr;

use clap::Parser;
use clap_verbosity_flag::{Level, Verbosity};
use itertools::Itertools;
use miette::IntoDiagnostic;
use rattler_conda_types::{MatchSpec, PackageName};

use crate::cli::global::install::{
    find_and_map_executable_scripts, find_designated_package, BinDir, BinEnvDir, BinScriptMapping,
};
use crate::prefix::Prefix;

/// Removes a package previously installed into a globally accessible location via `pixi global install`.
#[derive(Parser, Debug)]
#[clap(arg_required_else_help = true)]
pub struct Args {
    /// Specifies the package(s) that is to be removed.
    #[arg(num_args = 1..)]
    package: Vec<String>,
    #[command(flatten)]
    verbose: Verbosity,
}

pub async fn execute(args: Args) -> miette::Result<()> {
    // Find the MatchSpec we want to remove
    let specs = args
        .package
        .into_iter()
        .map(|package_str| MatchSpec::from_str(&package_str))
        .collect::<Result<Vec<_>, _>>()
        .into_diagnostic()?;
    let packages = specs
        .into_iter()
        .map(|spec| {
            spec.name
                .clone()
                .ok_or_else(|| miette::miette!("could not find package name in MatchSpec {}", spec))
        })
        .collect::<Result<Vec<_>, _>>()?;

    for package_name in packages {
        remove_global_package(package_name, &args.verbose).await?;
    }

    Ok(())
}

async fn remove_global_package(
    package_name: PackageName,
    verbose: &Verbosity,
) -> miette::Result<()> {
    let BinEnvDir(bin_prefix) = BinEnvDir::from_existing(&package_name).await?;
    let prefix = Prefix::new(bin_prefix.clone());

    // Find the installed package in the environment
    let prefix_package = find_designated_package(&prefix, &package_name).await?;

    // Construct the paths to all the installed package executables, which are what we need to remove.
    let paths_to_remove: Vec<_> =
        find_and_map_executable_scripts(&prefix, &prefix_package, &BinDir::from_existing().await?)
            .await?
            .into_iter()
            .map(
                |BinScriptMapping {
                     global_binary_path: path,
                     ..
                 }| path,
            )
            // Collecting to a HashSet first is a workaround for issue #317 and can be removed
            // once that is fixed.
            .collect::<HashSet<_>>()
            .into_iter()
            .collect();

    let dirs_to_remove: Vec<_> = vec![bin_prefix];

    if verbose.log_level().unwrap_or(Level::Error) >= Level::Warn {
        let whitespace = console::Emoji("  ", "").to_string();
        let names_to_remove = dirs_to_remove
            .iter()
            .map(|dir| dir.to_string_lossy())
            .chain(paths_to_remove.iter().map(|path| path.to_string_lossy()))
            .join(&format!("\n{whitespace} -  "));

        eprintln!(
            "{} Removing the following files and directories:\n{whitespace} -  {names_to_remove}",
            console::style("!").yellow().bold(),
        )
    }

    let mut errors = vec![];

    for file in paths_to_remove {
        if let Err(e) = tokio::fs::remove_file(&file).await.into_diagnostic() {
            errors.push((file, e))
        }
    }

    for dir in dirs_to_remove {
        if let Err(e) = tokio::fs::remove_dir_all(&dir).await.into_diagnostic() {
            errors.push((dir, e))
        }
    }

    if errors.is_empty() {
        eprintln!(
            "{}Successfully removed global package {}",
            console::style(console::Emoji("✔ ", "")).green(),
            console::style(package_name.as_source()).bold(),
        );
    } else {
        let whitespace = console::Emoji("  ", "").to_string();
        let error_string = errors
            .into_iter()
            .map(|(file, e)| format!("{} (on {})", e, file.to_string_lossy()))
            .join(&format!("\n{whitespace} -  "));
        miette::bail!(
            "got multiple errors trying to remove global package {}:\n{} -  {}",
            package_name.as_source(),
            whitespace,
            error_string,
        );
    }

    Ok(())
}