fixup

Author: apiraino

parser/src/command/relabel.rs

@@ -12,7 +12,7 @@ use std::fmt;
 #[derive(Debug, PartialEq, Eq)]
 pub struct RelabelCommand(pub Vec<LabelDelta>);
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum LabelDelta {
     Add(Label),
     Remove(Label),

parser/src/lib.rs

@@ -2,7 +2,6 @@ pub mod command;
 pub mod error;
 mod ignore_block;
 mod mentions;
-// XXX: is this necessary?
 pub mod token;
 
 pub use ignore_block::replace_all_outside_ignore_blocks;

src/config.rs

@@ -255,53 +255,41 @@ pub(crate) struct RelabelConfig {
     pub(crate) allow_unauthenticated: Vec<String>,
     // alias identifier -> labels
     #[serde(flatten)]
-    pub(crate) configs: Option<HashMap<String, RelabelRuleConfig>>,
+    pub(crate) aliases: HashMap<String, RelabelAliasConfig>,
 }
 
 impl RelabelConfig {
     pub(crate) fn retrieve_command_from_alias(&self, input: RelabelCommand) -> RelabelCommand {
         let mut deltas = vec![];
-        match &self.configs {
-            Some(configs) => {
-                // parse all tokens: if one matches an alias, extract the labels
-                // else, it will assumed to be a valid label
-                if input.0.len() > 0 {
-                    for tk in input.0.iter() {
-                        let name = tk.label().as_str();
-                        if configs.contains_key(name) {
-                            if let Some((_, cfg)) = configs.get_key_value(name) {
-                                let cmd = cfg.to_command();
-                                for d in cmd.0 {
-                                    deltas.push(d);
-                                }
-                            }
-                        } else {
-                            deltas.push(tk.clone());
-                        }
-                    }
+        if !self.aliases.is_empty() {
+            // parse all tokens: if one matches an alias, extract the labels
+            // else, it will assumed to be a valid label
+            for tk in input.0.into_iter() {
+                let name = tk.label().as_str();
+                if let Some(alias) = self.aliases.get(name) {
+                    let cmd = alias.to_command();
+                    deltas.extend(cmd.0);
+                } else {
+                    deltas.push(tk);
                 }
             }
-            None => {
-                // nothing to do, return the original command
-                return input;
-            }
-        };
+        }
         RelabelCommand(deltas)
     }
 }
 
 #[derive(Default, PartialEq, Eq, Debug, serde::Deserialize)]
 #[serde(rename_all = "kebab-case")]
 #[serde(deny_unknown_fields)]
-pub(crate) struct RelabelRuleConfig {
+pub(crate) struct RelabelAliasConfig {
     /// Labels to be added
     pub(crate) add_labels: Vec<String>,
     /// Labels to be removed
     pub(crate) rem_labels: Vec<String>,
 }
 
-impl RelabelRuleConfig {
-    /// Translate a RelabelRuleConfig into a RelabelCommand for GitHub consumption
+impl RelabelAliasConfig {
+    /// Translate a RelabelAliasConfig into a RelabelCommand for GitHub consumption
     pub fn to_command(&self) -> RelabelCommand {
         let mut deltas = Vec::new();
         for l in self.add_labels.iter() {
@@ -777,6 +765,8 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
+    use parser::error::Error;
+    use parser::token::Tokenizer;
 
     #[test]
     fn sample() {
@@ -887,7 +877,7 @@ mod tests {
             Config {
                 relabel: Some(RelabelConfig {
                     allow_unauthenticated: vec!["C-*".into()],
-                    configs: Some(HashMap::new())
+                    aliases: HashMap::new()
                 }),
                 assign: Some(AssignConfig {
                     warn_non_default_branch: WarnNonDefaultBranchConfig::Simple(false),
@@ -1098,7 +1088,7 @@ mod tests {
         let mut relabel_configs = HashMap::new();
         relabel_configs.insert(
             "to-stable".into(),
-            RelabelRuleConfig {
+            RelabelAliasConfig {
                 add_labels: vec!["regression-from-stable-to-stable".to_string()],
                 rem_labels: vec![
                     "regression-from-stable-to-beta".to_string(),
@@ -1109,12 +1099,59 @@ mod tests {
 
         let expected_cfg = RelabelConfig {
             allow_unauthenticated: vec![],
-            configs: Some(relabel_configs),
+            aliases: relabel_configs,
         };
 
         assert_eq!(config.relabel, Some(expected_cfg));
     }
 
+    #[cfg(test)]
+    fn parse<'a>(input: &'a str) -> Result<Option<Vec<LabelDelta>>, Error<'a>> {
+        let mut toks = Tokenizer::new(input);
+        Ok(RelabelCommand::parse(&mut toks)?.map(|c| c.0))
+    }
+
+    #[test]
+    fn relabel_alias() {
+        // [relabel.my-alias]
+        // add-labels = ["Alpha"]
+        // rem-labels = ["Bravo", "Charlie"]
+        let relabel_cfg = RelabelConfig {
+            allow_unauthenticated: vec![],
+            aliases: HashMap::from([(
+                "my-alias".to_string(),
+                RelabelAliasConfig {
+                    add_labels: vec!["Alpha".to_string()],
+                    rem_labels: vec!["Bravo".to_string(), "Charlie".to_string()],
+                },
+            )]),
+        };
+
+        // @triagebot label my-alias
+        let deltas = parse("label my-alias").unwrap().unwrap();
+        let new_input = relabel_cfg.retrieve_command_from_alias(RelabelCommand(deltas));
+        assert_eq!(
+            new_input,
+            RelabelCommand(vec![
+                LabelDelta::Add(Label("Alpha".into())),
+                LabelDelta::Remove(Label("Bravo".into())),
+                LabelDelta::Remove(Label("Charlie".into())),
+            ])
+        );
+
+        // @triagebot label -my-alias
+        let deltas = parse("label -my-alias").unwrap().unwrap();
+        let new_input = relabel_cfg.retrieve_command_from_alias(RelabelCommand(deltas));
+        assert_eq!(
+            new_input,
+            RelabelCommand(vec![
+                LabelDelta::Remove(Label("Alpha".into())),
+                LabelDelta::Add(Label("Bravo".into())),
+                LabelDelta::Add(Label("Charlie".into())),
+            ])
+        );
+    }
+
     #[test]
     fn issue_links_uncanonicalized() {
         let config = r#"

src/handlers/relabel.rs

@@ -31,12 +31,12 @@ pub(super) async fn handle_command(
     };
 
     // If the input matches a valid alias, read the [relabel] config.
-    // if any alias matches, extract the alias config (RelabelRuleConfig) and build a new RelabelCommand.
+    // if any alias matches, extract the alias config (RelabelAliasConfig) and build a new RelabelCommand.
     let new_input = config.retrieve_command_from_alias(input);
 
     // Check label authorization for the current user
     for delta in &new_input.0 {
-        let name = delta.label().as_str();
+        let name = delta.label() as &str;
         let err = match check_filter(name, config, is_member(&event.user(), &ctx.team).await) {
             Ok(CheckFilterResult::Allow) => None,
             Ok(CheckFilterResult::Deny) => Some(format!(
@@ -204,6 +204,7 @@ fn compute_label_deltas(deltas: &[LabelDelta]) -> (Vec<Label>, Vec<Label>) {
 #[cfg(test)]
 mod tests {
     use parser::command::relabel::{Label, LabelDelta};
+    use std::collections::HashMap;
 
     use super::{
         CheckFilterResult, MatchPatternResult, TeamMembership, check_filter, compute_label_deltas,
@@ -242,7 +243,7 @@ mod tests {
             ($($member:ident { $($label:expr => $res:ident,)* })*) => {
                 let config = RelabelConfig {
                     allow_unauthenticated: vec!["T-*".into(), "I-*".into(), "!I-*nominated".into()],
-                    configs: None
+                    aliases: HashMap::new()
                 };
                 $($(assert_eq!(
                     check_filter($label, &config, TeamMembership::$member),