refactor sarcastifybot

src/main.rs

@@ -4,6 +4,85 @@ use dotenv::dotenv;
 use futures::StreamExt;
 use telegram_bot::*;
 
+/// Returns two versions of AlTeRnAtInG case equivalents of the given message
+/// The first result contains the a version beginning with an uppercase letter,
+/// the second result begins with a lowercase letter.
+///
+/// # Arguments
+///
+/// * `message` - A string slice that contains the message to convert
+fn generate_alternate_case(message: &str) -> (String, String) {
+    let mut option1 = String::new();
+    let mut option2 = String::new();
+
+    let mut stream = message.chars().enumerate();
+    while let Some((idx, letter)) = stream.next() {
+        if idx % 2 == 0 {
+            option1.push(letter.to_uppercase().next().unwrap());
+            option2.push(letter.to_lowercase().next().unwrap());
+        } else {
+            option1.push(letter.to_lowercase().next().unwrap());
+            option2.push(letter.to_uppercase().next().unwrap());
+        }
+    }
+
+    (option1, option2)
+}
+
+/// Generate a spaced-out version of the message.
+///
+/// # Arguments
+///
+/// * `message` - A string slice that contains the message to convert
+fn generate_spaced(message: &str) -> String
+{
+    let mut result = String::new();
+
+    let mut stream = message.chars().enumerate();
+    while let Some((_, letter)) = stream.next() {
+        result.push(letter);
+        result.push(' ');
+    }
+
+    // Trim trailing space
+    result.pop();
+    result
+}
+
+
+fn generate_responses(message: &str) -> Vec<InlineQueryResult> {
+    if message == "" {
+        return vec![];
+    }
+
+    let (option1, option2) = generate_alternate_case(message);
+    let option3 = generate_spaced(message);
+
+    vec![
+        InlineQueryResultArticle::new(
+            "altcase_1", option1.clone(), InputTextMessageContent {
+                message_text: option1,
+                parse_mode: None,
+                disable_web_page_preview: false,
+            }
+        ).into(),
+        InlineQueryResultArticle::new(
+            "altcase_2", option2.clone(), InputTextMessageContent {
+                message_text: option2,
+                parse_mode: None,
+                disable_web_page_preview: false,
+            }
+        ).into(),
+        InlineQueryResultArticle::new(
+            "spaced", option3.clone(), InputTextMessageContent {
+                message_text: option3,
+                parse_mode: None,
+                disable_web_page_preview: false,
+            }
+        ).into(),
+    ]
+}
+
 #[tokio::main]
 async fn main() {
     dotenv().ok();
@@ -20,53 +99,26 @@ async fn main() {
         };
 
         if let UpdateKind::InlineQuery(query) = update.kind {
-            let mut option1 = String::new();
+            let responses = generate_responses(&query.query);
-            let mut option2 = String::new();
+            api.send(query.answer(responses)).await.ok();
-            let mut option3 = String::new();
+        }
-            if query.query == "" {
+    }
-                api.send(query.answer(vec![])).await.ok();
-                continue;
 }
 
-            {
+#[cfg(test)]
-                let mut stream = query.query.chars().enumerate();
+mod tests {
-                while let Some((idx, letter)) = stream.next() {
+    use super::*;
-                    if idx % 2 == 0 {
+
-                        option1.push(letter.to_uppercase().next().unwrap());
+    #[test]
-                        option2.push(letter.to_lowercase().next().unwrap());
+    fn test_alternating() {
-                    } else {
+        let (option1, option2) = generate_alternate_case("This is a test");
-                        option1.push(letter.to_lowercase().next().unwrap());
+        assert_eq!(option1, "ThIs iS A TeSt");
-                        option2.push(letter.to_uppercase().next().unwrap());
+        assert_eq!(option2, "tHiS Is a tEsT");
-                    }
-                    option3.push(letter);
-                    option3.push(' ');
-                }
-                option3.pop();
     }
 
-            api.send(query.answer(vec![
+    #[test]
-                InlineQueryResultArticle::new(
+    fn test_spaced() {
-                    "1", option1.clone(), InputTextMessageContent {
+        let option = generate_spaced("This is a test");
-                        message_text: option1,
+        assert_eq!(option, "T h i s   i s   a   t e s t")
-                        parse_mode: None,
-                        disable_web_page_preview: false,
-                    }
-                ).into(),
-                InlineQueryResultArticle::new(
-                    "2", option2.clone(), InputTextMessageContent {
-                        message_text: option2,
-                        parse_mode: None,
-                        disable_web_page_preview: false,
-                    }
-                ).into(),
-                InlineQueryResultArticle::new(
-                    "3", option3.clone(), InputTextMessageContent {
-                        message_text: option3,
-                        parse_mode: None,
-                        disable_web_page_preview: false,
-                    }
-                ).into(),
-            ])).await.ok();
-        }
     }
 }