Merge pull request #62 from soma-smart/fix/v1.7.2-improvements

Prepare v1.7.2: fix file naming, improve error messages

Author: vianneybacoup

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "fakelake"
-version = "1.7.0"
+version = "1.7.2"
 edition = "2021"
 rust-version = "1.90.0"
 

Cargo.toml

@@ -126,7 +126,7 @@ impl Column {
             let provider: Box<dyn Provider> =
                 match ProviderBuilder::get_corresponding_provider(provider, column) {
                     Ok(value) => CorruptedProvider::new_from_yaml(column, value),
-                    Err(e) => return Err(FakeLakeError::BadYAMLFormat(e.to_string())),
+                    Err(e) => return Err(e),
                 };
 
             let column = Column {

src/config.rs

@@ -4,6 +4,10 @@ use std::io;
 #[derive(Debug)]
 pub enum FakeLakeError {
     BadYAMLFormat(String),
+    UnknownProvider {
+        provider: String,
+        available: &'static [&'static str],
+    },
     IOError(io::Error),
     CSVError(csv::Error),
     JSONError(serde_json::Error),
@@ -14,8 +18,25 @@ pub enum FakeLakeError {
 #[cfg(not(tarpaulin_include))]
 impl fmt::Display for FakeLakeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        // For now, use the debug derived version
-        write!(f, "{:?}", self)
+        match self {
+            FakeLakeError::BadYAMLFormat(msg) => write!(f, "{}", msg),
+            FakeLakeError::UnknownProvider {
+                provider,
+                available,
+            } => {
+                write!(
+                    f,
+                    "Unknown provider: {}. Expected one of: {}",
+                    provider,
+                    available.join(", ")
+                )
+            }
+            FakeLakeError::IOError(err) => write!(f, "IO error: {}", err),
+            FakeLakeError::CSVError(err) => write!(f, "CSV error: {}", err),
+            FakeLakeError::JSONError(err) => write!(f, "JSON error: {}", err),
+            FakeLakeError::ParquetError(err) => write!(f, "Parquet error: {}", err),
+            FakeLakeError::ArrowError(err) => write!(f, "Arrow error: {}", err),
+        }
     }
 }
 

src/errors.rs

@@ -30,11 +30,18 @@ pub trait OutputFormat {
             );
         }
 
+        let extension = self.get_extension();
+
         for f in 0..files {
             let file_name = if files == 1 {
                 default_file_name.clone()
             } else {
-                format!("{}_{}", default_file_name, f)
+                match default_file_name.strip_suffix(extension) {
+                    Some(stem) if !extension.is_empty() => {
+                        format!("{}_{}{}", stem, f, extension)
+                    }
+                    _ => format!("{}_{}", default_file_name, f),
+                }
             };
 
             let file_seed = rng::derive_seed(root_seed, rng::DOMAIN_FILE, &[f as u64]);

src/generate/output_format.rs

@@ -1,17 +1,20 @@
 use yaml_rust::Yaml;
 
-use crate::{errors::FakeLakeError, providers::provider::Provider};
+use crate::errors::FakeLakeError;
+use crate::providers::provider::{unknown_provider, Provider};
 
 use super::{external, string};
 
+const AVAILABLE: &[&str] = &["constant.string", "constant.external"];
+
 pub fn get_corresponding_provider(
     mut provider_split: std::str::Split<'_, char>,
     column: &Yaml,
 ) -> Result<Box<dyn Provider>, FakeLakeError> {
     match provider_split.next() {
         Some("string") => Ok(string::new_from_yaml(column)),
         Some("external") => Ok(external::new_from_yaml(column)),
-        _ => Err(FakeLakeError::BadYAMLFormat("".to_string())),
+        other => Err(unknown_provider("constant", other, AVAILABLE)),
     }
 }
 

src/providers/constant/builder.rs

@@ -1,17 +1,19 @@
 use crate::errors::FakeLakeError;
-use crate::providers::provider::Provider;
+use crate::providers::provider::{unknown_provider, Provider};
 
 use super::integer;
 
 use yaml_rust::Yaml;
 
+const AVAILABLE: &[&str] = &["increment.integer"];
+
 pub fn get_corresponding_provider(
     mut provider_split: std::str::Split<'_, char>,
     column: &Yaml,
 ) -> Result<Box<dyn Provider>, FakeLakeError> {
     match provider_split.next() {
         Some("integer") => Ok(integer::new_from_yaml(column)),
-        _ => Err(FakeLakeError::BadYAMLFormat("".to_string())),
+        other => Err(unknown_provider("increment", other, AVAILABLE)),
     }
 }
 

src/providers/increment/builder.rs

@@ -1,12 +1,14 @@
 use crate::errors::FakeLakeError;
 use crate::providers::constant::external;
-use crate::providers::provider::Provider;
+use crate::providers::provider::{unknown_provider, Provider};
 
 use super::email;
 
 use once_cell::sync::Lazy;
 use yaml_rust::Yaml;
 
+const AVAILABLE: &[&str] = &["person.email", "person.fname", "person.lname"];
+
 static FIRST_NAMES: Lazy<Vec<String>> = Lazy::new(|| {
     let raw_first_names = include_str!("../../../static/first_name_fr.txt");
     raw_first_names.lines().map(|v| v.to_string()).collect()
@@ -25,7 +27,7 @@ pub fn get_corresponding_provider(
         Some("email") => Ok(email::new_from_yaml(column)),
         Some("fname") => Ok(external::new(FIRST_NAMES.to_vec())),
         Some("lname") => Ok(external::new(LAST_NAMES.to_vec())),
-        _ => Err(FakeLakeError::BadYAMLFormat("".to_string())),
+        other => Err(unknown_provider("person", other, AVAILABLE)),
     }
 }
 

src/providers/person/builder.rs

@@ -106,13 +106,30 @@ impl ProviderBuilder {
             Some("random") => {
                 providers::random::builder::get_corresponding_provider(provider_split, column)
             }
-            _ => Err(unknown_provider(provider)),
+            other => Err(unknown_provider(
+                "",
+                other,
+                &["constant.*", "increment.*", "person.*", "random.*"],
+            )),
         }
     }
 }
 
-pub fn unknown_provider(wrong_provider: &str) -> FakeLakeError {
-    FakeLakeError::BadYAMLFormat(format!("Unknown provider: {}", wrong_provider))
+pub fn unknown_provider(
+    prefix: &str,
+    segment: Option<&str>,
+    available: &'static [&'static str],
+) -> FakeLakeError {
+    let provider = match (prefix, segment) {
+        ("", Some(s)) => s.to_string(),
+        ("", None) => "<missing>".to_string(),
+        (p, Some(s)) => format!("{}.{}", p, s),
+        (p, None) => format!("{}.<missing>", p),
+    };
+    FakeLakeError::UnknownProvider {
+        provider,
+        available,
+    }
 }
 
 #[cfg(test)]
@@ -195,6 +212,36 @@ mod tests {
         }
     }
 
+    #[test]
+    fn given_valid_provider_case_insensitive_should_return_provider() {
+        let provider_names = [
+            "Constant.String",
+            "CONSTANT.STRING",
+            "Increment.Integer",
+            "INCREMENT.INTEGER",
+            "Person.Email",
+            "PERSON.EMAIL",
+            "Random.String.Alphanumeric",
+            "RANDOM.STRING.ALPHANUMERIC",
+            "Random.Number.I32",
+            "RANDOM.NUMBER.F64",
+            "Random.Date.Date",
+            "RANDOM.DATE.DATETIME",
+        ];
+        for provider_name in provider_names {
+            let yaml_str = format!("name: name{}provider: {}", '\n', provider_name);
+            let column = &YamlLoader::load_from_str(yaml_str.as_str()).unwrap()[0];
+
+            match ProviderBuilder::get_corresponding_provider(provider_name, column) {
+                Ok(_) => (),
+                _ => panic!(
+                    "Provider '{}' should be resolved case-insensitively",
+                    provider_name
+                ),
+            }
+        }
+    }
+
     #[test]
     fn given_wrong_provider_should_return_error() {
         let provider_name = "not_a_provider";

src/providers/provider.rs

@@ -1,10 +1,17 @@
 use crate::errors::FakeLakeError;
-use crate::providers::provider::Provider;
+use crate::providers::provider::{unknown_provider, Provider};
 
 use super::{bool, date, number, string};
 
 use yaml_rust::Yaml;
 
+const AVAILABLE: &[&str] = &[
+    "random.bool",
+    "random.date.*",
+    "random.number.*",
+    "random.string.*",
+];
+
 pub fn get_corresponding_provider(
     mut provider_split: std::str::Split<'_, char>,
     column: &Yaml,
@@ -14,7 +21,7 @@ pub fn get_corresponding_provider(
         Some("date") => date::builder::get_corresponding_provider(provider_split, column),
         Some("number") => number::builder::get_corresponding_provider(provider_split, column),
         Some("string") => string::builder::get_corresponding_provider(provider_split, column),
-        _ => Err(FakeLakeError::BadYAMLFormat("".to_string())),
+        other => Err(unknown_provider("random", other, AVAILABLE)),
     }
 }