Add initial parsing for merge and hold commands

Author: joulei

parser/src/command/decision.rs

@@ -8,6 +8,8 @@
 //! Command: `@bot merge`, `@bot hold`, `@bot restart`, `@bot dissent`, `@bot stabilize` or `@bot close`.
 //! ```
 
+use std::fmt;
+
 use crate::error::Error;
 use crate::token::{Token, Tokenizer};
 use postgres_types::{FromSql, ToSql};
@@ -23,20 +25,49 @@ pub struct DecisionCommand {
 
 impl DecisionCommand {
     pub fn parse<'a>(input: &mut Tokenizer<'a>) -> Result<Option<Self>, Error<'a>> {
-        if let Some(Token::Word("merge")) = input.peek_token()? {
-            Ok(Some(Self {
-                resolution: Resolution::Merge,
-                reversibility: Reversibility::Reversible,
-            }))
-        } else {
-            Ok(None)
+        let mut toks = input.clone();
+
+        match toks.peek_token()? {
+            Some(Token::Word("merge")) => {
+                command_or_error(input, &mut toks, Self {
+                    resolution: Resolution::Merge,
+                    reversibility: Reversibility::Reversible,
+                })
+            }
+            Some(Token::Word("hold")) => {
+                command_or_error(input, &mut toks, Self {
+                    resolution: Resolution::Hold,
+                    reversibility: Reversibility::Reversible,
+                })
+            }
+            _ => Ok(None),
         }
     }
 }
 
-#[derive(Debug, Eq, PartialEq)]
+fn command_or_error<'a>(input: &mut Tokenizer<'a>, toks: &mut Tokenizer<'a>, command: DecisionCommand) -> Result<Option<DecisionCommand>, Error<'a>> {
+    toks.next_token()?;
+    if let Some(Token::Dot) | Some(Token::EndOfLine) = toks.peek_token()? {
+        *input = toks.clone();
+        Ok(Some(command))
+    } else {
+        Err(toks.error(ParseError::ExpectedEnd))
+    }
+}
+
+#[derive(PartialEq, Eq, Debug)]
 pub enum ParseError {
-    InvalidFirstCommand,
+    ExpectedEnd,
+}
+
+impl std::error::Error for ParseError {}
+
+impl fmt::Display for ParseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            ParseError::ExpectedEnd => write!(f, "expected end of command"),
+        }
+    }
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, ToSql, FromSql, Eq, PartialEq)]
@@ -56,3 +87,58 @@ pub enum Resolution {
     #[postgres(name = "hold")]
     Hold,
 }
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn parse<'a>(input: &'a str) -> Result<Option<DecisionCommand>, Error<'a>> {
+        let mut toks = Tokenizer::new(input);
+        Ok(DecisionCommand::parse(&mut toks)?)
+    }
+
+    #[test]
+    fn test_correct_merge() {
+        assert_eq!(
+            parse("merge"),
+            Ok(Some(DecisionCommand {
+                resolution: Resolution::Merge,
+                reversibility: Reversibility::Reversible
+            })),
+        );
+    }
+
+    #[test]
+    fn test_correct_merge_final_dot() {
+        assert_eq!(
+            parse("merge."),
+            Ok(Some(DecisionCommand {
+                resolution: Resolution::Merge,
+                reversibility: Reversibility::Reversible
+            })),
+        );
+    }
+
+    #[test]
+    fn test_correct_hold() {
+        assert_eq!(
+            parse("hold"),
+            Ok(Some(DecisionCommand {
+                resolution: Resolution::Hold,
+                reversibility: Reversibility::Reversible
+            })),
+        );
+    }
+
+    #[test]
+    fn test_expected_end() {
+        use std::error::Error;
+        assert_eq!(
+            parse("hold my beer")
+                .unwrap_err()
+                .source()
+                .unwrap()
+                .downcast_ref(),
+            Some(&ParseError::ExpectedEnd),
+        );
+    }
+}