feat: add storage feature

.github/workflows/rust-checks.yml

@@ -24,4 +24,5 @@ jobs:
       - run: rustup update ${{ matrix.toolchain }} && rustup default ${{ matrix.toolchain }}
       - run: cd rust && cargo build --verbose
       - run: cd rust && cargo test --verbose
-      - run: cd rust && cargo test --verbose --features serde_derive
+      - run: cd rust && cargo test --verbose --no-default-features --features const
+      - run: cd rust && cargo test --verbose --no-default-features --features storage

rust/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2021"
 default = ["const"]
 const = []
 serde_derive = ["dep:serde", "dep:serde_json"]
+storage = ["serde_derive"]
 
 [dependencies]
 serde = { version = "1.0.194", features = ["derive"], optional = true }

rust/src/api/get_node_by_path.rs

@@ -1,10 +1,22 @@
-use crate::{_auto_generated, node::model::Node};
+use crate::node::model::Node;
+
+#[cfg(feature = "const")]
+use crate::_auto_generated;
+
+#[cfg(feature = "storage")]
+use crate::api::storage;
 
 #[cfg(feature = "const")]
 pub fn get_node_by_path(path: &str) -> Option<&Node> {
     _auto_generated::data::get_node_by_path(path)
 }
 
+#[cfg(feature = "storage")]
+pub fn get_node_by_path(data_path: &'static str, path: &str) -> Result<Node, std::io::Error> {
+    storage::get_node_by_path(data_path, path)
+}
+
+#[cfg(any(feature = "const", feature = "storage"))]
 #[cfg(test)]
 mod test {
     use crate::node::model::{Node, NodeName, NodeTerms, NodeType};
@@ -16,47 +28,147 @@ mod test {
         let tests = vec![
             (
                 "umkb",
-                Some(&Node {
+                Some(
+                    #[cfg(feature = "const")]&Node {
                     name: NodeName {
+                        #[cfg(feature = "const")]
                         ar: "جامعة محمد خيضر بسكرة",
+                        #[cfg(feature = "storage")]
+                        ar: "جامعة محمد خيضر بسكرة".to_string(),
+                        #[cfg(feature = "const")]
                         en: "University of Mohamed Khider Biskra",
+                        #[cfg(feature = "storage")]
+                        en: "University of Mohamed Khider Biskra".to_string(),
+                        #[cfg(feature = "const")]
                         fr: "Université Mohamed Khider Biskra",
+                        #[cfg(feature = "storage")]
+                        fr: "Université Mohamed Khider Biskra".to_string(),
                     },
                     r#type: NodeType::University,
-                }),
+                },
+                #[cfg(feature = "storage")]
+                Node {
+                    name: NodeName {
+                        #[cfg(feature = "const")]
+                        ar: "جامعة محمد خيضر بسكرة",
+                        #[cfg(feature = "storage")]
+                        ar: "جامعة محمد خيضر بسكرة".to_string(),
+                        #[cfg(feature = "const")]
+                        en: "University of Mohamed Khider Biskra",
+                        #[cfg(feature = "storage")]
+                        en: "University of Mohamed Khider Biskra".to_string(),
+                        #[cfg(feature = "const")]
+                        fr: "Université Mohamed Khider Biskra",
+                        #[cfg(feature = "storage")]
+                        fr: "Université Mohamed Khider Biskra".to_string(),
+                    },
+                    r#type: NodeType::University,
+                }
+                ),
                 #[cfg(feature = "serde_derive")]
-                "{\"name\":{\"ar\":\"جامعة محمد خيضر بسكرة\",\"en\":\"University of Mohamed Khider Biskra\",\"fr\":\"Université Mohamed Khider Biskra\"},\"type\":\"University\"}",
+                "{\"name\":{\"ar\":\"جامعة محمد خيضر بسكرة\",\"en\":\"University of Mohamed Khider Biskra\",\"fr\":\"Université Mohamed Khider Biskra\"},\"type\":\"UNIVERSITY\"}",
             ),
             (
                 "umkb/fst",
-                Some(&Node {
+                Some(
+                    #[cfg(feature = "const")]
+                    &Node {
                     name: NodeName {
+                        #[cfg(feature = "const")]
                         ar: "كلية العلوم والتكنلوجيا",
+                        #[cfg(feature = "storage")]
+                        ar: "كلية العلوم والتكنلوجيا".to_string(),
+                        #[cfg(feature = "const")]
                         en: "Faculty of Science and Technology",
+                        #[cfg(feature = "storage")]
+                        en: "Faculty of Science and Technology".to_string(),
+                        #[cfg(feature = "const")]
                         fr: "Faculté des Sciences et de la Technologie",
+                        #[cfg(feature = "storage")]
+                        fr: "Faculté des Sciences et de la Technologie".to_string(),
                     },
                     r#type: NodeType::Faculty,
-                }),
+                },
+                #[cfg(feature = "storage")]
+                Node {
+                    name: NodeName {
+                        #[cfg(feature = "const")]
+                        ar: "كلية العلوم والتكنلوجيا",
+                        #[cfg(feature = "storage")]
+                        ar: "كلية العلوم والتكنلوجيا".to_string(),
+                        #[cfg(feature = "const")]
+                        en: "Faculty of Science and Technology",
+                        #[cfg(feature = "storage")]
+                        en: "Faculty of Science and Technology".to_string(),
+                        #[cfg(feature = "const")]
+                        fr: "Faculté des Sciences et de la Technologie",
+                        #[cfg(feature = "storage")]
+                        fr: "Faculté des Sciences et de la Technologie".to_string(),
+                    },
+                    r#type: NodeType::Faculty,
+                }
+                ),
                 #[cfg(feature = "serde_derive")]
-                "{\"name\":{\"ar\":\"كلية العلوم والتكنلوجيا\",\"en\":\"Faculty of Science and Technology\",\"fr\":\"Faculté des Sciences et de la Technologie\"},\"type\":\"Faculty\"}",
+                "{\"name\":{\"ar\":\"كلية العلوم والتكنلوجيا\",\"en\":\"Faculty of Science and Technology\",\"fr\":\"Faculté des Sciences et de la Technologie\"},\"type\":\"FACULTY\"}",
             ),
             (
                 "umkb/fst/dee/sec",
-                Some(&Node {
+                Some(
+                    #[cfg(feature = "const")]
+                    &Node {
                     name: NodeName {
+                        #[cfg(feature = "const")]
                         ar: "تخصص التحكم الكهربائي",
+                        #[cfg(feature = "storage")]
+                        ar: "تخصص التحكم الكهربائي".to_string(),
+                        #[cfg(feature = "const")]
                         en: "Specialy of Electrical Control",
+                        #[cfg(feature = "storage")]
+                        en: "Specialy of Electrical Control".to_string(),
+                        #[cfg(feature = "const")]
                         fr: "Spécialité de commande électrique",
+                        #[cfg(feature = "storage")]
+                        fr: "Spécialité de commande électrique".to_string(),
                     },
                     r#type: NodeType::Specialty {
                         terms: NodeTerms {
                             per_year: 2,
+                            #[cfg(feature = "const")]
                             slots: &[7, 8, 9, 10],
+                            #[cfg(feature = "storage")]
+                            slots: vec![7, 8, 9, 10],
                         },
                     },
-                }),
+                },
+                #[cfg(feature = "storage")]
+                Node {
+                    name: NodeName {
+                        #[cfg(feature = "const")]
+                        ar: "تخصص التحكم الكهربائي",
+                        #[cfg(feature = "storage")]
+                        ar: "تخصص التحكم الكهربائي".to_string(),
+                        #[cfg(feature = "const")]
+                        en: "Specialy of Electrical Control",
+                        #[cfg(feature = "storage")]
+                        en: "Specialy of Electrical Control".to_string(),
+                        #[cfg(feature = "const")]
+                        fr: "Spécialité de commande électrique",
+                        #[cfg(feature = "storage")]
+                        fr: "Spécialité de commande électrique".to_string(),
+                    },
+                    r#type: NodeType::Specialty {
+                        terms: NodeTerms {
+                            per_year: 2,
+                            #[cfg(feature = "const")]
+                            slots: &[7, 8, 9, 10],
+                            #[cfg(feature = "storage")]
+                            slots: vec![7, 8, 9, 10],
+                        },
+                    },
+                }
+                ),
                 #[cfg(feature = "serde_derive")]
-                "{\"name\":{\"ar\":\"تخصص التحكم الكهربائي\",\"en\":\"Specialy of Electrical Control\",\"fr\":\"Spécialité de commande électrique\"},\"type\":{\"Specialty\":{\"terms\":{\"per_year\":2,\"slots\":[7,8,9,10]}}}}",
+                "{\"name\":{\"ar\":\"تخصص التحكم الكهربائي\",\"en\":\"Specialy of Electrical Control\",\"fr\":\"Spécialité de commande électrique\"},\"type\":\"SPECIALTY\",\"terms\":{\"perYear\":2,\"slots\":[7,8,9,10]}}",
             ),
             (
                 "does/not/exist", None, 
@@ -65,19 +177,42 @@ mod test {
             ),
         ];
 
-        for test_case in tests {
-            let path = test_case.0;
-            let expected = test_case.1;
-            let actual = get_node_by_path(path);
-            assert_eq!(actual, expected);
+        for tc in tests {
+            let path = tc.0;
+            let expected = tc.1;
+            #[cfg(feature = "const")]
+            {
+                let actual = get_node_by_path(path);
+                assert_eq!(actual, expected);
+            }
+            #[cfg(feature = "storage")]
+            {
+                let actual = get_node_by_path("../_data", path).ok();
+                assert_eq!(actual, expected);
+            }
             #[cfg(feature = "serde_derive")]
             {
-                let expected_stringified = test_case.2;
+                let expected_stringified = tc.2;
+                let actual = get_node_by_path("../_data", path).ok();
                 assert_eq!(
                     serde_json::to_string(&actual).unwrap(),
                     expected_stringified
                 );
             }
         }
     }
+
+    #[test]
+    fn should_get_none_when_path_does_not_exist() {
+        #[cfg(feature = "const")]
+        {
+            let res = get_node_by_path("does/not/exist");
+            assert!(res.is_none());
+        }
+        #[cfg(feature = "storage")]
+        {
+            let res = get_node_by_path("../_data", "does/not/exist");
+            assert!(res.is_err());
+        }
+    }
 }

rust/src/api/mod.rs

@@ -1 +1,2 @@
 pub mod get_node_by_path;
+mod storage;

rust/src/api/storage.rs

@@ -0,0 +1,15 @@
+#[cfg(feature = "storage")]
+use crate::Node;
+
+#[cfg(feature = "storage")]
+pub fn get_node_by_path(data_path: &'static str, path: &str) -> Result<Node, std::io::Error> {
+    let fs_path = format!("{}/{}/info.json", data_path, path);
+    let info = std::fs::read_to_string(fs_path)?;
+    let Ok(node) = serde_json::from_str::<Node>(info.as_str()) else {
+        return Err(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            "json was not deserialized",
+        ));
+    };
+    Ok(node)
+}

rust/src/lib.rs

@@ -1,4 +1,6 @@
+#[cfg(feature = "const")]
 mod _auto_generated;
+
 mod api;
 mod node;
 

rust/src/node/model.rs

@@ -1,41 +1,73 @@
 #[cfg(feature = "serde_derive")]
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
+#[cfg(feature = "const")]
 #[derive(Debug, PartialEq)]
-#[cfg_attr(feature = "serde_derive", derive(Serialize))]
+#[cfg_attr(feature = "serde_derive", derive(Serialize, Deserialize))]
+pub struct NodeName<'a> {
+    pub ar: &'a str,
+    pub en: &'a str,
+    pub fr: &'a str,
+}
+
+#[cfg(feature = "storage")]
+#[derive(Debug, PartialEq)]
+#[cfg_attr(feature = "serde_derive", derive(Serialize, Deserialize))]
 pub struct NodeName {
-    #[cfg(feature = "const")]
-    pub ar: &'static str,
-    #[cfg(feature = "const")]
-    pub en: &'static str,
-    #[cfg(feature = "const")]
-    pub fr: &'static str,
+    pub ar: String,
+    pub en: String,
+    pub fr: String,
 }
 
+#[cfg(any(feature = "const", feature = "storage"))]
 #[derive(Debug, PartialEq)]
-#[cfg_attr(feature = "serde_derive", derive(Serialize))]
+#[cfg_attr(
+    feature = "serde_derive",
+    derive(Serialize, Deserialize),
+    serde(tag = "type")
+)]
 pub enum NodeType {
+    #[cfg_attr(feature = "serde_derive", serde(rename = "UNIVERSITY"))]
     University,
+    #[cfg_attr(feature = "serde_derive", serde(rename = "ACADEMY"))]
     Academy,
+    #[cfg_attr(feature = "serde_derive", serde(rename = "PRIVATE_SCHOOL"))]
     PrivateSchool,
+    #[cfg_attr(feature = "serde_derive", serde(rename = "INSTITUTE"))]
     Institute,
+    #[cfg_attr(feature = "serde_derive", serde(rename = "FACULTY"))]
     Faculty,
+    #[cfg_attr(feature = "serde_derive", serde(rename = "DEPARTMENT"))]
     Department,
+    #[cfg_attr(feature = "serde_derive", serde(rename = "SPECIALTY"))]
     Specialty { terms: NodeTerms },
+    #[cfg_attr(feature = "serde_derive", serde(rename = "SECTOR"))]
     Sector { terms: NodeTerms },
 }
 
 #[derive(Debug, PartialEq, Clone)]
-#[cfg_attr(feature = "serde_derive", derive(Serialize))]
+#[cfg_attr(
+    feature = "serde_derive",
+    derive(Serialize, Deserialize),
+    serde(rename_all = "camelCase")
+)]
 pub struct NodeTerms {
     pub per_year: usize,
     #[cfg(feature = "const")]
     pub slots: &'static [i32],
+    #[cfg(feature = "storage")]
+    pub slots: Vec<i32>,
 }
 
+#[cfg(any(feature = "const", feature = "storage"))]
 #[derive(Debug, PartialEq)]
-#[cfg_attr(feature = "serde_derive", derive(Serialize))]
+#[cfg_attr(feature = "serde_derive", derive(Serialize, Deserialize))]
 pub struct Node {
+    #[cfg(feature = "const")]
+    #[cfg_attr(feature = "serde_derive", serde(borrow))]
+    pub name: NodeName<'static>,
+    #[cfg(feature = "storage")]
     pub name: NodeName,
+    #[cfg_attr(feature = "serde_derive", serde(flatten))]
     pub r#type: NodeType,
 }