WIP: app structure

lib/src/core/entities.rs

@@ -0,0 +1,45 @@
+use std::collections::HashMap;
+
+#[derive(Debug, Default, Clone)]
+pub struct DictEntry {
+    pub phoneme_in: String,
+    pub phoneme_out: String,
+
+    pub not_before: Vec<String>,
+    pub not_after: Vec<String>,
+
+    pub only_before: Vec<String>,
+    pub only_after: Vec<String>,
+}
+
+impl DictEntry {
+    pub fn into_lowercase(self) -> Self {
+        DictEntry {
+            phoneme_in: self.phoneme_in.to_lowercase(),
+            phoneme_out: self.phoneme_out.to_lowercase(),
+            not_before: Self::lower_vec(self.not_before),
+            not_after: Self::lower_vec(self.not_after),
+            only_before: Self::lower_vec(self.only_before),
+            only_after: Self::lower_vec(self.only_after),
+        }
+    }
+
+    fn lower_vec(vec: Vec<String>) -> Vec<String> {
+        vec.into_iter().map(|s| s.to_lowercase()).collect()
+    }
+}
+
+pub type DictEntries = Vec<DictEntry>;
+pub struct Dict {
+    name: String,
+    entries: DictEntries,
+}
+
+pub type WordEntryId = u32;
+
+#[derive(Debug, Default)]
+pub struct WordEntry {
+    id: Option<WordEntryId>,
+    word: String,
+    metadata: HashMap<String, String>,
+}

lib/src/core/errors.rs

@@ -0,0 +1,15 @@
+use std::fmt;
+
+#[derive(Debug)]
+pub enum RepositoryError {
+    NotFound,
+    ConnectionFailed,
+    InvalidData(String),
+    Unexpected(String),
+}
+
+impl fmt::Display for RepositoryError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}

lib/src/core/major.rs

@@ -3,6 +3,6 @@ pub mod dict_pl;
 mod encoder;
 
 #[cfg(test)]
-mod tests;
+mod encoder_tests;
 
 pub use encoder::*;

lib/src/core/major/dict_en.rs

@@ -1,6 +1,6 @@
-use crate::core::major::{Dict, DictEntry};
+use crate::core::entities::{DictEntries, DictEntry};
 
-pub fn get_dict() -> Dict {
+pub fn get_dict() -> DictEntries {
     vec![
         DictEntry {
             phoneme_in: "EN".to_string(),

lib/src/core/major/dict_pl.rs

@@ -1,6 +1,6 @@
-use crate::core::major::{Dict, DictEntry};
+use crate::core::entities::{DictEntries, DictEntry};
 
-pub fn get_dict() -> Dict {
+pub fn get_dict() -> DictEntries {
     vec![
         DictEntry {
             phoneme_in: "PL".to_string(),

lib/src/core/major/encoder.rs

@@ -1,51 +1,21 @@
+use crate::core::entities::{DictEntries, DictEntry};
 use crate::core::traits::SystemEncoder;
 
-#[derive(Debug, Default, Clone)]
-pub struct DictEntry {
-    pub phoneme_in: String,
-    pub phoneme_out: String,
-
-    pub not_before: Vec<String>,
-    pub not_after: Vec<String>,
-
-    pub only_before: Vec<String>,
-    pub only_after: Vec<String>,
-}
-
-impl DictEntry {
-    pub fn into_lowercase(self) -> Self {
-        DictEntry {
-            phoneme_in: self.phoneme_in.to_lowercase(),
-            phoneme_out: self.phoneme_out.to_lowercase(),
-            not_before: Self::lower_vec(self.not_before),
-            not_after: Self::lower_vec(self.not_after),
-            only_before: Self::lower_vec(self.only_before),
-            only_after: Self::lower_vec(self.only_after),
-        }
-    }
-
-    fn lower_vec(vec: Vec<String>) -> Vec<String> {
-        vec.into_iter().map(|s| s.to_lowercase()).collect()
-    }
-}
-
-pub type Dict = Vec<DictEntry>;
-
 /// (index, encoded value)
 type DictMatches = Vec<(usize, String)>;
 
 pub struct Encoder {
-    dict: Dict,
+    dict: DictEntries,
 }
 
 impl Encoder {
-    pub fn new(dict: Dict) -> Self {
+    pub fn new(dict: DictEntries) -> Self {
         Encoder {
             dict: Encoder::to_lower_dict(dict),
         }
     }
 
-    fn to_lower_dict(dict: Dict) -> Dict {
+    fn to_lower_dict(dict: DictEntries) -> DictEntries {
         dict.into_iter()
             .map(|entry| entry.into_lowercase())
             .collect()

lib/src/core/major/encoder_tests.rs

@@ -1,3 +1,4 @@
+use crate::core::entities::{DictEntries, DictEntry};
 use crate::core::major::*;
 use crate::core::traits::SystemEncoder;
 
@@ -5,7 +6,7 @@ use crate::core::traits::SystemEncoder;
 mod tests {
     use super::*;
 
-    fn create_single_dict() -> Dict {
+    fn create_single_dict() -> DictEntries {
         vec![DictEntry {
             phoneme_in: "B".to_string(),
             phoneme_out: "2".to_string(),
@@ -16,7 +17,7 @@ mod tests {
         }]
     }
 
-    fn create_single_dict_min() -> Dict {
+    fn create_single_dict_min() -> DictEntries {
         vec![DictEntry {
             phoneme_in: "B".to_string(),
             phoneme_out: "2".to_string(),
@@ -24,15 +25,22 @@ mod tests {
         }]
     }
 
-    fn create_double_dict() -> Dict {
+    fn create_double_dict() -> DictEntries {
-        vec![DictEntry {
+        vec![
-            phoneme_in: "CD".to_string(),
+            DictEntry {
-            phoneme_out: "2".to_string(),
+                phoneme_in: "CD".to_string(),
-            not_after: vec!["YZ".to_string()],
+                phoneme_out: "2".to_string(),
-            not_before: vec!["WX".to_string()],
+                not_after: vec!["00".to_string(), "YZ".to_string()],
-            only_after: vec!["AB".to_string()],
+                not_before: vec!["11".to_string(), "WX".to_string()],
-            only_before: vec!["EF".to_string()],
+                only_after: vec!["22".to_string(), "AB".to_string()],
-        }]
+                only_before: vec!["33".to_string(), "EF".to_string()],
+            },
+            DictEntry {
+                phoneme_in: "MN".to_string(),
+                phoneme_out: "3".to_string(),
+                ..Default::default()
+            },
+        ]
     }
 
     #[test]
@@ -118,4 +126,10 @@ mod tests {
         let output = encoder.encode("AXBYC");
         assert_eq!(output, "2")
     }
+    #[test]
+    fn test_encoding_multiple_phonemes() {
+        let encoder = Encoder::new(create_double_dict());
+        let output = encoder.encode("VvmNabCd33mn00CD22cdefmn");
+        assert_eq!(output, "32323")
+    }
 }

lib/src/core/mod.rs

@@ -1,7 +1,11 @@
+pub mod entities;
+pub mod errors;
 pub mod major;
 pub mod system;
 pub mod traits;
 
 // pub use self::major::*;
+pub use self::entities::*;
+pub use self::errors::*;
 pub use self::system::*;
 pub use self::traits::*;

lib/src/core/traits.rs

@@ -1,3 +1,18 @@
+use crate::core::entities::{Dict, WordEntry, WordEntryId};
+use crate::core::errors::RepositoryError;
+
 pub trait SystemEncoder {
     fn encode(&self, word: &str) -> String;
 }
+
+pub trait WordRepository {
+    fn save(word: &WordEntry) -> Result<WordEntryId, RepositoryError>;
+    fn save_many(words: &Vec<WordEntry>) -> Result<(), RepositoryError>;
+    fn fetch(id: WordEntryId) -> Result<WordEntry, RepositoryError>;
+    fn fetch_many(ids: &Vec<WordEntryId>) -> Result<Vec<WordEntry>, RepositoryError>;
+}
+
+pub trait DictRepository {
+    fn save(dict: &Dict) -> Result<(), RepositoryError>;
+    fn fetch(name: &str) -> Result<Dict, RepositoryError>;
+}