add rot13

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rc"
-version = "0.2.2"
+version = "0.3.0"
 authors = ["Elliot Cubit <[email protected]>"]
 description = "Text encoding swiss army knife"
 edition = "2018"

README.md

@@ -73,7 +73,7 @@ base 64: "aGVsbG8gbmV0d29yaw=="
 - [x] binary
 - [ ] ascii85
 - [ ] url
-- [ ] spelling alphabet
+- [x] spelling alphabet
 
 ### Number bases
 
@@ -93,7 +93,7 @@ base 64: "aGVsbG8gbmV0d29yaw=="
 
 - [ ] caeser
 - [ ] vigenère
-- [ ] rot13
+- [x] rot13
 - [ ] substitution
 
 ### Crypto

src/codecs/codec.rs

@@ -5,4 +5,7 @@ pub trait Codec {
     fn decode(&self, s: Vec<u8>) -> Result<Vec<u8>, Error>;
     fn encode(&self, data: Vec<u8>) -> Result<String, Error>;
     fn format(&self) -> Format;
+    fn inferrable(&self) -> bool {
+        true
+    }
 }

src/codecs/mod.rs

@@ -4,5 +4,6 @@ pub mod codec;
 pub mod error;
 pub mod hex;
 pub mod raw;
+pub mod rot13;
 pub mod spelling;
 pub mod utf8;

src/codecs/rot13.rs

@@ -0,0 +1,51 @@
+use super::codec::Codec;
+use super::error::Error;
+use crate::Format;
+
+pub struct Rot13Codec {}
+
+impl Codec for Rot13Codec {
+    fn format(&self) -> Format {
+        Format::Rot13
+    }
+
+    fn decode(&self, s: Vec<u8>) -> Result<Vec<u8>, Error> {
+        String::from_utf8(s.clone())
+            .map(|s| {
+                s.to_lowercase()
+                    .chars()
+                    .map(Self::cnv)
+                    .collect::<Result<String, Error>>()
+                    .map(|s| s.into_bytes())
+            })
+            .unwrap_or(Err(Error::new("input data is not utf8".to_string())))
+    }
+
+    fn encode(&self, data: Vec<u8>) -> Result<String, Error> {
+        String::from_utf8(data.clone())
+            .map(|s| {
+                s.to_lowercase()
+                    .chars()
+                    .map(Self::cnv)
+                    .collect::<Result<String, Error>>()
+            })
+            .unwrap_or(Err(Error::new("input data is not utf8".to_string())))
+    }
+
+    fn inferrable(&self) -> bool {
+        false
+    }
+}
+
+impl Rot13Codec {
+    fn cnv(c: char) -> Result<char, Error> {
+        let val = c as u8;
+        if val >= 'a' as u8 && val <= ('z' as u8 - 13) {
+            Ok((val + 13) as char)
+        } else if val > ('z' as u8 - 13) && val <= 'z' as u8 {
+            Ok((((val + 12) % ('z' as u8)) + 'a' as u8) as char)
+        } else {
+            Ok(val as char)
+        }
+    }
+}

src/main.rs

@@ -197,11 +197,18 @@ fn decode_encode(from: &str, to: Vec<&str>, _as: &str, verbosity: u64, value: Ve
 // and inferring codecs. Order is significant.
 fn codecs_preferred_order() -> Vec<Box<dyn Codec>> {
     vec![
-        Box::new(codecs::spelling::SpellingCodec {}),
+        /*
+           Codecs that can't be assumed must be first
+        */
+        Box::new(codecs::rot13::Rot13Codec {}),
+        /*
+            Inferrable codecs
+        */
         // Rule out binary before assuming hex
         Box::new(codecs::binary::BinaryCodec {}),
         // Rule out hex before assuming base 64
         Box::new(codecs::hex::HexCodec {}),
+        Box::new(codecs::spelling::SpellingCodec {}),
         // Rule out base 64 before assuming utf8
         Box::new(codecs::base64::Base64Codec {}),
         // Rule out utf8 before assuming it's nothing

src/options.rs

@@ -12,13 +12,16 @@ pub enum Format {
     Base64,
     Binary,
     Spelling,
+    Rot13,
     Raw,
     Inferred,
 }
 
 impl Format {
     pub fn all_variants() -> Vec<&'static str> {
-        vec!["utf8", "hex", "base64", "binary", "spelling", "raw"]
+        vec![
+            "utf8", "hex", "base64", "binary", "spelling", "raw", "rot13",
+        ]
     }
 
     pub fn from_str(s: &str) -> Option<Self> {
@@ -33,6 +36,7 @@ impl Format {
             "base64" => Some(Self::Base64),
             "binary" => Some(Self::Binary),
             "spelling" => Some(Self::Spelling),
+            "rot13" => Some(Self::Rot13),
             "raw" => Some(Self::Raw),
             "__infer" => Some(Self::Inferred),
             _ => None,
@@ -51,6 +55,7 @@ impl Format {
             Self::Base64 => "base 64",
             Self::Binary => "binary",
             Self::Spelling => "spelling",
+            Self::Rot13 => "rot13",
             Self::Raw => "raw bytes",
             // This shouldn't really happen, since if we ever have an inferred enum
             // we should be converting it to a relevant one