Add exclude labels pattern handling

This is to support not prioritizing issues tagged with `T-rustdoc`, `T-infra` and `T-release`.

Author: spastorino

src/config.rs

@@ -81,7 +81,7 @@ pub(crate) struct PrioritizeConfig {
     #[serde(default)]
     pub(crate) prioritize_on: Vec<String>,
     #[serde(default)]
-    pub(crate) priority_labels: String,
+    pub(crate) exclude_labels: Vec<String>,
     pub(crate) zulip_stream: u64,
 }
 

src/handlers/prioritize.rs

@@ -35,22 +35,35 @@ impl Handler for PrioritizeHandler {
         if let Event::Issue(e) = event {
             if e.action == github::IssuesAction::Labeled {
                 if let Some(config) = config {
-                    if e.label.as_ref().expect("label").name == config.label {
+                    let label_name = &e.label.as_ref().expect("label").name;
+
+                    if *label_name == config.label {
                         // We need to take the exact same action in this case.
                         return Ok(Some(Prioritize::Start));
                     } else {
-                        match glob::Pattern::new(&config.priority_labels) {
-                            Ok(glob) => {
-                                let issue_labels = event.issue().unwrap().labels();
-                                let label_name = &e.label.as_ref().expect("label").name;
-
-                                if issue_labels.iter().all(|l| !glob.matches(&l.name))
-                                    && config.prioritize_on.iter().any(|l| l == label_name)
-                                {
-                                    return Ok(Some(Prioritize::Label));
+                        if config.prioritize_on.iter().any(|l| l == label_name) {
+                            let mut prioritize = false;
+
+                            for label in event.issue().unwrap().labels() {
+                                for exclude_label in &config.exclude_labels {
+                                    match glob::Pattern::new(exclude_label) {
+                                        Ok(exclude_glob) => {
+                                            prioritize = !exclude_glob.matches(&label.name);
+                                        }
+                                        Err(error) => {
+                                            log::error!("Invalid glob pattern: {}", error);
+                                        }
+                                    }
+
+                                    if !prioritize {
+                                        break;
+                                    }
                                 }
                             }
-                            Err(error) => log::error!("Invalid glob pattern: {}", error),
+
+                            if prioritize {
+                                return Ok(Some(Prioritize::Label));
+                            }
                         }
                     }
                 }