Add alias for compound labels

Configure relabel command aliases from the `triagebot.toml`.
When a valid alias is parsed, it will be replaced with the labels configured.

Example configuration:
```
[relabel.cmd-alias]
add-labels = ["Foo", "Bar"]
rem-labels = ["Baz"]
```

The command `@rustbot label cmd-alias` will translate to:
```
@rustbot label +Foo +Bar -Baz
```

The command `@rustbot label -cmd-alias` will translate to:
```
@rustbot label +Baz -Foo -Bar
```

Note: self-canceling labels will be omitted.
The command `@rustbot label cmd-alias +Bar` will translate to:
```
@rustbot label -Foo -Bar
```

Author: apiraino

parser/src/lib.rs

@@ -2,7 +2,7 @@ pub mod command;
 pub mod error;
 mod ignore_block;
 mod mentions;
-mod token;
+pub mod token;
 
 pub use ignore_block::replace_all_outside_ignore_blocks;
 pub use mentions::get_mentions;

src/config.rs

@@ -256,53 +256,55 @@ 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 {
-        match &self.configs {
-            Some(configs) => {
-                dbg!(&configs);
-                // get only the first token from the command
-                // extract the "alias" from the RelabelCommand
-                if input.0.len() > 0 {
-                    let name = input.0.get(0).unwrap();
-                    let name = name.label().as_str();
-                    // check if this alias matches any RelabelRuleConfig key in our config
-                    // extract the labels and build a new command
-                    if configs.contains_key(name) {
-                        let (_alias, cfg) = configs.get_key_value(name).unwrap();
-                        return cfg.to_command();
-                    }
+        let mut deltas = vec![];
+        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(matches!(tk, LabelDelta::Remove(_)));
+                    deltas.extend(cmd.0);
+                } else {
+                    deltas.push(tk);
                 }
             }
-            None => {
-                return input;
-            }
-        };
-        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
-    pub fn to_command(&self) -> RelabelCommand {
+impl RelabelAliasConfig {
+    /// Translate a RelabelAliasConfig into a RelabelCommand for GitHub consumption
+    pub fn to_command(&self, inverted: bool) -> RelabelCommand {
         let mut deltas = Vec::new();
-        for l in self.add_labels.iter() {
+        let mut add_labels = &self.add_labels;
+        let mut rem_labels = &self.rem_labels;
+
+        // if the polarity of the alias is inverted, swap labels before parsing the command
+        if inverted {
+            std::mem::swap(&mut add_labels, &mut rem_labels);
+        }
+
+        for l in add_labels.iter() {
             deltas.push(LabelDelta::Add(Label(l.into())));
         }
-        for l in self.rem_labels.iter() {
+        for l in rem_labels.iter() {
             deltas.push(LabelDelta::Remove(Label(l.into())));
         }
         RelabelCommand(deltas)
@@ -778,6 +780,8 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
+    use parser::error::Error;
+    use parser::token::Tokenizer;
 
     #[test]
     fn sample() {
@@ -888,7 +892,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),
@@ -1087,6 +1091,82 @@ mod tests {
         );
     }
 
+    #[test]
+    fn relabel_alias_config() {
+        let config = r#"
+            [relabel.to-stable]
+            add-labels = ["regression-from-stable-to-stable"]
+            rem-labels = ["regression-from-stable-to-beta", "regression-from-stable-to-nightly"]
+        "#;
+        let config = toml::from_str::<Config>(&config).unwrap();
+
+        let mut relabel_configs = HashMap::new();
+        relabel_configs.insert(
+            "to-stable".into(),
+            RelabelAliasConfig {
+                add_labels: vec!["regression-from-stable-to-stable".to_string()],
+                rem_labels: vec![
+                    "regression-from-stable-to-beta".to_string(),
+                    "regression-from-stable-to-nightly".to_string(),
+                ],
+            },
+        );
+
+        let expected_cfg = RelabelConfig {
+            allow_unauthenticated: vec![],
+            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::Add(Label("Bravo".into())),
+                LabelDelta::Add(Label("Charlie".into())),
+                LabelDelta::Remove(Label("Alpha".into())),
+            ])
+        );
+    }
+
     #[test]
     fn issue_links_uncanonicalized() {
         let config = r#"

src/github.rs

@@ -1338,9 +1338,6 @@ impl IssuesEvent {
     }
 }
 
-#[derive(Debug, serde::Deserialize)]
-struct PullRequestEventFields {}
-
 #[derive(Debug, serde::Deserialize)]
 pub struct WorkflowRunJob {
     pub name: String,

src/handlers/relabel.rs

@@ -1,7 +1,7 @@
-//! Purpose: Allow any user to modify issue labels on GitHub via comments.
+//! Purpose: Allow any user to modify labels on GitHub issues and pull requests via comments.
 //!
-//! Labels are checked against the labels in the project; the bot does not support creating new
-//! labels.
+//! Labels are checked against the existing set in the git repository; the bot does not support
+//! creating new labels.
 //!
 //! Parsing is done in the `parser::command::relabel` module.
 //!
@@ -26,17 +26,17 @@ pub(super) async fn handle_command(
     event: &Event,
     input: RelabelCommand,
 ) -> anyhow::Result<()> {
-    let mut to_rem = vec![];
-    let mut to_add = vec![];
+    let Some(issue) = event.issue() else {
+        return user_error!("Can only add and remove labels on issues and pull requests");
+    };
 
     // 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.
-    // Discard anything after the alias.
+    // if any alias matches, extract the alias config (RelabelAliasConfig) and build a new RelabelCommand.
     let new_input = config.retrieve_command_from_alias(input);
 
-    // Parse input label command, checks permissions, built GitHub commands
+    // 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) => {
@@ -56,7 +56,7 @@ pub(super) async fn handle_command(
     }
 
     // Compute the labels to add and remove
-    let (to_add, to_remove) = compute_label_deltas(&input.0);
+    let (to_add, to_remove) = compute_label_deltas(&new_input.0);
 
     // Add labels
     if let Err(e) = issue.add_labels(&ctx.github, to_add.clone()).await {
@@ -201,6 +201,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,
@@ -239,7 +240,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),