refactor: eliminate duplicate logic in cesr-proof mod

Author: edytapawlak

cesr/src/cesr_proof/codes.rs

@@ -1,15 +1,15 @@
 use base64::URL_SAFE;
 use serde::Deserialize;
 
-use crate::derivation_code::DerivationCode;
-
-use self::codes::MaterialPathCode;
+use crate::{
+    conversion::from_bytes_to_text,
+    variable_length::{
+        LeadBytes, SmallVariableLengthCode, VariableLengthCode, VariableLengthPrimitive,
+    },
+};
 
 use super::error::Error;
 
-pub mod codes;
-pub mod parsers;
-
 #[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
 pub struct MaterialPath {
     lead_bytes: usize,
@@ -18,36 +18,47 @@ pub struct MaterialPath {
 }
 
 impl MaterialPath {
-    pub fn new(pt: MaterialPathCode, path: String) -> Self {
-        let lead_bytes = pt.lead_bytes_len();
+    pub fn new(lb: LeadBytes, path: String) -> Self {
+        let lead_bytes = match lb {
+            LeadBytes::Zero => 0,
+            LeadBytes::One => 1,
+            LeadBytes::Two => 2,
+        };
         MaterialPath {
             lead_bytes,
             base: path,
         }
     }
 
-    pub fn to_path(path: String) -> Self {
-        let len_modulo = path.len() % 4;
-        let leading_bytes = (3 - (len_modulo % 3)) % 3;
+    fn lead_bytes(&self) -> LeadBytes {
+        match self.lead_bytes {
+            0 => LeadBytes::Zero,
+            1 => LeadBytes::One,
+            2 => LeadBytes::Two,
+            _ => panic!("Invalid lead bytes"),
+        }
+    }
 
-        // fill input string with A
-        let b64path = match len_modulo {
-            0 => path,
-            n => ["A".repeat(4 - n), path].join(""),
-        };
+    pub fn create_from_str(path: String) -> Self {
+        let primitive =
+            VariableLengthPrimitive::create_from_str(SmallVariableLengthCode::Base64String, &path);
 
         Self {
-            base: b64path,
-            lead_bytes: leading_bytes,
+            base: from_bytes_to_text(primitive.value()),
+            lead_bytes: primitive.code().lead_bytes() as usize,
         }
     }
 
     pub fn to_cesr(&self) -> String {
         let decoded_base = base64::decode_config(&self.base, URL_SAFE).unwrap();
 
         let size = decoded_base.len() / 3;
-        let code = MaterialPathCode::new(self.lead_bytes, size as u16).unwrap();
-        [code.to_str(), self.base.clone()].join("")
+        let code = VariableLengthCode::Small {
+            lb: self.lead_bytes(),
+            code: SmallVariableLengthCode::Base64String,
+            length: size as u16,
+        };
+        [code.to_cesr(), self.base.clone()].join("")
     }
 
     pub fn to_raw(&self) -> Result<Vec<u8>, Error> {
@@ -59,22 +70,34 @@ impl MaterialPath {
 
 #[test]
 pub fn test_path_to_cesr() -> Result<(), Error> {
-    assert_eq!(MaterialPath::to_path("-".into()).to_cesr(), "6AABAAA-");
-    assert_eq!(MaterialPath::to_path("-A".into()).to_cesr(), "5AABAA-A");
-    assert_eq!(MaterialPath::to_path("-A-".into()).to_cesr(), "4AABA-A-");
-    assert_eq!(MaterialPath::to_path("-A-B".into()).to_cesr(), "4AAB-A-B");
     assert_eq!(
-        MaterialPath::to_path("-a-b-c".into()).to_cesr(),
+        MaterialPath::create_from_str("-".into()).to_cesr(),
+        "6AABAAA-"
+    );
+    assert_eq!(
+        MaterialPath::create_from_str("-A".into()).to_cesr(),
+        "5AABAA-A"
+    );
+    assert_eq!(
+        MaterialPath::create_from_str("-A-".into()).to_cesr(),
+        "4AABA-A-"
+    );
+    assert_eq!(
+        MaterialPath::create_from_str("-A-B".into()).to_cesr(),
+        "4AAB-A-B"
+    );
+    assert_eq!(
+        MaterialPath::create_from_str("-a-b-c".into()).to_cesr(),
         "5AACAA-a-b-c"
     );
 
     assert_eq!(
-        MaterialPath::to_path("-field0".into()).to_cesr(),
+        MaterialPath::create_from_str("-field0".into()).to_cesr(),
         "4AACA-field0"
     );
 
     assert_eq!(
-        MaterialPath::to_path("-field0-field1-field3".into()).to_cesr(),
+        MaterialPath::create_from_str("-field0-field1-field3".into()).to_cesr(),
         "6AAGAAA-field0-field1-field3"
     );
 

cesr/src/cesr_proof/mod.rs

@@ -7,8 +7,6 @@ use nom::{
     sequence::tuple,
 };
 
-#[cfg(feature = "cesr-proof")]
-use crate::cesr_proof::parsers::material_path;
 use crate::{
     primitives::{
         codes::{
@@ -80,10 +78,29 @@ pub fn parse_group(stream: &str) -> nom::IResult<&str, Group> {
             // n * 4 is all path and attachments length (?)
             match nom::bytes::complete::take(n * 4)(rest) {
                 Ok((rest, total)) => {
-                    let (extra, mp) = material_path(total)?;
+                    use crate::variable_length::{
+                        variable_length_value, SmallVariableLengthCode, VariableLengthCode,
+                    };
+                    let (extra, mp) = variable_length_value(total)?;
+                    let material_path = match mp.code() {
+                        VariableLengthCode::Small {
+                            code: SmallVariableLengthCode::Base64String,
+                            lb,
+                            length: _,
+                        } => {
+                            use crate::{cesr_proof::MaterialPath, conversion::from_bytes_to_text};
+
+                            let value = from_bytes_to_text(&mp.value());
+                            MaterialPath::new(lb.clone(), value)
+                        }
+                        _ => return Err(nom::Err::Error(make_error(total, ErrorKind::IsNot))),
+                    };
                     let (_extra, attachment) = many0(parse_group)(extra)?;
 
-                    Ok((rest, Group::PathedMaterialQuadruplet(mp, attachment)))
+                    Ok((
+                        rest,
+                        Group::PathedMaterialQuadruplet(material_path, attachment),
+                    ))
                 }
                 Err(e) => Err(e),
             }?
@@ -122,7 +139,7 @@ fn test_pathed_material() {
 
     let attached_str = "-PAZ5AABAA-a-KABAAFjjD99-xy7J0LGmCkSE_zYceED5uPF4q7l8J23nNQ64U-oWWulHI5dh3cFDWT4eICuEQCALdh8BO5ps-qx0qBA";
     let (_rest, attached_material) = parse_group(attached_str).unwrap();
-    let expected_path = MaterialPath::to_path("-a".into());
+    let expected_path = MaterialPath::create_from_str("-a".into());
     if let Group::PathedMaterialQuadruplet(material_path, groups) = attached_material {
         assert_eq!(material_path, expected_path);
         assert_eq!(groups.len(), 1)

cesr/src/cesr_proof/parsers.rs

@@ -1,9 +1,6 @@
 use std::str::FromStr;
 
-use crate::{
-    conversion::from_bytes_to_text, derivation_code::DerivationCode, error::Error,
-    primitives::parsers::parse_primitive,
-};
+use crate::{conversion::from_bytes_to_text, derivation_code::DerivationCode, error::Error};
 
 // Random salt, seed, nonce, private key, or sequence number of length 128 bits
 #[derive(PartialEq, Eq, Debug, Clone)]

cesr/src/group/parsers.rs

@@ -2,10 +2,7 @@ pub mod codes;
 pub mod parsers;
 use chrono::{DateTime, FixedOffset};
 
-use crate::{
-    conversion::from_bytes_to_text,
-    primitives::codes::{rand_128::Rand128Code, seed::SeedCode},
-};
+use crate::{conversion::from_bytes_to_text, primitives::codes::rand_128::Rand128Code};
 
 use self::codes::{
     attached_signature_code::AttachedSignatureCode, basic::Basic, self_addressing::SelfAddressing,

cesr/src/primitives/codes/rand_128.rs

@@ -89,18 +89,14 @@ pub fn anchoring_event_seal(s: &str) -> nom::IResult<&str, AnchoringEventSeal> {
 #[cfg(test)]
 pub mod tests {
 
-    #[cfg(feature = "cesr-proof")]
-    use crate::cesr_proof::{parsers::material_path, MaterialPath};
     use crate::{
         parse_one,
         primitives::{
             codes::{
                 attached_signature_code::{AttachedSignatureCode, Index},
                 basic::Basic,
-                rand_128::Rand128Code,
                 self_addressing::SelfAddressing,
                 self_signing::SelfSigning,
-                PrimitiveCode,
             },
             parsers::{parse_primitive, serial_number_parser, timestamp_parser},
         },
@@ -247,14 +243,6 @@ pub mod tests {
         );
     }
 
-    #[cfg(feature = "cesr-proof")]
-    #[test]
-    fn test_path_parse() {
-        let attached_str = "6AABAAA-";
-        let (_rest, attached_material) = material_path(attached_str).unwrap();
-        assert_eq!(attached_material, MaterialPath::to_path("-".into()));
-    }
-
     #[test]
     fn parse_tag() {
         use crate::derivation_code::DerivationCode;

cesr/src/primitives/mod.rs

@@ -200,26 +200,23 @@ impl DerivationCode for UniversalGroupCode {
                 CustomizableCode::GenericPipeline => 2,
                 CustomizableCode::Attachments => 2,
             },
-            UniversalGroupCode::OverrideNotAllowed { code, quadlets } => 2,
+            UniversalGroupCode::OverrideNotAllowed { .. } => 2,
         }
     }
 
     fn soft_size(&self) -> usize {
         match self {
             UniversalGroupCode::Genus(_genus_count_code) => 0,
-            UniversalGroupCode::OverrideAllowed {
-                code: _,
-                quadlets: _,
-            } => 2,
-            UniversalGroupCode::OverrideNotAllowed { code, quadlets } => 2,
+            UniversalGroupCode::OverrideAllowed { .. } => 2,
+            UniversalGroupCode::OverrideNotAllowed { .. } => 2,
         }
     }
 
     fn value_size(&self) -> usize {
         match self {
             UniversalGroupCode::Genus(_) => 0,
             UniversalGroupCode::OverrideAllowed { quadlets, .. } => *quadlets as usize,
-            UniversalGroupCode::OverrideNotAllowed { code, quadlets } => *quadlets as usize,
+            UniversalGroupCode::OverrideNotAllowed { quadlets, .. } => *quadlets as usize,
         }
     }