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
129
130
131
132

use std::path::PathBuf;
use std::str::FromStr;

use clap::Parser;
use indexmap::IndexMap;
use miette::miette;
use rattler_conda_types::Platform;

use crate::environment::{get_up_to_date_prefix, LockFileUsage};
use crate::project::manifest::FeatureName;
use crate::{consts, project::SpecType, Project};

/// Remove the dependency from the project
#[derive(Debug, Default, Parser)]
pub struct Args {
    /// List of dependencies you wish to remove from the project
    #[arg(required = true)]
    pub deps: Vec<String>,

    /// The path to 'pixi.toml'
    #[arg(long)]
    pub manifest_path: Option<PathBuf>,

    /// Whether dependency is a host dependency
    #[arg(long, conflicts_with = "build")]
    pub host: bool,

    /// Whether dependency is a build dependency
    #[arg(long, conflicts_with = "host")]
    pub build: bool,

    /// Whether the dependency is a pypi package
    #[arg(long)]
    pub pypi: bool,

    /// The platform for which the dependency should be removed
    #[arg(long, short)]
    pub platform: Option<Platform>,

    /// The feature for which the dependency should be removed
    #[arg(long, short)]
    pub feature: Option<String>,
}

fn convert_pkg_name<T>(deps: &[String]) -> miette::Result<Vec<T>>
where
    T: FromStr,
{
    deps.iter()
        .map(|dep| {
            T::from_str(dep)
                .map_err(|_| miette!("Can't convert dependency name `{dep}` to package name"))
        })
        .collect()
}

pub async fn execute(args: Args) -> miette::Result<()> {
    let mut project = Project::load_or_else_discover(args.manifest_path.as_deref())?;
    let deps = args.deps;
    let spec_type = if args.host {
        SpecType::Host
    } else if args.build {
        SpecType::Build
    } else {
        SpecType::Run
    };

    let section_name: String = if args.pypi {
        consts::PYPI_DEPENDENCIES.to_string()
    } else {
        spec_type.name().to_string()
    };
    let table_name = if let Some(p) = &args.platform {
        format!("target.{}.{}", p.as_str(), section_name)
    } else {
        section_name
    };
    let feature_name = args
        .feature
        .map_or(FeatureName::Default, FeatureName::Named);

    fn format_ok_message(pkg_name: &str, pkg_extras: &str, table_name: &str) -> String {
        format!(
            "Removed {} from [{}]",
            console::style(format!("{pkg_name} {pkg_extras}")).bold(),
            console::style(table_name).bold()
        )
    }
    let mut sucessful_output: Vec<String> = Vec::with_capacity(deps.len());
    if args.pypi {
        let all_pkg_name = convert_pkg_name::<rip::types::PackageName>(&deps)?;
        for dep in all_pkg_name.iter() {
            let (name, req) =
                project
                    .manifest
                    .remove_pypi_dependency(dep, args.platform, &feature_name)?;
            sucessful_output.push(format_ok_message(
                name.as_str(),
                &req.to_string(),
                &table_name,
            ));
        }
    } else {
        let all_pkg_name = convert_pkg_name::<rattler_conda_types::PackageName>(&deps)?;
        for dep in all_pkg_name.iter() {
            let (name, req) =
                project
                    .manifest
                    .remove_dependency(dep, spec_type, args.platform, &feature_name)?;
            sucessful_output.push(format_ok_message(
                name.as_source(),
                &req.to_string(),
                &table_name,
            ));
        }
    };

    project.save()?;
    eprintln!("{}", sucessful_output.join("\n"));

    // TODO: update all environments touched by this feature defined.
    // updating prefix after removing from toml
    get_up_to_date_prefix(
        &project.default_environment(),
        LockFileUsage::Update,
        false,
        IndexMap::default(),
    )
    .await?;

    Ok(())
}