pre_process.rs

use regex::Regex;
use std::{borrow::Cow, collections::HashSet, path::PathBuf, process::Command};

use crate::config::configs::{EmmyrcWorkspacePathConfig, EmmyrcWorkspacePathItem};

pub struct PreProcessContext {
    workspace: PathBuf,
    luarocks_deploy_dir: String,
    placeholder_regex: Option<Regex>,
    env_var_regex: Option<Regex>,
}

impl PreProcessContext {
    pub fn new(workspace: PathBuf) -> Self {
        let luarocks_deploy_dir = get_luarocks_deploy_dir();

        Self {
            workspace,
            luarocks_deploy_dir,
            env_var_regex: match Regex::new(r"\$(\w+)") {
                Ok(re) => Some(re),
                Err(_) => {
                    log::error!(
                        "Warning: Failed to create regex for environment variable replacement"
                    );
                    None
                }
            },
            placeholder_regex: match Regex::new(r"\{([^}]+)\}") {
                Ok(re) => Some(re),
                Err(_) => {
                    log::error!(
                        "Warning: Failed to create regex for environment variable replacement"
                    );
                    None
                }
            },
        }
    }

    pub fn process_and_dedup_string<'a>(
        &self,
        iter: impl Iterator<Item = &'a String>,
    ) -> Vec<String> {
        let mut seen = HashSet::new();
        iter.map(|root| self.pre_process_path(root))
            .filter(|path| seen.insert(path.clone()))
            .collect()
    }

    /// library / packages
    pub fn process_and_dedup_workspace_path_items<'a>(
        &mut self,
        iter: impl Iterator<Item = &'a EmmyrcWorkspacePathItem>,
    ) -> Vec<EmmyrcWorkspacePathItem> {
        let mut seen = HashSet::new();
        iter.map(|root| self.pre_process_workspace_path_item(root))
            .filter(|path| seen.insert(path.clone()))
            .collect()
    }

    fn pre_process_path(&self, path: &str) -> String {
        let path = self.replace_env_var(path);
        // ${workspaceFolder}  == {workspaceFolder}
        let mut path = path.replace("$", ""); // ideally, this should be `Cow`
        let workspace_str = match self.workspace.to_str() {
            Some(path) => path,
            None => {
                log::error!("Warning: workspace path is not valid UTF-8");
                return path;
            }
        };

        path = self.replace_placeholders(&path, workspace_str);

        if let Some(suffix) = path.strip_prefix("~/") {
            let home_dir = match dirs::home_dir() {
                Some(h) => h,
                None => {
                    log::error!("Warning: Home directory not found");
                    return path;
                }
            };
            path = home_dir.join(suffix).to_string_lossy().to_string();
        } else if let Some(suffix) = path.strip_prefix("./") {
            path = self.workspace.join(suffix).to_string_lossy().to_string();
        } else if !PathBuf::from(&path).is_absolute() {
            path = self.workspace.join(&path).to_string_lossy().to_string();
        }

        path
    }

    fn pre_process_workspace_path_item(
        &mut self,
        item: &EmmyrcWorkspacePathItem,
    ) -> EmmyrcWorkspacePathItem {
        match item {
            EmmyrcWorkspacePathItem::Path(p) => {
                let processed_path = self.pre_process_path(p);
                EmmyrcWorkspacePathItem::Path(processed_path)
            }
            EmmyrcWorkspacePathItem::Config(config) => {
                let processed_path = self.pre_process_path(&config.path);
                let old_workspace = self.workspace.clone();
                self.workspace = PathBuf::from(&processed_path);
                let processed_ignore_dir = config
                    .ignore_dir
                    .iter()
                    .map(|d| self.pre_process_path(d))
                    .collect();
                self.workspace = old_workspace;
                let processed_ignore_globs = config.ignore_globs.clone();

                EmmyrcWorkspacePathItem::Config(EmmyrcWorkspacePathConfig {
                    path: processed_path,
                    ignore_dir: processed_ignore_dir,
                    ignore_globs: processed_ignore_globs,
                })
            }
        }
    }

    // compact luals
    fn replace_env_var<'a>(&self, path: &'a str) -> Cow<'a, str> {
        let re = match &self.env_var_regex {
            Some(re) => re,
            None => return Cow::Borrowed(path),
        };
        re.replace_all(path, |caps: &regex::Captures| {
            let key = &caps[1];
            std::env::var(key).unwrap_or_else(|_| {
                log::error!("Warning: Environment variable {} is not set", key);
                String::new()
            })
        })
    }

    fn replace_placeholders(&self, input: &str, workspace_folder: &str) -> String {
        let re = match &self.placeholder_regex {
            Some(re) => re,
            None => return input.to_string(),
        };
        re.replace_all(input, |caps: &regex::Captures| {
            let key = &caps[1];
            if key == "workspaceFolder" {
                workspace_folder.to_string()
            } else if let Some(env_name) = key.strip_prefix("env:") {
                std::env::var(env_name).unwrap_or_default()
            } else if key == "luarocks" {
                self.luarocks_deploy_dir.clone()
            } else {
                caps[0].to_string()
            }
        })
        .to_string()
    }
}

fn get_luarocks_deploy_dir() -> String {
    Command::new("luarocks")
        .args(["config", "deploy_lua_dir"])
        .output()
        .ok()
        .and_then(|output| {
            if output.status.success() {
                Some(String::from_utf8_lossy(&output.stdout).trim().to_string())
            } else {
                None
            }
        })
        .unwrap_or_default()
}