Add concern/resolve command parsing

Author: Urgau

parser/src/command.rs

@@ -5,6 +5,7 @@ use regex::Regex;
 
 pub mod assign;
 pub mod close;
+pub mod concern;
 pub mod nominate;
 pub mod note;
 pub mod ping;
@@ -25,6 +26,7 @@ pub enum Command<'a> {
     Shortcut(Result<shortcut::ShortcutCommand, Error<'a>>),
     Close(Result<close::CloseCommand, Error<'a>>),
     Note(Result<note::NoteCommand, Error<'a>>),
+    Concern(Result<concern::ConcernCommand, Error<'a>>),
     Transfer(Result<transfer::TransferCommand, Error<'a>>),
 }
 
@@ -97,6 +99,11 @@ impl<'a> Input<'a> {
             Command::Note,
             &original_tokenizer,
         ));
+        success.extend(parse_single_command(
+            concern::ConcernCommand::parse,
+            Command::Concern,
+            &original_tokenizer,
+        ));
         success.extend(parse_single_command(
             ping::PingCommand::parse,
             Command::Ping,
@@ -206,6 +213,7 @@ impl<'a> Command<'a> {
             Command::Shortcut(r) => r.is_ok(),
             Command::Close(r) => r.is_ok(),
             Command::Note(r) => r.is_ok(),
+            Command::Concern(r) => r.is_ok(),
             Command::Transfer(r) => r.is_ok(),
         }
     }
@@ -353,3 +361,27 @@ fn review_ignored() {
         assert_eq!(input.next(), None);
     }
 }
+
+#[test]
+fn concern() {
+    let input = "@bot concern this is my concern";
+    let mut input = Input::new(input, vec!["bot"]);
+    assert_eq!(
+        input.next(),
+        Some(Command::Concern(Ok(concern::ConcernCommand::Concern {
+            title: "this is my concern".to_string()
+        })))
+    );
+}
+
+#[test]
+fn resolve() {
+    let input = "@bot resolve this is my concern";
+    let mut input = Input::new(input, vec!["bot"]);
+    assert_eq!(
+        input.next(),
+        Some(Command::Concern(Ok(concern::ConcernCommand::Resolve {
+            title: "this is my concern".to_string()
+        })))
+    );
+}

parser/src/command/concern.rs

@@ -0,0 +1,48 @@
+use crate::error::Error;
+use crate::token::{Token, Tokenizer};
+use std::fmt;
+
+#[derive(PartialEq, Eq, Debug)]
+pub enum ConcernCommand {
+    Concern { title: String },
+    Resolve { title: String },
+}
+
+#[derive(PartialEq, Eq, Debug)]
+pub enum ParseError {
+    MissingTitle,
+}
+
+impl std::error::Error for ParseError {}
+impl fmt::Display for ParseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            ParseError::MissingTitle => write!(f, "missing required title"),
+        }
+    }
+}
+
+impl ConcernCommand {
+    pub fn parse<'a>(input: &mut Tokenizer<'a>) -> Result<Option<Self>, Error<'a>> {
+        let mut toks = input.clone();
+        if let Some(Token::Word(action @ ("concern" | "resolve"))) = toks.peek_token()? {
+            toks.next_token()?;
+
+            let title = toks.take_line()?.trim().to_string();
+
+            if title.is_empty() {
+                return Err(toks.error(ParseError::MissingTitle));
+            }
+
+            let command = if action == "resolve" {
+                ConcernCommand::Resolve { title }
+            } else {
+                ConcernCommand::Concern { title }
+            };
+
+            Ok(Some(command))
+        } else {
+            Ok(None)
+        }
+    }
+}