refactor

src/encoding.rs

@@ -2,25 +2,23 @@ use crate::message::{self, Message};
 use std::ops::Add;
 
 pub fn encrypt_message(message: &mut Message, circle_length: &usize) -> Vec<Circle> {
-        encode_circles(
+    encode_circles(
-            &mut triples_into_circles(&message.to_triples(), circle_length), 
+        &mut triples_into_circles(&message.to_triples(), circle_length), 
-            &mut message.parts.start_shift,
+        &mut message.parts.start_shift,
-        )
+    )
 }
 
-fn caesar_shift(char: &char, shift: &u8) -> char {
+pub fn caesar_shift(char: &char, shift: &mut u8, shift_delta: i8) -> char {
-    shift.wrapping_add(*char as u8) as char
+    let char = shift.wrapping_add(*char as u8);
+    *shift = shift.wrapping_add_signed(shift_delta);
+    char as char
 }
 
 pub type Circle = Vec<message::Triple>;
 
 pub fn circle_to_points(circle: &Circle) -> Vec<f64> {
     circle.iter().flat_map(|triple| {
-        vec![
+        Vec::<f64>::from(triple.clone())
-            triple.first as u8  as f64,
-            triple.second as u8 as f64,
-            triple.third as u8 as f64
-        ]
     }).collect()
 }
 
@@ -33,26 +31,15 @@ fn triples_into_circles(triples: &Vec<message::Triple>, circle_length: &usize) -
 
 fn encode_circles(circles: &mut Vec<Circle>, shift: &mut u8) -> Vec<Circle> {
     circles.iter_mut().enumerate().map(|(count, circle)| { 
-        let shift_delta = match count {
+        let shift_delta = get_shift_delta(&count);
-            count if count % 2 == 0 => count.add(1) as i8,
-            _ => -(count.add(1) as i8)
-        };
-
         let circle_iter = circle.iter_mut();
 
         let new_circle = match count {
             0 => circle_iter.skip(1),
             _ => circle_iter.skip(0),
         }.map(|triple| {
-            triple.first = caesar_shift(&triple.first, shift);
+            triple.clone().encrypt(shift, shift_delta)
-            *shift = shift.wrapping_add_signed(shift_delta);
+        }).collect();
-            triple.second = caesar_shift(&triple.second, shift);
-            *shift = shift.wrapping_add_signed(shift_delta);
-            triple.second = caesar_shift(&triple.third, shift);
-            *shift = shift.wrapping_add_signed(shift_delta);
-        
-            triple.clone()
-        }).collect::<Circle>();
         
         let new_circle = match count {
             0 => { 
@@ -61,9 +48,15 @@ fn encode_circles(circles: &mut Vec<Circle>, shift: &mut u8) -> Vec<Circle> {
                 return vec;
             },
             _ => new_circle,
-        };
+        }; 
-    
         new_circle
     }).collect()
 }
 
+fn get_shift_delta(count: &usize) -> i8 {
+    match count {
+        count if count % 2 == 0 => count.add(1) as i8,
+        _ => -(count.add(1) as i8)
+    }
+}
+

src/gui.rs

@@ -12,19 +12,11 @@ pub fn gui() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[derive(Default)]
 struct Gui {
     message: Option<crate::Message>,
     circle_length: Option<usize>,
 }
-impl Default for Gui {
-    fn default() -> Self {
-        Self{
-            message: None,
-            circle_length: None,
-        }
-    }
-}
-
 
 impl eframe::App for Gui {
     fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {

src/lib.rs

@@ -41,6 +41,7 @@ pub enum OutputMode {
 }
 
 pub use cli::display_plot;
+pub use encoding::caesar_shift;
 pub use encoding::Circle;
 pub use encoding::circle_to_points;
 pub use encoding::encrypt_message;

src/message.rs

@@ -66,16 +66,15 @@ impl Triple {
             third,
         }
     }
-    
+    pub fn encrypt(mut self, shift: &mut u8, shift_delta: i8) -> Self {
-    pub fn filler() -> Self {
+        self.first = crate::caesar_shift(&self.first, shift, shift_delta);
-        let filler = 0 as char;
+        self.second = crate::caesar_shift(&self.second, shift, shift_delta);
-        Self {
+        self.second = crate::caesar_shift(&self.third, shift, shift_delta); 
-            first: filler,
+
-            second: filler,
+        self
-            third: filler,
-        }
     }
 }
+
 impl IntoIterator for Triple {
     type Item = char;
     type IntoIter = IntoIter<char>;
@@ -84,3 +83,12 @@ impl IntoIterator for Triple {
         vec![self.first, self.second, self.third].into_iter()
     }
 }
+impl From<Triple> for Vec<f64> {
+    fn from(triple: Triple) -> Self {
+        vec![
+            triple.first as u8 as f64,
+            triple.second as u8 as f64,
+            triple.third as u8 as f64,
+        ]
+    }
+}