Refactor.

src/lib.rs

@@ -39,15 +39,15 @@ mod support_tests {
 
 static TIMEOUT: Duration = Duration::from_secs(10);
 
-struct PreBuildClient {
+pub struct MTTClient {
     queue: Queue,
-    msg_id: MessageID,
     rx: Receiver<Message>,
     sender_id: SenderID,
+    session_id: Uuid,
 }
 
-impl PreBuildClient {
+impl MTTClient {
-    fn new(mut queue: Queue) -> Self {
+    fn new(mut queue: Queue, sess_id: Option<String>, lang: Option<Language>) -> Self {
         let sess_name = Session::doc_names()[0].clone();
         let (tx, rx) = channel();
         let sender_id = queue.add_sender(tx);
@@ -64,42 +64,6 @@ impl PreBuildClient {
                 Include::Just(Action::Error),
             ),
         ];
-        for path in paths.iter().cloned() {
-            let reg_msg = Register::new(sender_id.clone(), RegMsg::AddRoute(path));
-            queue.send(Message::with_id(msg_id.clone(), reg_msg));
-            let result = rx.recv().unwrap();
-        }
-        Self {
-            queue: queue,
-            msg_id: msg_id,
-            rx: rx,
-            sender_id: sender_id,
-        }
-    }
-
-    fn send<MA>(&self, action: MA) -> Records
-    where
-        MA: Into<MsgAction>,
-    {
-        self.queue
-            .send(Message::with_id(self.msg_id.clone(), action));
-        let result = self.rx.recv().unwrap();
-        match result.get_action() {
-            MsgAction::Records(data) => data.clone(),
-            _ => unreachable!("session requests should always return data"),
-        }
-    }
-}
-
-pub struct MTTClient {
-    queue: Queue,
-    rx: Receiver<Message>,
-    sender_id: SenderID,
-    session_id: Uuid,
-}
-
-impl MTTClient {
-    fn internal_new(prebuild: PreBuildClient, lang: Option<Language>) -> Self {
         let mut add = Addition::new(Session::doc_names()[0].clone());
         match lang {
             Some(language) => {
@@ -108,54 +72,55 @@ impl MTTClient {
             }
             None => {}
         }
-        let result = prebuild.send(add);
+        for path in paths.iter().cloned() {
-        let rec = result.iter().last().unwrap();
+            let reg_msg = Register::new(sender_id.clone(), RegMsg::AddRoute(path));
-        let session_id = match rec.get(Session::id_field_names()[0].clone()).unwrap() {
+            queue.send(Message::with_id(msg_id.clone(), reg_msg));
-            Field::Uuid(data) => data.clone(),
+            let result = rx.recv().unwrap();
-            _ => unreachable!("should always be uuid"),
-        };
-        Self {
-            queue: prebuild.queue,
-            rx: prebuild.rx,
-            sender_id: prebuild.sender_id,
-            session_id: session_id,
         }
-    }
+        match sess_id {
-
+            Some(id) => {
-    fn new(mut queue: Queue, lang: Option<Language>) -> Self {
-        let prebuild = PreBuildClient::new(queue);
-        Self::internal_new(prebuild, lang)
-    }
-
-    fn with_session(queue: Queue, id: String, lang: Option<Language>) -> Self {
-        let prebuild = PreBuildClient::new(queue.clone());
                 let sess_id = match Uuid::try_from(id.as_str()) {
-            Ok(data) => data,
+                    Ok(data) => {
-            Err(_) => return Self::internal_new(prebuild, lang),
-        };
                         let mut qry = Query::new(Session::doc_names()[0].clone());
                         let mut calc = Calculation::new(Operand::Equal);
                         calc.add_value(CalcValue::Existing(FieldType::Uuid))
                             .unwrap();
-        calc.add_value(sess_id).unwrap();
+                        calc.add_value(data.clone()).unwrap();
                         qry.add(Session::id_field_names()[0].clone(), calc);
-        let result = prebuild.send(qry);
+                        queue.send(Message::with_id(msg_id.clone(), qry));
-        if result.len() == 0 {
+                    }
-            Self::internal_new(prebuild, lang)
+                    Err(_) => queue.send(Message::with_id(msg_id.clone(), add.clone())),
-        } else {
+                };
-            let rec = result.iter().last().unwrap();
+            }
-            let session_id = match rec.get(Session::id_field_names()[0].clone()).unwrap() {
+            None => queue.send(Message::with_id(msg_id.clone(), add.clone())),
+        };
+        let result = rx.recv().unwrap();
+        let session_id = match result.get_action() {
+            MsgAction::Records(result) => {
+                let mut holder = result.clone();
+                if holder.len() == 0 {
+                    queue.send(Message::with_id(msg_id.clone(), add));
+                    let new_sess = rx.recv().unwrap();
+                    holder = match new_sess.get_action() {
+                        MsgAction::Records(new_holder) => new_holder.clone(),
+                        _ => unreachable!("should only receive session records"),
+                    }
+                }
+                let rec = holder.iter().last().unwrap();
+                match rec.get(Session::id_field_names()[0].clone()).unwrap() {
                     Field::Uuid(data) => data.clone(),
                     _ => unreachable!("should always be uuid"),
+                }
+            }
+            _ => unreachable!("should only receive session records"),
         };
         Self {
             queue: queue,
-                rx: prebuild.rx,
+            rx: rx,
-                sender_id: prebuild.sender_id.clone(),
+            sender_id: sender_id,
             session_id: session_id,
         }
     }
-    }
 
     pub fn session_id(&self) -> String {
         self.session_id.to_string()
@@ -188,15 +153,15 @@ impl MoreThanText {
     }
 
     pub fn client(&self) -> MTTClient {
-        MTTClient::new(self.queue.clone(), None)
+        MTTClient::new(self.queue.clone(), None, None)
     }
 
     pub fn client_with_language(&self, lang: Language) -> MTTClient {
-        MTTClient::new(self.queue.clone(), Some(lang))
+        MTTClient::new(self.queue.clone(), None, Some(lang))
     }
 
     pub fn client_with_session(&self, id: String, lang: Option<Language>) -> MTTClient {
-        MTTClient::with_session(self.queue.clone(), id, lang)
+        MTTClient::new(self.queue.clone(), Some(id), lang)
     }
 
     fn new_session(lang: Option<Language>) -> ClientAction {