jerome 0.1.0

Does ROT13 decoding/encoding
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use std::collections::HashMap;
use anyhow::Result;

const ROT13_MAPPING: [(char, char); 26] = [
    ('a', 'n'),
    ('b', 'o'),
    ('c', 'p'),
    ('d', 'q'),
    ('e', 'r'),
    ('f', 's'),
    ('g', 't'),
    ('h', 'u'),
    ('i', 'v'),
    ('j', 'w'),
    ('k', 'x'),
    ('l', 'y'),
    ('m', 'z'),
    ('n', 'a'),
    ('o', 'b'),
    ('p', 'c'),
    ('q', 'd'),
    ('r', 'e'),
    ('s', 'f'),
    ('t', 'g'),
    ('u', 'h'),
    ('v', 'i'),
    ('w', 'j'),
    ('x', 'k'),
    ('y', 'l'),
    ('z', 'm'),
];

pub struct Translator {
    rot13_mapping: HashMap<char, char>,
}

impl Translator {
    pub fn new() -> Translator {
        Translator{
            rot13_mapping: HashMap::from(ROT13_MAPPING),
        }
    }

    /// Encodes/decodes a given text using a ROT13 cipher. At the moment, this
    /// loses any case by default. Will likely take na option later of some kind.
    /// Basically just stores the HashMap so the creation only happens once.
    ///
    /// # Examples
    /// ```
    /// let original = "Zapper man".to_string();
    /// assert_eq!("mnccre zna".to_string(), jerome::Translator::new().rot13(&original).unwrap());
    /// ```
    pub fn rot13(&self, plaintext: &String) -> Result<String> {
        let plaintext = plaintext.to_ascii_lowercase();

        let mut translated = String::from("");

        for c in plaintext.chars() {
            if let Some(found_val) = self.rot13_mapping.get(&c) {
                translated.push(found_val.clone());
            } else {
                translated.push(c);
            }
        }

        Ok(translated)
    }
}

/// Encodes/decodes a given text using a ROT13 cipher. At the moment, this
/// loses any case by default. Will likely take na option later of some kind.
///
/// # Examples
/// ```
/// let original = "Zapper man".to_string();
/// assert_eq!("mnccre zna".to_string(), jerome::rot13(&original).unwrap());
/// ```
pub fn rot13(plaintext: &String) -> Result<String> {
    Translator::new().rot13(plaintext)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn produces_rot13() {
        let original = "Sphinx of black quartz, judge my vow.".to_owned();
        let expected = "fcuvak bs oynpx dhnegm, whqtr zl ibj.".to_owned();

        assert_eq!(expected, rot13(&original).unwrap());

        let translator = Translator::new();

        assert_eq!(expected, translator.rot13(&original).unwrap());
    }
}