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,8 +2,7 @@ pub mod command;
 pub mod error;
 mod ignore_block;
 mod mentions;
-// XXX: is this necessary?
-pub mod token;
+mod token;
 
 pub use ignore_block::replace_all_outside_ignore_blocks;
 pub use mentions::get_mentions;

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() {
@@ -887,7 +875,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 +1086,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,7 +1097,7 @@ mod tests {
 
         let expected_cfg = RelabelConfig {
             allow_unauthenticated: vec![],
-            configs: Some(relabel_configs),
+            aliases: relabel_configs,
         };
 
         assert_eq!(config.relabel, Some(expected_cfg));

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),