[feat] custom Error Handling

Author: MecryTv

crates/package/src/lib.rs

@@ -1,113 +1,144 @@
 use serde::Deserialize;
 use serde::de::DeserializeOwned;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::{fs, io};
-use tucana::shared::{DefinitionDataType, FlowType, RuntimeFunctionDefinition};
+use tucana::shared::{DefinitionDataType, FlowType, RuntimeFunctionDefinition, Version};
 use walkdir::WalkDir;
 
-#[derive(Deserialize, Debug)]
+#[derive(Deserialize, Debug, Clone)]
 pub struct Feature {
     pub name: String,
     pub data_types: Vec<DefinitionDataType>,
     pub flow_types: Vec<FlowType>,
     pub functions: Vec<RuntimeFunctionDefinition>,
 }
 
-pub fn read_features(path: &str) -> Result<Vec<Feature>, io::Error> {
-    let definitions = Path::new(path);
+pub struct Reader {
+    should_break: bool,
+    accepted_features: Vec<String>,
+    accepted_versions: Option<Version>,
+    path: String,
+}
 
-    match read_feature_content(definitions) {
-        Ok(features) => {
-            log::info!("Loaded Successfully {} features", features.len());
-            Ok(features)
-        }
-        Err(err) => {
-            panic!("Cannot loaded content: {}", err)
-        }
-    }
+pub enum ReaderError {
+    JsonError { path: PathBuf, error: serde_json::Error },
+    ReadFeatureError { path: String, source: Box<ReaderError> },
+    ReadDirectoryError { path: PathBuf, error: io::Error },
+    ReadFileError { path: PathBuf, error: io::Error },
+    DirectoryEntryError(io::Error),
 }
 
-fn read_feature_content(dir: &Path) -> Result<Vec<Feature>, io::Error> {
-    let mut features: Vec<Feature> = Vec::new();
-    let readdir = match fs::read_dir(dir) {
-        Ok(readdir) => readdir,
-        Err(err) => {
-            log::error!("Failed to read directory {}: {}", dir.display(), err);
-            return Err(err);
+impl Reader {
+    pub fn read_features(&self, path: &str) -> Result<Vec<Feature>, ReaderError> {
+        let definitions = Path::new(path);
+
+        match self.read_feature_content(definitions) {
+            Ok(features) => {
+                log::info!("Loaded Successfully {} features", features.len());
+                Ok(features)
+            }
+            Err(err) => {
+                log::error!("Failed to read features from {}", path);
+                Err(ReaderError::ReadFeatureError {
+                    path: path.to_string(),
+                    source: Box::new(err),
+                })
+            }
         }
-    };
+    }
 
-    for entry_result in readdir {
-        let entry = match entry_result {
-            Ok(entry) => entry,
+    fn read_feature_content(&self, dir: &Path) -> Result<Vec<Feature>, ReaderError> {
+        let mut features: Vec<Feature> = Vec::new();
+        let readdir = match fs::read_dir(dir) {
+            Ok(readdir) => readdir,
             Err(err) => {
-                log::error!("Failed to read directory entry: {}", err);
-                continue;
+                log::error!("Failed to read directory {}: {}", dir.display(), err);
+                return Err(ReaderError::ReadDirectoryError {
+                    path: dir.to_path_buf(),
+                    error: err,
+                });
             }
         };
 
-        let path = entry.path();
+        for entry_result in readdir {
+            let entry = match entry_result {
+                Ok(entry) => entry,
+                Err(err) => {
+                    log::error!("Failed to read directory entry: {}", err);
+                    return Err(ReaderError::DirectoryEntryError(err));
+                }
+            };
 
-        if path.is_dir() {
-            let feature_name = path
-                .file_name()
-                .unwrap_or_default()
-                .to_string_lossy()
-                .to_string();
+            let path = entry.path();
 
-            let data_types_path = path.join("data_type");
-            let data_types: Vec<DefinitionDataType> = collect_definitions(&data_types_path)?;
+            if path.is_dir() {
+                let feature_name = path
+                    .file_name()
+                    .unwrap_or_default()
+                    .to_string_lossy()
+                    .to_string();
 
-            let flow_types_path = path.join("flow_type");
-            let flow_types: Vec<FlowType> = collect_definitions(&flow_types_path)?;
+                let data_types_path = path.join("data_type");
+                let data_types: Vec<DefinitionDataType> = self.collect_definitions(&data_types_path)?;
 
-            let functions_path = path.join("runtime_definition");
-            let functions: Vec<RuntimeFunctionDefinition> = collect_definitions(&functions_path)?;
+                let flow_types_path = path.join("flow_type");
+                let flow_types: Vec<FlowType> = self.collect_definitions(&flow_types_path)?;
 
-            let feature = Feature {
-                name: feature_name,
-                data_types,
-                flow_types,
-                functions,
-            };
+                let functions_path = path.join("runtime_definition");
+                let functions: Vec<RuntimeFunctionDefinition> = self.collect_definitions(&functions_path)?;
 
-            features.push(feature);
-        }
-    }
-
-    Ok(features)
-}
+                let feature = Feature {
+                    name: feature_name,
+                    data_types,
+                    flow_types,
+                    functions,
+                };
 
-fn collect_definitions<T>(dir: &Path) -> Result<Vec<T>, io::Error>
-where
-    T: DeserializeOwned,
-{
-    let mut definitions = Vec::new();
+                features.push(feature);
+            }
+        }
 
-    if !dir.exists() {
-        return Ok(definitions);
+        Ok(features)
     }
 
-    for entry in WalkDir::new(dir).into_iter().filter_map(Result::ok) {
-        let path = entry.path();
+    fn collect_definitions<T>(&self, dir: &Path) -> Result<Vec<T>, ReaderError>
+    where
+        T: DeserializeOwned,
+    {
+        let mut definitions = Vec::new();
 
-        if path.is_file() && path.extension().is_some_and(|ext| ext == "json") {
-            let content = match fs::read_to_string(path) {
-                Ok(content) => content,
-                Err(err) => {
-                    log::error!("Failed to read file {}: {}", path.display(), err);
-                    continue;
-                }
-            };
+        if !dir.exists() {
+            return Ok(definitions);
+        }
 
-            match serde_json::from_str::<T>(&content) {
-                Ok(def) => definitions.push(def),
-                Err(e) => {
-                    log::error!("Failed to parse JSON in file {}: {}", path.display(), e);
+        for entry in WalkDir::new(dir).into_iter().filter_map(Result::ok) {
+            let path = entry.path();
+
+            if path.is_file() && path.extension().is_some_and(|ext| ext == "json") {
+                let content = match fs::read_to_string(path) {
+                    Ok(content) => content,
+                    Err(err) => {
+                        log::error!("Failed to read file {}: {}", path.display(), err);
+                        return Err(ReaderError::ReadFileError {
+                            path: path.to_path_buf(),
+                            error: err,
+                        })
+                    }
+                };
+
+                match serde_json::from_str::<T>(&content) {
+                    Ok(def) => definitions.push(def),
+                    Err(e) => {
+                        log::error!("Failed to parse JSON in file {}: {}", path.display(), e);
+                        return Err(ReaderError::JsonError {
+                            path: path.to_path_buf(),
+                            error: e,
+                        });
+                    }
                 }
             }
         }
-    }
 
-    Ok(definitions)
+        Ok(definitions)
+    }
 }