feat: add --priority arg to project channel add

crates/pixi_manifest/src/channel.rs

@@ -23,6 +23,16 @@
     }
 }
 
+impl From<(NamedChannelOrUrl, Option<i32>)> for PrioritizedChannel {
+    fn from((value, priority): (NamedChannelOrUrl, Option<i32>)) -> Self {
+        Self {
+            channel: value,
+            priority: priority,
+        }
+    }
+}
+
+
 pub enum TomlPrioritizedChannelStrOrMap {
     Map(PrioritizedChannel),
     Str(NamedChannelOrUrl),

crates/pixi_manifest/src/manifests/manifest.rs

@@ -9,14 +9,17 @@
 };
 
 use indexmap::{Equivalent, IndexSet};
 use itertools::Itertools;
 use miette::{miette, IntoDiagnostic, NamedSource, WrapErr};
 use pixi_spec::PixiSpec;
-use rattler_conda_types::{ChannelConfig, MatchSpec, PackageName, Platform, Version};
-use toml_edit::DocumentMut;
+use rattler_conda_types::{ChannelConfig, MatchSpec, PackageName, Platform, Version
+};
+use serde::Deserialize;
+use toml_edit::{DocumentMut, Table, Value};
 
 use crate::{
     consts,
+    channel::TomlPrioritizedChannelStrOrMap,
     error::{DependencyError, TomlError, UnknownFeature},
     manifests::{ManifestSource, TomlManifest},
     pypi::PyPiPackageName,
@@ -528,17 +531,55 @@
         let current = match feature_name {
             FeatureName::Default => &mut self.parsed.project.channels,
             FeatureName::Named(_) => self.get_or_insert_feature_mut(feature_name).channels_mut(),
         };
         let to_add: IndexSet<_> = channels.into_iter().collect();
         let new: IndexSet<_> = to_add.difference(current).cloned().collect();
+        let new_channels: IndexSet<_> = new.clone().into_iter().map(|channel| channel.channel).collect();
+
+        // clear channels with modified priority
+        current.retain(|c| ! new_channels.contains(&c.channel));
 
-        // Add the channels to the manifest
+        // Add the updated channels to the manifest
         current.extend(new.clone());
 
         // Then to the TOML document
         let channels = self.document.get_array_mut("channels", feature_name)?;
+
         for channel in new.iter() {
-            channels.push(channel.channel.to_string())
+            // lookup index for changed priority and update in-place
+            // is there an easier lookup for deserialize to use here?
+            let index = channels.iter().map(
+                |value| {
+                    let deserializer = value.to_string().trim().parse::<toml_edit::de::ValueDeserializer>().unwrap();
+                    TomlPrioritizedChannelStrOrMap::deserialize(deserializer)
+            }
+            ).position(
+                |c| match c {
+                    Ok(c) => c.into_prioritized_channel().channel == channel.channel,
+                    Err(_) => false,
+                }
+            );
+
+            // push if not found, remove & insert if found
+            let mut push = |item: Value| {
+                if index.is_some() {
+                    channels.remove(index.unwrap());
+                    channels.insert(index.unwrap(), item);
+                } else {
+                    channels.push(item);
+                }
+            };
+            match channel.priority {
+                Some(priority) => {
+                    let mut table = Table::new().into_inline_table();
+                    table.insert("channel", channel.channel.to_string().into());
+                    table.insert("priority", i64::from(priority).into());
+                    push(table.into());
+                },
+                None => {
+                    push(channel.channel.to_string().into());
+                },
+            }
         }
 
         Ok(())
@@ -564,19 +605,28 @@
                     .iter()
                     .position(|x| x.channel == c.channel)
                     .ok_or_else(|| miette::miette!("channel {} does not exist", c.channel.as_str()))
-                    .map(|_| c)
+                    .map(|_| c.channel)
             })
             .collect::<Result<_, _>>()?;
 
-        let retained: IndexSet<_> = current.difference(&to_remove).cloned().collect();
+        let retained: IndexSet<_> = current.iter().filter(
+            |channel| ! to_remove.contains(&channel.channel)).cloned().collect();
 
         // Remove channels from the manifest
         current.retain(|c| retained.contains(c));
 
         // And from the TOML document
-        let retained = retained.iter().map(|c| c.channel.as_str()).collect_vec();
         let channels = self.document.get_array_mut("channels", feature_name)?;
-        channels.retain(|x| retained.contains(&x.as_str().unwrap()));
+        channels.retain(
+            |value| {
+                let deserializer = value.to_string().trim().parse::<toml_edit::de::ValueDeserializer>().unwrap();
+                let parsed = TomlPrioritizedChannelStrOrMap::deserialize(deserializer);
+                match parsed {
+                    Ok(c) => retained.contains(&c.into_prioritized_channel()),
+                    Err(_) => false,
+                }
+            }
+        );
 
         Ok(())
     }

src/cli/project/channel/mod.rs

@@ -24,8 +24,12 @@
 pub struct AddRemoveArgs {
     /// The channel name or URL
     #[clap(required = true, num_args=1..)]
     pub channel: Vec<NamedChannelOrUrl>,
 
+    /// Specify the channel priority
+    #[clap(long, num_args=1)]
+    pub priority: Option<i32>,
+
     /// Don't update the environment, only modify the manifest and the
     /// lock-file.
     #[clap(long)]
@@ -35,10 +39,10 @@
     #[clap(long, short)]
     pub feature: Option<String>,
 }
 
 impl AddRemoveArgs {
     fn prioritized_channels(&self) -> impl IntoIterator<Item = PrioritizedChannel> + '_ {
-        self.channel.iter().cloned().map(PrioritizedChannel::from)
+        self.channel.iter().cloned().map(|channel| PrioritizedChannel::from((channel, self.priority)))
     }
 
     fn feature_name(&self) -> FeatureName {