Handle r? as assignment

    This adds parsing support for handling r? to direct assignment; anyone can do so
    on a PR to any org member.

    A future commit will add support for r? with a team.

    This does not currently auto-assign reviewers like highfive to new PRs, though.

Author: kellda

parser/src/command.rs

@@ -11,7 +11,10 @@ pub mod relabel;
 pub mod second;
 
 pub fn find_command_start(input: &str, bot: &str) -> Option<usize> {
-    input.find(&format!("@{}", bot))
+    [&format!("@{}", bot), "r?", "R?"]
+        .iter()
+        .map(|s| input.find(s))
+        .min_by_key(|i| i.unwrap_or(usize::MAX))?
 }
 
 #[derive(Debug, PartialEq)]
@@ -65,51 +68,87 @@ impl<'a> Input<'a> {
 
     fn parse_command(&mut self) -> Option<Command<'a>> {
         let mut tok = Tokenizer::new(&self.all[self.parsed..]);
-        assert_eq!(
-            tok.next_token().unwrap(),
-            Some(Token::Word(&format!("@{}", self.bot)))
-        );
-        log::info!("identified potential command");
-
+        let review = match tok.next_token() {
+            Ok(Some(Token::Word(w))) if w == &format!("@{}", self.bot) => false,
+            Ok(Some(Token::Word(w))) if w == "r" || w == "R" => true,
+            other => {
+                log::trace!("received odd review start token: {:?}", other);
+                return None;
+            }
+        };
+        
         let mut success = vec![];
-
-        let original_tokenizer = tok.clone();
-
-        success.extend(parse_single_command(
-            relabel::RelabelCommand::parse,
-            Command::Relabel,
-            &original_tokenizer,
-        ));
-        success.extend(parse_single_command(
-            assign::AssignCommand::parse,
-            Command::Assign,
-            &original_tokenizer,
-        ));
-        success.extend(parse_single_command(
-            ping::PingCommand::parse,
-            Command::Ping,
-            &original_tokenizer,
-        ));
-        success.extend(parse_single_command(
-            nominate::NominateCommand::parse,
-            Command::Nominate,
-            &original_tokenizer,
-        ));
-        success.extend(parse_single_command(
-            prioritize::PrioritizeCommand::parse,
-            Command::Prioritize,
-            &original_tokenizer,
-        ));
-        success.extend(parse_single_command(
-            second::SecondCommand::parse,
-            Command::Second,
-            &original_tokenizer,
-        ));
-        success.extend(parse_single_command(
-            glacier::GlacierCommand::parse,
-            Command::Glacier,
-            &original_tokenizer,
-        ));
+        
+        if review {
+            match tok.next_token() {
+                Ok(Some(Token::Question)) => {}
+                other => {
+                    log::trace!("received odd review start token: {:?}", other);
+                    return None;
+                }
+            }
+            log::info!("identified potential review request");
+            match tok.next_token() {
+                Ok(Some(Token::Word(w))) => {
+                    let mentions = crate::mentions::get_mentions(w);
+                    if let [a] = &mentions[..] {
+                        success.push((
+                            tok,
+                            Command::Assign(Ok(assign::AssignCommand::User {
+                                username: (*a).to_owned(),
+                            })),
+                        ));
+                    } else {
+                        log::trace!("{:?} had non-one mention: {:?}", w, mentions);
+                        return None
+                    }
+                }
+                other => {
+                    log::trace!("received odd review start token: {:?}", other);
+                    return None
+                }
+            }
+        } else {
+            log::info!("identified potential command");
+    
+            let original_tokenizer = tok.clone();
+    
+            success.extend(parse_single_command(
+                relabel::RelabelCommand::parse,
+                Command::Relabel,
+                &original_tokenizer,
+            ));
+            success.extend(parse_single_command(
+                assign::AssignCommand::parse,
+                Command::Assign,
+                &original_tokenizer,
+            ));
+            success.extend(parse_single_command(
+                ping::PingCommand::parse,
+                Command::Ping,
+                &original_tokenizer,
+            ));
+            success.extend(parse_single_command(
+                nominate::NominateCommand::parse,
+                Command::Nominate,
+                &original_tokenizer,
+            ));
+            success.extend(parse_single_command(
+                prioritize::PrioritizeCommand::parse,
+                Command::Prioritize,
+                &original_tokenizer,
+            ));
+            success.extend(parse_single_command(
+                second::SecondCommand::parse,
+                Command::Second,
+                &original_tokenizer,
+            ));
+            success.extend(parse_single_command(
+                glacier::GlacierCommand::parse,
+                Command::Glacier,
+                &original_tokenizer,
+            ));
+        }
 
         if success.len() > 1 {
             panic!(
@@ -119,6 +158,8 @@ impl<'a> Input<'a> {
             );
         }
 
+        let (mut tok, c) = success.pop()?;
+
         if self
             .code
             .overlaps_code((self.parsed)..(self.parsed + tok.position()))
@@ -128,7 +169,6 @@ impl<'a> Input<'a> {
             return None;
         }
 
-        let (mut tok, c) = success.pop()?;
         // if we errored out while parsing the command do not move the input forwards
         self.parsed += if c.is_ok() {
             tok.position()
@@ -230,3 +270,25 @@ fn move_input_along_1() {
     // don't move input along if parsing the command fails
     assert_eq!(&input.all[..input.parsed], "@bot");
 }
+
+#[test]
+fn parse_assign_review() {
+    let input = "R? @user";
+    let mut input = Input::new(input, "bot");
+    match input.next().unwrap() {
+        Command::Assign(Ok(x)) => assert_eq!(
+            x,
+            assign::AssignCommand::User {
+                username: String::from("user"),
+            }
+        ),
+        o => panic!("unknown: {:?}", o),
+    };
+}
+
+#[test]
+fn parse_assign_review_no_panic() {
+    let input = "R ?";
+    let mut input = Input::new(input, "bot");
+    assert!(input.next().is_none());
+}