Add support for the camel case mode, instead of regular mode.

src/parser.rs

@@ -48,10 +48,11 @@ peg::parser! {
                 _ => Err("unknown mode"),
             }
         }
-        rule rmode() -> Mode = m:$("R" / "r" / "U" / "u" / "N" / "n" / "H" / "h" / "B" / "b" / "D" / "d") {?
+        rule rmode() -> Mode = m:$("R" / "r" / "U" / "u" / "N" / "n" / "C" / "H" / "h" / "B" / "b" / "D" / "d") {?
             match m.to_uppercase().as_str() {
                 "R" => Ok(Mode::Regular),
                 "N" => Ok(Mode::NoSpace),
+                "C" => Ok(Mode::NoSpaceCamel),
                 "U" => Ok(Mode::RegularUpcase),
                 "H" => Ok(Mode::Hex),
                 "B" => Ok(Mode::Base64),
@@ -233,6 +234,19 @@ mod tests {
                 comment: Some("a b c".to_string())
             })
         );
+        assert_eq!(
+            command_parser::name("ableton89 20C 98 2020-12-09 a b c"),
+            Ok(Password {
+                name: Rc::new("ableton89".to_string()),
+                parent: None,
+                prefix: None,
+                mode: Mode::NoSpaceCamel,
+                length: Some(20),
+                seq: 98,
+                date: NaiveDate::from_ymd_opt(2020, 12, 09).unwrap(),
+                comment: Some("a b c".to_string())
+            })
+        );
         assert_eq!(
             command_parser::name("ableton89 20D 2020-12-09 a b c"),
             Ok(Password {

src/password.rs

@@ -46,7 +46,7 @@ impl Password {
             (Some(n), Mode::Base64 | Mode::Base64Upcase | Mode::Hex | Mode::HexUpcase) => ("", n),
             (Some(n), _) => ("", n),
             (None, Mode::NoSpace | Mode::NoSpaceUpcase) => ("-", &0_u32),
-            (None, Mode::Base64 | Mode::Base64Upcase | Mode::Hex | Mode::HexUpcase) => ("", &0_u32),
+            (None, Mode::Base64 | Mode::Base64Upcase | Mode::Hex | Mode::HexUpcase | Mode::NoSpaceCamel) => ("", &0_u32),
             (None, _) => (" ", &0_u32),
         };
         let result = match self.mode {
@@ -54,6 +54,7 @@ impl Password {
             Mode::RegularUpcase => skey.to_words().join(sep).to_uppercase(),
             Mode::NoSpace => skey.to_words().join(sep),
             Mode::NoSpaceUpcase => skey.to_words().join(sep).to_uppercase(),
+            Mode::NoSpaceCamel => camel_case(skey.to_words()),
             Mode::Hex => skey.to_hex(),
             Mode::HexUpcase => skey.to_hex().to_uppercase(),
             Mode::Base64 => skey.to_b64(),
@@ -91,6 +92,18 @@ impl std::string::ToString for Password {
     }
 }
 
+fn camel_case(words: [&str; 6]) -> String {
+    let mut camel_case_string = String::new();
+
+    for word in words.iter() {
+        let mut chars = word.chars();
+        camel_case_string.push(chars.next().unwrap().to_uppercase().next().unwrap());
+        camel_case_string.extend(chars);
+    }
+
+    camel_case_string
+}
+
 pub fn fix_password_recursion(entry: Rc<RefCell<Password>>) {
     let mut t1 = entry.clone();
     let mut t2 = entry;
@@ -156,6 +169,8 @@ mod tests {
 
         let mut pwd = Password::new(None, "test1".to_string(), None, Mode::Regular, 99, dat, None);
         assert_eq!(pwd.encode(sec), "ross beau week held yoga anti");
+        pwd.mode = Mode::NoSpaceCamel;
+        assert_eq!(pwd.encode(sec), "RossBeauWeekHeldYogaAnti");
         pwd.mode = Mode::Decimal;
         assert_eq!(pwd.encode(sec), "1684 680 1995 1203 2046 619");
         pwd.mode = Mode::RegularUpcase;
@@ -163,6 +178,8 @@ mod tests {
         pwd.mode = Mode::Regular;
         pwd.prefix = Some("#Q3a".to_string());
         assert_eq!(pwd.encode(sec), "#Q3a ross beau week held yoga anti");
+        pwd.mode = Mode::NoSpaceCamel;
+        assert_eq!(pwd.encode(sec), "#Q3aRossBeauWeekHeldYogaAnti");
         pwd.mode = Mode::NoSpace;
         assert_eq!(pwd.encode(sec), "#Q3a-ross-beau-week-held-yoga-anti");
         pwd.mode = Mode::Base64;
@@ -178,6 +195,8 @@ mod tests {
 
         let mut pwd = Password::new(None, "test1".to_string(), Some(6), Mode::Regular, 99, dat, None);
         assert_eq!(pwd.encode(sec), "rossbe");
+        pwd.mode = Mode::NoSpaceCamel;
+        assert_eq!(pwd.encode(sec), "RossBe");
         pwd.mode = Mode::Decimal;
         assert_eq!(pwd.encode(sec), "168468");
         pwd.mode = Mode::Regular;
@@ -193,5 +212,7 @@ mod tests {
         assert_eq!(pwd.encode(sec), "#Q3a16");
         pwd.length = Some(10);
         assert_eq!(pwd.encode(sec), "#Q3a168468");
+        pwd.mode = Mode::NoSpaceCamel;
+        assert_eq!(pwd.encode(sec), "#Q3aRossBe");
     }
 }

src/structs.rs

@@ -28,6 +28,7 @@ pub enum Mode {
     RegularUpcase,
     NoSpace,
     NoSpaceUpcase,
+    NoSpaceCamel,
     Hex,
     HexUpcase,
     Base64,
@@ -45,6 +46,7 @@ impl std::fmt::Display for Mode {
                 Mode::RegularUpcase => "UR",
                 Mode::NoSpace => "N",
                 Mode::NoSpaceUpcase => "UN",
+                Mode::NoSpaceCamel => "C",
                 Mode::Hex => "H",
                 Mode::HexUpcase => "UH",
                 Mode::Base64 => "B",