fixed env resolution

Cargo.lock

@@ -1453,7 +1453,7 @@ dependencies = [
  "log",
  "mime",
  "openssl",
- "path-absolutize",
+ "path-clean",
  "pest",
  "pest_derive",
  "quick-xml",
@@ -1687,22 +1687,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
 [[package]]
-name = "path-absolutize"
-version = "3.1.1"
+name = "path-clean"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4af381fe79fa195b4909485d99f73a80792331df0625188e707854f0b3383f5"
-dependencies = [
- "path-dedot",
-]
-
-[[package]]
-name = "path-dedot"
-version = "3.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07ba0ad7e047712414213ff67533e6dd477af0a4e1d14fb52343e53d30ea9397"
-dependencies = [
- "once_cell",
-]
+checksum = "17359afc20d7ab31fdb42bb844c8b3bb1dabd7dcf7e68428492da7f16966fcef"
 
 [[package]]
 name = "pem"

Cargo.toml

@@ -33,7 +33,7 @@ actix-web-httpauth = "0.8"
 jsonwebtoken = "9.3"
 rust-argon2 = "2.1"
 futures = "0.3"
-path-absolutize = "3.1"
+path-clean = "1"
 pest = "2.7"
 pest_derive = "2.7"
 enum-iterator = "2"

TODO.md

@@ -4,7 +4,6 @@
 
 
 ## Features
-- m3u8 support missing.
 - download from web-ui is not cancellable
 - resume download if available
 - display file size from header if available

src/model/config.rs

@@ -10,7 +10,7 @@ use std::str::FromStr;
 use std::sync::{Arc, RwLock};
 
 use log::{debug, error, warn};
-use path_absolutize::Absolutize;
+use path_clean::PathClean;
 use url::{Url};
 use crate::auth::user::UserCredential;
 
@@ -920,9 +920,13 @@ impl Config {
     }
 
     pub fn prepare(&mut self, resolve_var: bool) -> Result<(), M3uFilterError> {
-        self.working_dir = file_utils::get_working_path(&self.working_dir);
+        let work_dir = if resolve_var { &config_reader::resolve_env_var(&self.working_dir) } else { &self.working_dir };
+        self.working_dir = file_utils::get_working_path(work_dir);
         if self.backup_dir.is_none() {
             self.backup_dir = Some(PathBuf::from(&self.working_dir).join(".backup").into_os_string().to_string_lossy().to_string());
+        } else {
+            let backup_dir = if resolve_var { &config_reader::resolve_env_var(self.backup_dir.as_ref().unwrap()) } else { self.backup_dir.as_ref().unwrap() };
+            self.backup_dir = Some(backup_dir.to_string());
         }
         let backupdir = PathBuf::from(self.backup_dir.as_ref().unwrap());
         if !backupdir.exists() {
@@ -932,7 +936,7 @@ impl Config {
             }
         }
         self.api.prepare();
-        self.prepare_api_web_root();
+        self.prepare_api_web_root(resolve_var);
         if let Some(templates) = &mut self.templates {
             match prepare_templates(templates) {
                 Ok(tmplts) => {
@@ -1003,29 +1007,24 @@ impl Config {
         Ok(())
     }
 
-    fn prepare_api_web_root(&mut self) {
+    fn prepare_api_web_root(&mut self, resolve_var: bool) {
         if !self.api.web_root.is_empty() {
+            let web_root = if resolve_var { config_reader::resolve_env_var(&self.api.web_root) } else { self.api.web_root.clone() };
+            self.api.web_root = web_root.to_string();
             let wrpb = std::path::PathBuf::from(&self.api.web_root);
             if wrpb.is_relative() {
-                let mut wrpb2 = std::path::PathBuf::from(&self.working_dir).join(&self.api.web_root);
+                let mut wrpb2 = std::path::PathBuf::from(&self.working_dir).join(&web_root);
                 if !wrpb2.exists() {
-                    wrpb2 = file_utils::get_exe_path().join(&self.api.web_root);
+                    wrpb2 = file_utils::get_exe_path().join(&web_root);
                 }
                 if !wrpb2.exists() {
                     let cwd = std::env::current_dir();
                     if let Ok(cwd_path) = cwd {
-                        wrpb2 = cwd_path.join(&self.api.web_root);
+                        wrpb2 = cwd_path.join(&web_root);
                     }
                 }
                 if wrpb2.exists() {
-                    match wrpb2.absolutize() {
-                        Ok(os) => self.api.web_root = String::from(os.to_str().unwrap()),
-                        Err(e) => {
-                            error!("failed to absolutize web_root {:?}", e);
-                        }
-                    }
-                    // } else {
-                    //     error!("web_root directory does not exists {:?}", wrpb2)
+                    self.api.web_root = String::from(wrpb2.clean().to_str().unwrap_or_default());
                 }
             }
         }

src/utils/config_reader.rs

@@ -142,13 +142,8 @@ pub fn save_main_config(file_path: &str, backup_dir: &str, config: &ConfigDto) -
 static ENV_REGEX: LazyLock<regex::Regex> = LazyLock::new(|| Regex::new(r"\$\{env:(?P<var>[a-zA-Z_][a-zA-Z0-9_]*)}").unwrap());
 
 pub fn resolve_env_var(value: &str) -> String {
-    if !value.trim().is_empty() {
-        if let Some(caps) = ENV_REGEX.captures(value) {
-            if let Some(var) = caps.name("var") {
-                let var_name = var.as_str();
-                return env::var(var_name).unwrap_or_else(|_| value.to_string());
-            }
-        }
-    }
-    value.to_string()
+    ENV_REGEX.replace_all(value, |caps: &regex::Captures| {
+        let var_name = &caps["var"];
+        env::var(var_name).unwrap_or_else(|_| format!("${{env:{var_name}}}"))
+    }).to_string()
 }

src/utils/file_utils.rs

@@ -4,7 +4,7 @@ use std::io::Write;
 use std::path::{Path, PathBuf};
 
 use log::{debug, error};
-use path_absolutize::Absolutize;
+use path_clean::PathClean;
 
 const USER_FILE: &str = "user.txt";
 const CONFIG_PATH: &str = "config";
@@ -132,17 +132,11 @@ pub fn prepare_persist_path(file_name: &str, date_prefix: &str) -> PathBuf {
 
 pub fn get_file_path(wd: &str, path: Option<PathBuf>) -> Option<PathBuf> {
     path.map(|p| if p.is_relative() {
-                let pb = PathBuf::from(wd);
-                match pb.join(&p).absolutize() {
-                    Ok(os) => PathBuf::from(os),
-                    Err(e) => {
-                        error!("path is not relative {:?}", e);
-                        p
-                    }
-                }
-            } else {
-                p
-            })
+        let pb = PathBuf::from(wd);
+        pb.join(&p).clean()
+    } else {
+        p
+    })
 }
 
 pub fn add_prefix_to_filename(path: &Path, prefix: &str, ext: Option<&str>) -> PathBuf {