Parse deps name to package name first and after that remove dependency

src/cli/remove.rs

@@ -2,18 +2,18 @@ use std::path::PathBuf;
 use std::str::FromStr;
 
 use clap::Parser;
-use rattler_conda_types::{NamelessMatchSpec, PackageName, Platform};
+use miette::miette;
+use rattler_conda_types::Platform;
 
 use crate::environment::LockFileUsage;
-use crate::project::python::PyPiRequirement;
-use crate::{environment::get_up_to_date_prefix, project::SpecType, Project};
+use crate::{consts, environment::get_up_to_date_prefix, 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<PackageName>,
+    pub deps: Vec<String>,
 
     /// The path to 'pixi.toml'
     #[arg(long)]
@@ -36,10 +36,16 @@ pub struct Args {
     pub platform: Option<Platform>,
 }
 
-enum DependencyRemovalResult {
-    Conda(miette::Result<(String, NamelessMatchSpec)>),
-    PyPi(miette::Result<(rip::types::PackageName, PyPiRequirement)>),
-    Error(miette::Report),
+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<()> {
@@ -53,76 +59,55 @@ pub async fn execute(args: Args) -> miette::Result<()> {
         SpecType::Run
     };
 
-    let results = deps
-        .iter()
-        .map(|dep| {
-            if args.pypi {
-                match rip::types::PackageName::from_str(dep.as_source()) {
-                    Ok(pkg_name) => {
-                        if let Some(p) = &args.platform {
-                            DependencyRemovalResult::PyPi(
-                                project.manifest.remove_target_pypi_dependency(&pkg_name, p),
-                            )
-                        } else {
-                            DependencyRemovalResult::PyPi(
-                                project.manifest.remove_pypi_dependency(&pkg_name),
-                            )
-                        }
-                    }
-                    Err(e) => DependencyRemovalResult::Error(e.into()),
-                }
-            } else {
-                DependencyRemovalResult::Conda(if let Some(p) = &args.platform {
-                    project
-                        .manifest
-                        .remove_target_dependency(dep, &spec_type, p)
-                } else {
-                    project.manifest.remove_dependency(dep, &spec_type)
-                })
-            }
-        })
-        .collect::<Vec<DependencyRemovalResult>>();
-
-    project.save()?;
-
-    // updating prefix after removing from toml
-    let _ = get_up_to_date_prefix(&project, LockFileUsage::Update, false, None).await?;
-    let table_name = if let Some(p) = &args.platform {
-        format!("target.{}.{}", p.as_str(), spec_type.name())
+    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
+    };
+
     fn print_ok_dep_removal(pkg_name: &String, pkg_extras: &String, table_name: &String) {
         eprintln!(
             "Removed {} from [{}]",
             console::style(format!("{pkg_name} {pkg_extras}")).bold(),
             console::style(table_name).bold()
         )
     }
-    let mut all_errors: Vec<String> = Vec::new();
-    for result in results.iter() {
-        match result {
-            DependencyRemovalResult::Conda(Ok(pixi_result)) => print_ok_dep_removal(
-                &pixi_result.0.to_string(),
-                &pixi_result.1.to_string(),
-                &table_name,
-            ),
-            DependencyRemovalResult::PyPi(Ok(pypi_result)) => print_ok_dep_removal(
-                &pypi_result.0.as_str().to_string(),
-                &pypi_result.1.to_string(),
+
+    if args.pypi {
+        let all_pkg_name = convert_pkg_name::<rip::types::PackageName>(&deps)?;
+        for dep in all_pkg_name.iter() {
+            let result = if let Some(p) = &args.platform {
+                project.manifest.remove_target_pypi_dependency(dep, p)?
+            } else {
+                project.manifest.remove_pypi_dependency(dep)?
+            };
+            print_ok_dep_removal(
+                &result.0.as_str().to_string(),
+                &result.1.to_string(),
                 &table_name,
-            ),
-            DependencyRemovalResult::Conda(Err(e))
-            | DependencyRemovalResult::PyPi(Err(e))
-            | DependencyRemovalResult::Error(e) => {
-                all_errors.push(format!("{e}"));
-            }
+            );
         }
-    }
-
-    if all_errors.is_empty() {
-        Ok(())
     } else {
-        Err(miette::miette!(all_errors.join("\n")))
-    }
+        let all_pkg_name = convert_pkg_name::<rattler_conda_types::PackageName>(&deps)?;
+        for dep in all_pkg_name.iter() {
+            let result = if let Some(p) = &args.platform {
+                project
+                    .manifest
+                    .remove_target_dependency(dep, &spec_type, p)?
+            } else {
+                project.manifest.remove_dependency(dep, &spec_type)?
+            };
+            print_ok_dep_removal(&result.0, &result.1.to_string(), &table_name);
+        }
+    };
+    project.save()?;
+
+    // updating prefix after removing from toml
+    let _ = get_up_to_date_prefix(&project, LockFileUsage::Update, false, None).await?;
+    Ok(())
 }