feat: add delegation commands

Author: Sakib25800

.sqlx/query-491dd6278535e1015a8071f416a56112a153713a71af8d62917e2ff9873ecec1.json renamed to .sqlx/query-1afc103866242e2b1944b340e1db0206788b37a5cd9df052ce6d4cc636548254.json

@@ -8,4 +8,7 @@ which is by default set to `@bors`.
 | `try`              | `try`           | Start a try build based on the most recent commit from the main branch. |
 | `try parent=<sha>` | `try`           | Start a try build based on the specified parent commit `sha`.           |
 | `try cancel`       | `try`           | Cancel a running try build.                                             |
-| `p=<priority>`     | `try`           | Set the priority of a PR.                                               |
+| `p=<priority>`     | `review`        | Set the priority of a PR.                                               |
+| `delegate=<user>`  | `review`        | Delegate approval authority to a specific user.                         |
+| `delegate+`        | `review`        | Delegate approval authority to the PR author.                           |
+| `delegate-`        | `review`        | Remove any previously granted delegation.                               |

.sqlx/query-67511f5f15c07537d3d4f2d011abedd2173ab301e8a06c740b587738b140795a.json renamed to .sqlx/query-24cf4ecf74e363fbd4e3f9d4b5baaa664ec0a267d2a0258417b340979e3e3200.json

@@ -0,0 +1,2 @@
+-- Add down migration script here
+ALTER TABLE pull_request DROP COLUMN delegated_to;

.sqlx/query-255692270d8542f08c1741401256f7e326f055bc3598b444a9300d61df45fde0.json

@@ -0,0 +1,2 @@
+-- Add up migration script here
+ALTER TABLE pull_request ADD COLUMN delegated_to TEXT NULL;

.sqlx/query-51b05195690ba3b4af66c8bf33d335b1d0edead1a3da21617f8def3d42a010a8.json

@@ -16,9 +16,17 @@ pub enum Parent {
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum Approver {
-    /// The approver is the same as the comment author.
+    /// The approver is the same as the comment author: delegate+.
     Myself,
-    /// The approver is specified by the user.
+    /// The approver is specified by the user: delegate=<username>.
+    Specified(String),
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Delegatee {
+    /// The assignee is the same as the PR author.
+    Author,
+    /// The assignee is specified by the user.
     Specified(String),
 }
 
@@ -49,4 +57,8 @@ pub enum BorsCommand {
     TryCancel,
     /// Set the priority of a commit.
     SetPriority(Priority),
+    /// Delegate approval authority.
+    Delegate(Delegatee),
+    /// Revoke any previously granted delegation.
+    Undelegate,
 }

docs/commands.md

@@ -5,7 +5,7 @@ use std::collections::HashSet;
 use crate::bors::command::{Approver, BorsCommand, Parent};
 use crate::github::CommitSha;
 
-use super::Priority;
+use super::{Delegatee, Priority};
 
 const PRIORITY_NAMES: [&str; 2] = ["p", "priority"];
 
@@ -51,6 +51,8 @@ impl CommandParser {
             parser_ping,
             parser_try_cancel,
             parser_try,
+            parse_delegate_author,
+            parse_undelegate,
         ];
 
         text.lines()
@@ -86,6 +88,12 @@ impl CommandParser {
                                             }
                                         }
 
+                                        if key == "delegate" {
+                                            if let Some(result) = parse_delegate_to(&parts) {
+                                                return Some(result);
+                                            }
+                                        }
+
                                         Some(Err(CommandParseError::MissingCommand))
                                     }
                                 }
@@ -152,6 +160,7 @@ fn parse_approve_on_behalf<'a>(parts: &[CommandPart<'a>]) -> ParseResult<'a> {
         if value.is_empty() {
             return Some(Err(CommandParseError::MissingArgValue { arg: "r" }));
         }
+
         match parse_priority_arg(&parts[1..]) {
             Ok(priority) => Some(Ok(BorsCommand::Approve {
                 approver: Approver::Specified(value.to_string()),
@@ -270,6 +279,39 @@ fn parser_try_cancel<'a>(command: &'a str, parts: &[CommandPart<'a>]) -> ParseRe
     }
 }
 
+/// Parses "@bors delegate+"
+fn parse_delegate_author<'a>(command: &'a str, _parts: &[CommandPart<'a>]) -> ParseResult<'a> {
+    if command == "delegate+" {
+        Some(Ok(BorsCommand::Delegate(Delegatee::Author)))
+    } else {
+        None
+    }
+}
+
+/// Parses "@bors delegate=<username>"
+fn parse_delegate_to<'a>(parts: &[CommandPart<'a>]) -> ParseResult<'a> {
+    if let Some(CommandPart::KeyValue { value, .. }) = parts.first() {
+        if value.is_empty() {
+            return Some(Err(CommandParseError::MissingArgValue { arg: "delegate" }));
+        }
+
+        Some(Ok(BorsCommand::Delegate(Delegatee::Specified(
+            value.to_string(),
+        ))))
+    } else {
+        Some(Err(CommandParseError::MissingArgValue { arg: "delegate" }))
+    }
+}
+
+/// Parses "@bors delegate-"
+fn parse_undelegate<'a>(command: &'a str, _parts: &[CommandPart<'a>]) -> ParseResult<'a> {
+    if command == "delegate-" {
+        Some(Ok(BorsCommand::Undelegate))
+    } else {
+        None
+    }
+}
+
 /// Parses "@bors p=<priority>"
 fn parse_priority<'a>(parts: &[CommandPart<'a>]) -> ParseResult<'a> {
     // If we have more than one part, check for duplicate priority arguments
@@ -324,7 +366,7 @@ fn parse_priority_arg<'a>(parts: &[CommandPart<'a>]) -> Result<Option<u32>, Comm
 #[cfg(test)]
 mod tests {
     use crate::bors::command::parser::{CommandParseError, CommandParser};
-    use crate::bors::command::{Approver, BorsCommand, Parent};
+    use crate::bors::command::{Approver, BorsCommand, Delegatee, Parent};
     use crate::github::CommitSha;
 
     #[test]
@@ -821,6 +863,67 @@ line two
         assert!(matches!(cmds[0], Ok(BorsCommand::TryCancel)));
     }
 
+    #[test]
+    fn parse_delegate_author() {
+        let cmds = parse_commands("@bors delegate+");
+        assert_eq!(cmds.len(), 1);
+        assert!(matches!(
+            cmds[0],
+            Ok(BorsCommand::Delegate(Delegatee::Author))
+        ));
+    }
+
+    #[test]
+    fn parse_delegate_to_user() {
+        let cmds = parse_commands("@bors delegate=user1");
+        assert_eq!(cmds.len(), 1);
+        assert_eq!(
+            cmds[0],
+            Ok(BorsCommand::Delegate(Delegatee::Specified(
+                "user1".to_string()
+            )))
+        );
+    }
+
+    #[test]
+    fn parse_delegate_empty() {
+        let cmds = parse_commands("@bors delegate=");
+        assert_eq!(cmds.len(), 1);
+        insta::assert_debug_snapshot!(cmds[0], @r###"
+        Err(
+            MissingArgValue {
+                arg: "delegate",
+            },
+        )
+        "###);
+    }
+
+    #[test]
+    fn parse_undelegate() {
+        let cmds = parse_commands("@bors delegate-");
+        assert_eq!(cmds.len(), 1);
+        assert_eq!(cmds[0], Ok(BorsCommand::Undelegate));
+    }
+
+    #[test]
+    fn parse_delegate_author_unknown_arg() {
+        let cmds = parse_commands("@bors delegate+ a");
+        assert_eq!(cmds.len(), 1);
+        assert_eq!(cmds[0], Ok(BorsCommand::Delegate(Delegatee::Author)));
+    }
+
+    #[test]
+    fn parse_delegate_user_unknown_arg() {
+        let cmds = parse_commands("@bors delegate=user1 a");
+        assert_eq!(cmds.len(), 1);
+        assert_eq!(
+            cmds[0],
+            Ok(BorsCommand::Delegate(Delegatee::Specified(
+                "user1".to_string()
+            )))
+        );
+    }
+
     fn parse_commands(text: &str) -> Vec<Result<BorsCommand, CommandParseError>> {
         CommandParser::new("@bors".to_string()).parse_commands(text)
     }

migrations/20250304150656_add_delegated_to_pr.down.sql

@@ -1,4 +1,4 @@
-use crate::bors::command::{Approver, BorsCommand};
+use crate::bors::command::{Approver, BorsCommand, Delegatee};
 use crate::bors::Comment;
 use crate::bors::RepositoryState;
 use crate::github::PullRequest;
@@ -19,6 +19,9 @@ pub(super) async fn command_help(
         },
         BorsCommand::Unapprove,
         BorsCommand::SetPriority(0),
+        BorsCommand::Delegate(Delegatee::Specified("".to_string())),
+        BorsCommand::Delegate(Delegatee::Author),
+        BorsCommand::Undelegate,
         BorsCommand::Try {
             parent: None,
             jobs: vec![],
@@ -53,6 +56,15 @@ fn get_command_help(command: BorsCommand) -> String {
         BorsCommand::SetPriority(_) => {
             "`p=<priority>`: Set the priority of this PR"
         }
+        BorsCommand::Delegate(Delegatee::Specified(_)) => {
+            "`delegate=<username>`: Delegate approval authority to a specific user"
+        }
+        BorsCommand::Delegate(Delegatee::Author) => {
+            "`delegate+`: Delegate approval authority to the PR author"
+        }
+        BorsCommand::Undelegate => {
+            "`delegate-`: Remove any previously granted delegation"
+        }
         BorsCommand::Help => {
             "`help`: Print this help message"
         }
@@ -82,6 +94,9 @@ mod tests {
             - `r=<user> [p=<priority>]`: Approve this PR on behalf of `<user>`. Optionally, you can specify a `<priority>`.
             - `r-`: Unapprove this PR
             - `p=<priority>`: Set the priority of this PR
+            - `delegate=<username>`: Delegate approval authority to a specific user
+            - `delegate+`: Delegate approval authority to the PR author
+            - `delegate-`: Remove any previously granted delegation
             - `try [parent=<parent>] [jobs=<jobs>]`: Start a try build. Optionally, you can specify a `<parent>` SHA or a list of `<jobs>` to run
             - `try cancel`: Cancel a running try build
             - `ping`: Check if the bot is alive