Merge branch 'master' into accept-backports-from-zulip

Author: apiraino

parser/src/command/relabel.rs

@@ -102,7 +102,6 @@ fn delta_empty() {
 }
 
 impl RelabelCommand {
-    /// Parse and validate command tokens
     pub fn parse<'a>(input: &mut Tokenizer<'a>) -> Result<Option<Self>, Error<'a>> {
         let mut toks = input.clone();
 

src/agenda.rs

@@ -1,8 +1,8 @@
 use axum::response::Html;
 
 use crate::actions::{Action, Query, QueryKind, QueryMap, Step};
+use crate::errors::AppError;
 use crate::github;
-use crate::utils::AppError;
 use std::sync::Arc;
 
 pub async fn lang_http() -> axum::response::Result<Html<String>, AppError> {

src/bors.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use axum::{Json, extract::State};
 
-use crate::{db, handlers::Context, utils::AppError};
+use crate::{db, errors::AppError, handlers::Context};
 
 pub async fn bors_commit_list(
     State(ctx): State<Arc<Context>>,

src/config.rs

@@ -1,6 +1,5 @@
 use crate::changelogs::ChangelogFormat;
 use crate::github::{GithubClient, Repository};
-use parser::command::relabel::{Label, LabelDelta, RelabelCommand};
 use std::collections::{HashMap, HashSet};
 use std::fmt;
 use std::sync::{Arc, LazyLock, RwLock};
@@ -251,64 +250,10 @@ pub(crate) struct MentionsEntryConfig {
 
 #[derive(PartialEq, Eq, Debug, serde::Deserialize)]
 #[serde(rename_all = "kebab-case")]
+#[serde(deny_unknown_fields)]
 pub(crate) struct RelabelConfig {
     #[serde(default)]
     pub(crate) allow_unauthenticated: Vec<String>,
-    // alias identifier -> labels
-    #[serde(flatten)]
-    pub(crate) aliases: HashMap<String, RelabelAliasConfig>,
-}
-
-impl RelabelConfig {
-    pub(crate) fn retrieve_command_from_alias(&self, input: RelabelCommand) -> RelabelCommand {
-        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);
-                }
-            }
-        }
-        RelabelCommand(deltas)
-    }
-}
-
-#[derive(Default, PartialEq, Eq, Debug, serde::Deserialize)]
-#[serde(rename_all = "kebab-case")]
-#[serde(deny_unknown_fields)]
-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 RelabelAliasConfig {
-    /// Translate a RelabelAliasConfig into a RelabelCommand for GitHub consumption
-    fn to_command(&self, inverted: bool) -> RelabelCommand {
-        let mut deltas = Vec::new();
-        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 rem_labels.iter() {
-            deltas.push(LabelDelta::Remove(Label(l.into())));
-        }
-        RelabelCommand(deltas)
-    }
 }
 
 #[derive(PartialEq, Eq, Debug, serde::Deserialize)]
@@ -816,11 +761,11 @@ mod tests {
 
             [mentions."src/"]
             cc = ["@someone"]
-
+            
             [mentions."target/"]
             message = "This is a message."
             cc = ["@someone"]
-
+            
             [mentions."#[rustc_attr]"]
             type = "content"
             message = "This is a message."
@@ -890,7 +835,6 @@ mod tests {
             Config {
                 relabel: Some(RelabelConfig {
                     allow_unauthenticated: vec!["C-*".into()],
-                    aliases: HashMap::new()
                 }),
                 assign: Some(AssignConfig {
                     warn_non_default_branch: WarnNonDefaultBranchConfig::Simple(false),
@@ -1089,76 +1033,6 @@ 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));
-    }
-
-    #[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 = vec![LabelDelta::Add(Label("my-alias".into()))];
-        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 = vec![LabelDelta::Remove(Label("my-alias".into()))];
-        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#"
@@ -1219,36 +1093,4 @@ Multi text body with ${mcp_issue} and ${mcp_title}
             })
         );
     }
-
-    #[test]
-    fn relabel_new_config() {
-        let config = r#"
-            [relabel]
-            allow-unauthenticated = ["ABCD-*"]
-
-            [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!["ABCD-*".to_string()],
-            aliases: relabel_configs,
-        };
-
-        assert_eq!(config.relabel, Some(expected_cfg));
-    }
 }

src/errors.rs

@@ -0,0 +1,119 @@
+//! Errors handling
+
+use std::fmt;
+
+use crate::interactions::REPORT_TO;
+
+use axum::{
+    http::StatusCode,
+    response::{IntoResponse, Response},
+};
+
+/// Represent a user error.
+///
+/// The message will be shown to the user via comment posted by this bot.
+#[derive(Debug)]
+pub enum UserError {
+    /// Simple message
+    Message(String),
+    /// Unknown labels
+    UnknownLabels { labels: Vec<String> },
+    /// Invalid assignee
+    InvalidAssignee,
+}
+
+impl std::error::Error for UserError {}
+
+// NOTE: This is used to post the Github comment; make sure it's valid markdown.
+impl fmt::Display for UserError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            UserError::Message(msg) => f.write_str(msg),
+            UserError::UnknownLabels { labels } => {
+                write!(f, "Unknown labels: {}", labels.join(", "))
+            }
+            UserError::InvalidAssignee => write!(f, "invalid assignee"),
+        }
+    }
+}
+
+/// Creates a [`UserError`] with message.
+///
+/// Should be used when an handler is in error due to the user action's (not a PR,
+/// not a issue, not authorized, ...).
+///
+/// Should be used like this `return user_error!("My error message.");`.
+macro_rules! user_error {
+    ($err:expr $(,)?) => {
+        anyhow::Result::Err(anyhow::anyhow!(crate::errors::UserError::Message(
+            $err.into()
+        )))
+    };
+}
+
+// export the macro
+pub(crate) use user_error;
+
+/// Represent a application error.
+///
+/// Useful for returning a error via the API
+pub struct AppError(anyhow::Error);
+
+impl IntoResponse for AppError {
+    fn into_response(self) -> Response {
+        tracing::error!("{:?}", &self.0);
+        (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Something went wrong: {}\n\n{REPORT_TO}", self.0),
+        )
+            .into_response()
+    }
+}
+
+impl<E> From<E> for AppError
+where
+    E: Into<anyhow::Error>,
+{
+    fn from(err: E) -> Self {
+        AppError(err.into())
+    }
+}
+
+/// Represent an error when trying to assign someone
+#[derive(Debug)]
+pub enum AssignmentError {
+    InvalidAssignee,
+    Other(anyhow::Error),
+}
+
+// NOTE: This is used to post the Github comment; make sure it's valid markdown.
+impl fmt::Display for AssignmentError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            AssignmentError::InvalidAssignee => write!(f, "invalid assignee"),
+            AssignmentError::Other(err) => write!(f, "{err}"),
+        }
+    }
+}
+
+impl From<AssignmentError> for anyhow::Error {
+    fn from(a: AssignmentError) -> Self {
+        match a {
+            AssignmentError::InvalidAssignee => UserError::InvalidAssignee.into(),
+            AssignmentError::Other(err) => err.context("assignment error"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn display_labels() {
+        let x = UserError::UnknownLabels {
+            labels: vec!["A-bootstrap".into(), "xxx".into()],
+        };
+        assert_eq!(x.to_string(), "Unknown labels: A-bootstrap, xxx");
+    }
+}

src/gh_changes_since.rs

@@ -7,11 +7,7 @@ use axum::{
 };
 use hyper::StatusCode;
 
-use crate::{
-    github,
-    handlers::Context,
-    utils::{AppError, is_repo_autorized},
-};
+use crate::{errors::AppError, github, handlers::Context, utils::is_repo_autorized};
 
 /// Redirects to either `/gh-range-diff` (when the base changed) or to GitHub's compare
 /// page (when the base is the same).

src/gh_range_diff.rs

@@ -23,7 +23,7 @@ use unicode_segmentation::UnicodeSegmentation;
 
 use crate::github::GithubCompare;
 use crate::utils::is_repo_autorized;
-use crate::{github, handlers::Context, utils::AppError};
+use crate::{errors::AppError, github, handlers::Context};
 
 static MARKER_RE: LazyLock<Regex> =
     LazyLock::new(|| Regex::new(r"@@ -[\d]+,[\d]+ [+][\d]+,[\d]+ @@").unwrap());

src/gha_logs.rs

@@ -1,7 +1,8 @@
+use crate::errors::AppError;
 use crate::github::{self, WorkflowRunJob};
 use crate::handlers::Context;
 use crate::interactions::REPORT_TO;
-use crate::utils::{AppError, is_repo_autorized};
+use crate::utils::is_repo_autorized;
 use anyhow::Context as _;
 use axum::extract::{Path, State};
 use axum::http::HeaderValue;