fix(config): fixed bug where user path couldn't be parsed when using certain regex in variable

Author: MrDwarf7

src/config/core.rs

@@ -233,7 +233,13 @@ impl TryFrom<Cli> for Config {
             builder = builder.add_source(config::File::from(config_file));
         }
 
-        let config = builder.build().map_err(Error::ConfigParse)?;
+        let config = match builder.build() {
+            Ok(c) => c,
+            Err(e) => {
+                error!("\n{}", NO_CONFIG_FILE_MSG);
+                return Err(Error::ConfigParse(e));
+            }
+        };
 
         let fixed = fix_multiple_path_subs(&config, vec!["source", "output_path"]).unwrap_or_else(|e| {
             match e {
@@ -243,13 +249,16 @@ impl TryFrom<Cli> for Config {
             vec![]
         });
 
-        let fixed_source = fixed.first().unwrap();
-        let fixed_output_path = fixed.get(1).unwrap();
+        let fixed_source = fixed.to_owned().first().unwrap().clone();
+        let fixed_output_path = fixed.get(1).unwrap_or(&PathBuf::from("output.csv")).clone();
+
+        debug!("Fixed source: {:#?}", fixed_source);
+        debug!("Fixed output path: {:#?}", fixed_output_path);
 
         let mut config: Config = config.try_deserialize().expect("Failed to deserialize config");
 
-        config.source.clone_from(fixed_source);
-        config.output_path.clone_from(fixed_output_path);
+        config.source.clone_from(&fixed_source);
+        config.output_path.clone_from(&fixed_output_path);
 
         config = clear_placeholder_keys(config);
 
@@ -258,18 +267,21 @@ impl TryFrom<Cli> for Config {
 }
 
 #[allow(unused_assignments, clippy::redundant_else, clippy::manual_let_else)]
-fn fix_multiple_path_subs(config: &config::Config, paths: Vec<&str>) -> Result<Vec<PathBuf>> {
+fn fix_multiple_path_subs(config: &config::Config, keys: Vec<&str>) -> Result<Vec<PathBuf>> {
     let mut extracted = vec![];
 
     let mut last_path: Box<&str> = Box::default();
-    for path in paths {
+    for path in keys {
         last_path = Box::new(path);
         debug!("Attempting to extract path: {}", path);
 
         let extracted_path = extract_cached_config_value(config, path)?;
+        debug!("Extracted path: {}", extracted_path);
         let fixed_path = match parse_user_variable_path(&extracted_path) {
             Ok(f) => f,
             Err(_) => {
+                trace!("LAST PATH: {}", last_path);
+                trace!("CURRENT PATH: {}", path);
                 if *last_path == path {
                     warn!("Failed to extract path: {}", path);
                     let extension_idx = extracted_path.rfind('.');
@@ -289,6 +301,7 @@ fn fix_multiple_path_subs(config: &config::Config, paths: Vec<&str>) -> Result<V
                 }
             }
         };
+        debug!("Fixed path: {:#?}", fixed_path);
         extracted.push(fixed_path);
     }
     Ok(extracted)

src/config/file_path_finds.rs

@@ -39,14 +39,19 @@ pub static USER_PATH_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\{(.
 /// It's marginally faster to use an Array/slice over generic size, than allocating to the heap via `Vec::new()`;
 const _S: usize = 1;
 
-pub fn parse_user_variable_path(path_str: &str) -> Result<PathBuf> {
-    // If the user has not provided a user defined regex, then we can just fix the path and return it
-    let user_defined_parts = extract_user_regex(path_str);
+// TODO: Test
+//// Substitute the `var` variable in a string with the given `val` value.
+////
+//// Variable format: `{{ var }}`
+// fn substitute<'a: 'b, 'b>(str: &'a str, var: &str, val: &str) -> std::borrow::Cow<'b, str> {
+//     let format = format!(r"\{{\{{[[:space:]]*{}[[:space:]]*\}}\}}", var);
+//     Regex::new(&format).unwrap().replace_all(str, val)
+// }
 
-    // Serpating the calls here for refactoring purposes later.
-    // Can just call match on the extracted user_regex fnc call above to simplify if wanted.
-    let user_defined_parts = match user_defined_parts {
+pub fn parse_user_variable_path(path_str: &str) -> Result<PathBuf> {
+    let user_defined_parts = match extract_user_regex(path_str) {
         Some(mut parts) => {
+            trace!("User defined parts INNER: {:?}", parts);
             parts.base_path = if is_relative(parts.base_path.to_str().unwrap()).is_ok() {
                 is_relative(parts.base_path.to_str().unwrap())?
             } else {
@@ -57,13 +62,18 @@ pub fn parse_user_variable_path(path_str: &str) -> Result<PathBuf> {
         None => return is_relative(path_str),
     };
 
+    trace!("User defined parts OUTER: {:?}", user_defined_parts);
+
     let base_path_parent = user_defined_parts
         .base_path
         .parent()
         .ok_or_else(|| Error::NoParentPath(user_defined_parts.base_path.clone()))?;
 
+    trace!("Base path parent: {:?}", base_path_parent);
+
     let before_reg_filename =
-        &user_defined_parts.before_regex[user_defined_parts.before_regex.rfind('\\').unwrap_or_default() + 1..];
+        &user_defined_parts.before_regex[(user_defined_parts.before_regex.rfind('\\').unwrap_or_default() + 1)..];
+    trace!("Before regex filename: {:?}", before_reg_filename);
 
     let mut matching_files = Box::new(
         find_match_files_from_regex_path(base_path_parent, &user_defined_parts, before_reg_filename)
@@ -97,14 +107,20 @@ fn extract_user_regex(base_path: &str) -> Option<UserDefinedParts<'_, PathBuf>>
     let re = &USER_PATH_REGEX;
 
     if let Some(captures) = re.captures(base_path) {
-        let var = &captures[1];
-        let user_defined_regex = Regex::new(var).ok()?;
+        let inner_regx = &captures[1];
+        let user_defined_regex = Regex::new(inner_regx).ok()?;
 
         // Everything BEFORE the user defined regex (ie : before { __ } )
         let start = &base_path[0..captures.get(0).unwrap().start()];
 
         // Everything AFTER the user defined regex (ie : after { __ } ) could be ext, or more filename
         let end = &base_path[captures.get(0).unwrap().end()..];
+        let raw_ext = Some(
+            end[end.rfind('.').unwrap_or_default()..]
+                .split_whitespace()
+                .next()
+                .unwrap_or_default(),
+        );
 
         return Some(UserDefinedParts {
             base_path: PathBuf::from(base_path),
@@ -114,6 +130,7 @@ fn extract_user_regex(base_path: &str) -> Option<UserDefinedParts<'_, PathBuf>>
                 _phantom: std::marker::PhantomData,
             },
             suffix_ext: Some(end),
+            raw_ext,
         });
     }
 
@@ -142,6 +159,7 @@ fn find_match_files_from_regex_path(
     let mut matches: Vec<DirEntry> = Vec::new();
 
     for entry in std::fs::read_dir(base_directory).map_err(Error::Io)? {
+        trace!("Entry: {:?}", entry);
         let entry = entry?;
         let metadata = entry.metadata()?;
         let filename = entry.file_name().into_string().unwrap_or_default();
@@ -208,6 +226,7 @@ mod regex_filename {
                 _phantom: std::marker::PhantomData,
             },
             suffix_ext: Some(".csv"),
+            raw_ext: Some(".csv"),
         };
 
         let matches =

src/config/mod.rs

@@ -10,6 +10,7 @@ use config::Value;
 use regex::Regex;
 
 use crate::error::Error;
+use crate::prelude::*;
 
 #[derive(Debug, Clone)]
 struct UserDefinedRegex<'b> {
@@ -18,6 +19,7 @@ struct UserDefinedRegex<'b> {
 }
 
 #[derive(Debug, Clone)]
+#[allow(dead_code)]
 struct UserDefinedParts<'a, P>
 where
     P: Into<PathBuf>,
@@ -27,6 +29,7 @@ where
     before_regex: &'a str,
     user_regex: UserDefinedRegex<'a>,
     suffix_ext: Option<&'a str>,
+    raw_ext: Option<&'a str>,
 }
 
 #[allow(clippy::unnecessary_wraps)] // TODO: will need to change it over at some point
@@ -62,6 +65,7 @@ pub(crate) fn resolve_if_relative(path: &'_ Path) -> Cow<'_, Path> {
 }
 
 pub fn extract_cached_config_value(config: &config::Config, find_key_for: &str) -> crate::prelude::Result<String> {
+    trace!("Extracting cached config value for: {}", find_key_for);
     let (_key, prov_path) = config
         .cache
         .clone()

src/error.rs

@@ -122,4 +122,7 @@ pub enum Error {
 
     #[error("Failed to parse path: {0}")]
     ParsingPath(String),
+
+    #[error("Failed to update the application: {0}")]
+    SelfUpdateFailed(#[from] self_update::errors::Error),
 }

src/macros.rs

@@ -0,0 +1,57 @@
+/// Allows you to pull the authors for the command from your Cargo.toml at
+/// compile time in the form:
+/// `"author1 lastname <author1@example.com>:author2 lastname <author2@example.com>"`
+///
+/// You can replace the colons with a custom separator by supplying a
+/// replacement string, so, for example,
+/// `crate_authors!(",\n")` would become
+/// `"author1 lastname <author1@example.com>,\nauthor2 lastname <author2@example.com>,\nauthor3 lastname <author3@example.com>"`
+///
+/// # Examples
+///
+/// ```no_run
+/// let m = crate_authors!();
+/// assert_eq!(m, "author1 lastname <author1@example.com>:author2 lastname <author2@example.com>"
+/// ```
+#[macro_export]
+macro_rules! crate_authors {
+    ($sep:expr) => {{
+        static AUTHORS: &str = env!("CARGO_PKG_AUTHORS");
+        if AUTHORS.contains(':') {
+            static CACHED: std::sync::OnceLock<String> = std::sync::OnceLock::new();
+            let s = CACHED.get_or_init(|| AUTHORS.replace(':', $sep));
+            let s: &'static str = &*s;
+            s
+        } else {
+            AUTHORS
+        }
+    }};
+    () => {
+        env!("CARGO_PKG_AUTHORS")
+    };
+}
+
+/// Allows you to pull the name from your Cargo.toml at compile time.
+///
+/// <div class="warning">
+///
+/// **NOTE:** This macro extracts the name from an environment variable `CARGO_PKG_NAME`.
+/// When the crate name is set to something different from the package name,
+/// use environment variables `CARGO_CRATE_NAME` or `CARGO_BIN_NAME`.
+/// See [the Cargo Book](https://doc.rust-lang.org/cargo/reference/environment-variables.html)
+/// for more information.
+///
+/// </div>
+///
+/// # Examples
+///
+/// ```no_run
+/// let m =  crate_name!();
+/// assert_eq!(m, "csv_parser_rs");
+/// ```
+#[macro_export]
+macro_rules! crate_name {
+    () => {
+        env!("CARGO_PKG_NAME")
+    };
+}