feat: Add Morse Decoder. (#212)

* Add Morse Decoder

Author: aalekhpatel07

.gitignore

@@ -6,3 +6,4 @@
 **/*.rs.bk
 Cargo.lock
 /.idea/
+.vscode

README.md

@@ -73,7 +73,7 @@ These are for demonstration purposes only.
 
 - [x] [Caesar](./src/ciphers/caesar.rs)
 - [x] [Vigenère](./src/ciphers/vigenere.rs)
-- [ ] [Morse Code](./src/ciphers/morse_code.rs)
+- [x] [Morse Code](./src/ciphers/morse_code.rs)
 - [ ] Transposition
 
 ---

src/ciphers/mod.rs

@@ -4,6 +4,6 @@ mod rot13;
 mod vigenere;
 
 pub use self::caesar::caesar;
-pub use self::morse_code::morse_code;
+pub use self::morse_code::{decode, encode};
 pub use self::rot13::rot13;
 pub use self::vigenere::vigenere;

src/ciphers/morse_code.rs

@@ -1,9 +1,11 @@
 use std::collections::HashMap;
+use std::io;
 
 const UNKNOWN_CHARACTER: &str = "........";
+const _UNKNOWN_MORSE_CHARACTER: &str = "_";
 
-pub fn morse_code(message: &str) -> String {
-    let dictionary = morse_dictionary();
+pub fn encode(message: &str) -> String {
+    let dictionary = _morse_dictionary();
     message
         .chars()
         .into_iter()
@@ -21,7 +23,7 @@ macro_rules! map {
     };
 }
 
-fn morse_dictionary() -> HashMap<&'static str, &'static str> {
+fn _morse_dictionary() -> HashMap<&'static str, &'static str> {
     map! {
         "A" => ".-",      "B" => "-...",    "C" => "-.-.",
         "D" => "-..",     "E" => ".",       "F" => "..-.",
@@ -47,14 +49,90 @@ fn morse_dictionary() -> HashMap<&'static str, &'static str> {
     }
 }
 
+fn _morse_to_alphanumeric_dictionary() -> HashMap<&'static str, &'static str> {
+    map! {
+        ".-"   =>  "A",      "-..." => "B",    "-.-." => "C",
+        "-.."  =>  "D",      "."    => "E",       "..-." => "F",
+        "--."  =>  "G",      "...." => "H",    ".." => "I",
+        ".---" =>  "J",     "-.-" => "K",     ".-.." => "L",
+        "--"   =>  "M",       "-." => "N",      "---" => "O",
+        ".--." =>  "P",     "--.-" => "Q",    ".-." => "R",
+        "..."  =>  "S",      "-" => "T",       "..-" => "U",
+        "...-" =>  "V",     ".--" => "W",     "-..-" => "X",
+        "-.--" =>  "Y",     "--.." => "Z",
+
+        ".----" => "1",    "..---" => "2",   "...--" => "3",
+        "....-" => "4",    "....." => "5",   "-...." => "6",
+        "--..." => "7",    "---.." => "8",   "----." => "9",
+        "-----" => "0",
+
+        ".-..." => "&",    ".--.-." => "@",  "---..." => ":",
+        "--..--" => ",",   ".-.-.-" => ".",  ".----." => "'",
+        ".-..-." => "\"",  "..--.." => "?",  "-..-." => "/",
+        "-...-" => "=",   ".-.-." => "+",   "-....-" => "-",
+        "-.--." => "(",   "-.--.-" => ")",  "/" => " ",
+        "-.-.--" => "!",  " " => " ",       "" => ""
+    }
+}
+
+fn _check_part(string: &str) -> bool {
+    for c in string.chars() {
+        match c {
+            '.' | '-' | ' ' => (),
+            _ => return false,
+        }
+    }
+    true
+}
+
+fn _check_all_parts(string: &str) -> bool {
+    string.split('/').all(_check_part)
+}
+
+fn _decode_token(string: &str) -> String {
+    _morse_to_alphanumeric_dictionary()
+        .get(string)
+        .unwrap_or(&_UNKNOWN_MORSE_CHARACTER)
+        .to_string()
+}
+
+fn _decode_part(string: &str) -> String {
+    string
+        .split(' ')
+        .map(_decode_token)
+        .collect::<Vec<String>>()
+        .join("")
+}
+
+/// Convert morse code to ascii.
+///
+/// Given a morse code, return the corresponding message.
+/// If the code is invalid, the undecipherable part of the code is replaced by `_`.
+pub fn decode(string: &str) -> Result<String, io::Error> {
+    if !_check_all_parts(string) {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            "Invalid morse code",
+        ));
+    }
+
+    let mut partitions: Vec<String> = vec![];
+
+    for part in string.split('/') {
+        partitions.push(_decode_part(part));
+    }
+
+    Ok(partitions.join(" "))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn encrypt_only_letters() {
         let message = "Hello Morse";
-        let cipher = morse_code(message);
+        let cipher = encode(message);
         assert_eq!(
             cipher,
             ".... . .-.. .-.. --- / -- --- .-. ... .".to_string()
@@ -64,7 +142,7 @@ mod tests {
     #[test]
     fn encrypt_letters_and_special_characters() {
         let message = "What's a great day!";
-        let cipher = morse_code(message);
+        let cipher = encode(message);
         assert_eq!(
             cipher,
             ".-- .... .- - .----. ... / .- / --. .-. . .- - / -.. .- -.-- -.-.--".to_string()
@@ -74,10 +152,47 @@ mod tests {
     #[test]
     fn encrypt_message_with_unsupported_character() {
         let message = "Error?? {}";
-        let cipher = morse_code(message);
+        let cipher = encode(message);
         assert_eq!(
             cipher,
             ". .-. .-. --- .-. ..--.. ..--.. / ........ ........".to_string()
         )
     }
+
+    #[test]
+    fn decrypt_valid_morsecode_with_spaces() {
+        let expected = "Hello Morse! How's it goin, \"eh\"?"
+            .to_string()
+            .to_uppercase();
+        let encypted = encode(&expected);
+        let result = decode(&encypted).unwrap();
+
+        assert_eq!(expected, result);
+    }
+
+    #[test]
+    fn decrypt_valid_character_set_invalid_morsecode() {
+        let expected = format!(
+            "{}{}{}{} {}",
+            _UNKNOWN_MORSE_CHARACTER,
+            _UNKNOWN_MORSE_CHARACTER,
+            _UNKNOWN_MORSE_CHARACTER,
+            _UNKNOWN_MORSE_CHARACTER,
+            _UNKNOWN_MORSE_CHARACTER,
+        );
+
+        let encypted = ".-.-.--.-.-. --------. ..---.-.-. .-.-.--.-.-. / .-.-.--.-.-.".to_string();
+        let result = decode(&encypted).unwrap();
+
+        assert_eq!(expected, result);
+    }
+
+    #[test]
+    fn decrypt_invalid_morsecode_with_spaces() {
+        let encypted = "1... . .-.. .-.. --- / -- --- .-. ... .";
+        let result = decode(encypted).map_err(|e| e.kind());
+        let expected = Err(io::ErrorKind::InvalidData);
+
+        assert_eq!(expected, result);
+    }
 }