feat: implement r+, r= and r-

migrations/20240626072340_add_approved_by_to_pr.down.sql

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

migrations/20240626072340_add_approved_by_to_pr.up.sql

@@ -0,0 +1,3 @@
+-- Add up migration script here
+ALTER TABLE pull_request ADD COLUMN approved_by TEXT;
+

rust-bors.example.toml

@@ -10,6 +10,7 @@ timeout = 3600
 # - try_failed: Try build has failed
 # (Optional)
 [labels]
+approve = ["+approved"]
 try = ["+foo", "-bar"]
 try_succeed = ["+foobar", "+foo", "+baz"]
 try_failed = []

src/bors/command/mod.rs

@@ -11,9 +11,21 @@ pub enum Parent {
     Last,
 }
 
+#[derive(Clone, Debug, PartialEq)]
+pub enum Approver {
+    /// The approver is the same as the comment author.
+    Myself,
+    /// The approver is specified by the user.
+    Specified(String),
+}
+
 /// Bors command specified by a user.
 #[derive(Debug, PartialEq)]
 pub enum BorsCommand {
+    /// Approve a commit.
+    Approve(Approver),
+    /// Unapprove a commit.
+    Unapprove,
     /// Print help
     Help,
     /// Ping the bot.

src/bors/command/parser.rs

@@ -2,7 +2,7 @@
 
 use std::collections::HashSet;
 
-use crate::bors::command::{BorsCommand, Parent};
+use crate::bors::command::{Approver, BorsCommand, Parent};
 use crate::github::CommitSha;
 
 #[derive(Debug, PartialEq)]
@@ -40,8 +40,14 @@ impl CommandParser {
         text: &'a str,
     ) -> Vec<Result<BorsCommand, CommandParseError<'a>>> {
         // The order of the parsers in the vector is important
-        let parsers: Vec<for<'b> fn(&'b str, &[CommandPart<'b>]) -> ParseResult<'b>> =
-            vec![parser_help, parser_ping, parser_try_cancel, parser_try];
+        let parsers: Vec<for<'b> fn(&'b str, &[CommandPart<'b>]) -> ParseResult<'b>> = vec![
+            parse_self_approve,
+            parse_unapprove,
+            parser_help,
+            parser_ping,
+            parser_try_cancel,
+            parser_try,
+        ];
 
         text.lines()
             .filter_map(|line| match line.find(&self.prefix) {
@@ -62,7 +68,11 @@ impl CommandParser {
                                         }
                                         Some(Err(CommandParseError::UnknownCommand(command)))
                                     }
+                                    // for `@bors r=user1`
                                     CommandPart::KeyValue { .. } => {
+                                        if let Some(result) = parse_approve_on_behalf(&parts) {
+                                            return Some(result);
+                                        }
                                         Some(Err(CommandParseError::MissingCommand))
                                     }
                                 }
@@ -108,6 +118,41 @@ fn parse_parts(input: &str) -> Result<Vec<CommandPart>, CommandParseError> {
 
 /// Parsers
 
+/// Parses "@bors r+"
+fn parse_self_approve<'a>(command: &'a str, _parts: &[CommandPart<'a>]) -> ParseResult<'a> {
+    if command == "r+" {
+        Some(Ok(BorsCommand::Approve(Approver::Myself)))
+    } else {
+        None
+    }
+}
+
+/// Parses "@bors r=<username>".
+fn parse_approve_on_behalf<'a>(parts: &[CommandPart<'a>]) -> ParseResult<'a> {
+    if let Some(CommandPart::KeyValue { key, value }) = parts.first() {
+        if *key != "r" {
+            Some(Err(CommandParseError::UnknownArg(key)))
+        } else if value.is_empty() {
+            return Some(Err(CommandParseError::MissingArgValue { arg: "r" }));
+        } else {
+            Some(Ok(BorsCommand::Approve(Approver::Specified(
+                value.to_string(),
+            ))))
+        }
+    } else {
+        Some(Err(CommandParseError::MissingArgValue { arg: "r" }))
+    }
+}
+
+/// Parses "@bors r-"
+fn parse_unapprove<'a>(command: &'a str, _parts: &[CommandPart<'a>]) -> ParseResult<'a> {
+    if command == "r-" {
+        Some(Ok(BorsCommand::Unapprove))
+    } else {
+        None
+    }
+}
+
 /// Parses "@bors help".
 fn parser_help<'a>(command: &'a str, _parts: &[CommandPart<'a>]) -> ParseResult<'a> {
     if command == "help" {
@@ -199,7 +244,7 @@ fn parser_try_cancel<'a>(command: &'a str, parts: &[CommandPart<'a>]) -> ParseRe
 #[cfg(test)]
 mod tests {
     use crate::bors::command::parser::{CommandParseError, CommandParser};
-    use crate::bors::command::{BorsCommand, Parent};
+    use crate::bors::command::{Approver, BorsCommand, Parent};
     use crate::github::CommitSha;
 
     #[test]
@@ -242,6 +287,38 @@ mod tests {
         assert!(matches!(cmds[0], Err(CommandParseError::DuplicateArg("a"))));
     }
 
+    #[test]
+    fn parse_default_approve() {
+        let cmds = parse_commands("@bors r+");
+        assert_eq!(cmds.len(), 1);
+        assert!(matches!(
+            cmds[0],
+            Ok(BorsCommand::Approve(Approver::Myself))
+        ));
+    }
+
+    #[test]
+    fn parse_approve_on_behalf() {
+        let cmds = parse_commands("@bors r=user1");
+        assert_eq!(cmds.len(), 1);
+        insta::assert_debug_snapshot!(cmds[0], @r###"
+        Ok(
+            Approve(
+                Specified(
+                    "user1",
+                ),
+            ),
+        )
+        "###);
+    }
+
+    #[test]
+    fn parse_unapprove() {
+        let cmds = parse_commands("@bors r-");
+        assert_eq!(cmds.len(), 1);
+        assert!(matches!(cmds[0], Ok(BorsCommand::Unapprove)));
+    }
+
     #[test]
     fn parse_help() {
         let cmds = parse_commands("@bors help");

src/bors/handlers/mod.rs

@@ -8,6 +8,7 @@ use crate::bors::event::{BorsGlobalEvent, BorsRepositoryEvent, PullRequestCommen
 use crate::bors::handlers::help::command_help;
 use crate::bors::handlers::ping::command_ping;
 use crate::bors::handlers::refresh::refresh_repository;
+use crate::bors::handlers::review::{command_approve, command_unapprove};
 use crate::bors::handlers::trybuild::{command_try_build, command_try_cancel, TRY_BRANCH_NAME};
 use crate::bors::handlers::workflow::{
     handle_check_suite_completed, handle_workflow_completed, handle_workflow_started,
@@ -22,6 +23,7 @@ mod help;
 mod labels;
 mod ping;
 mod refresh;
+mod review;
 mod trybuild;
 mod workflow;
 
@@ -179,6 +181,18 @@ async fn handle_comment(
                 let repo = Arc::clone(&repo);
                 let database = Arc::clone(&database);
                 let result = match command {
+                    BorsCommand::Approve(approver) => {
+                        let span = tracing::info_span!("Approve");
+                        command_approve(repo, database, &pull_request, &comment.author, &approver)
+                            .instrument(span)
+                            .await
+                    }
+                    BorsCommand::Unapprove => {
+                        let span = tracing::info_span!("Unapprove");
+                        command_unapprove(repo, database, &pull_request, &comment.author)
+                            .instrument(span)
+                            .await
+                    }
                     BorsCommand::Help => {
                         let span = tracing::info_span!("Help");
                         command_help(repo, &pull_request).instrument(span).await