litnik 0.1.0

A Rust-native, libtest-mimic integrated runner for LLVM/MLIR-style lit tests.
Documentation
use std::collections::HashMap;
use std::path::{Path, PathBuf};

#[derive(Clone, Debug)]
pub struct ShellEnv {
    pub cwd: PathBuf,
    pub env: HashMap<String, String>,
    pub dir_stack: Vec<PathBuf>,
    pub umask: Option<u32>,
    pub normalize_slashes: bool,
}

impl ShellEnv {
    pub fn new(cwd: PathBuf, env: HashMap<String, String>, normalize_slashes: bool) -> Self {
        Self {
            cwd,
            env,
            dir_stack: Vec::new(),
            umask: None,
            normalize_slashes,
        }
    }

    pub fn pushd(&mut self, path: &str) -> Result<(), String> {
        let next = self.resolve_path(path);
        if !next.is_dir() {
            return Err(format!("cd: {}: No such file or directory", path));
        }
        self.dir_stack.push(self.cwd.clone());
        self.cwd = next;
        Ok(())
    }

    pub fn popd(&mut self) -> Option<PathBuf> {
        let next = self.dir_stack.pop()?;
        self.cwd = next.clone();
        Some(next)
    }

    pub fn change_dir(&mut self, path: &str) {
        self.cwd = self.resolve_path(path);
    }

    pub fn resolve_path(&self, value: &str) -> PathBuf {
        let p = PathBuf::from(value);
        if p.is_absolute() {
            p
        } else {
            self.cwd.join(p)
        }
    }

    pub fn with_env_for_process(&self) -> HashMap<String, String> {
        self.env.clone()
    }
}

pub fn expand_glob(pattern: &str, cwd: &Path) -> Vec<String> {
    let normalized = if pattern.contains('*') || pattern.contains('?') {
        pattern
    } else {
        return vec![pattern.to_string()];
    };

    let path = if Path::new(normalized).is_absolute() {
        PathBuf::from(normalized)
    } else {
        cwd.join(normalized)
    };

    let Some(parent) = path.parent() else {
        return vec![pattern.to_string()];
    };
    let Some(file_pat) = path.file_name().and_then(|name| name.to_str()) else {
        return vec![pattern.to_string()];
    };

    let mut expanded = Vec::new();
    let read = match std::fs::read_dir(parent) {
        Ok(entries) => entries,
        Err(_) => return vec![pattern.to_string()],
    };
    for entry in read.flatten() {
        let name = entry.file_name();
        let Some(name) = name.to_str() else {
            continue;
        };
        if glob_match(file_pat, name) {
            expanded.push(entry.path().to_string_lossy().to_string());
        }
    }

    if expanded.is_empty() {
        vec![pattern.to_string()]
    } else {
        expanded
    }
}

fn glob_match(pattern: &str, value: &str) -> bool {
    glob_match_like(pattern, value)
}

fn glob_match_like(pattern: &str, value: &str) -> bool {
    let pat: Vec<char> = pattern.chars().collect();
    let txt: Vec<char> = value.chars().collect();

    let mut pi = 0usize;
    let mut vi = 0usize;
    let mut star_idx: Option<(usize, usize)> = None;

    while vi < txt.len() {
        if pi < pat.len() && (pat[pi] == '?' || pat[pi] == txt[vi]) {
            vi += 1;
            pi += 1;
            continue;
        }

        if pi < pat.len() && pat[pi] == '*' {
            star_idx = Some((pi, vi));
            pi += 1;
            continue;
        }

        if let Some((si, sv)) = star_idx {
            pi = si + 1;
            vi = sv + 1;
            continue;
        }

        return false;
    }

    while pi < pat.len() && pat[pi] == '*' {
        pi += 1;
    }

    pi == pat.len()
}

#[cfg(test)]
mod tests {
    use super::glob_match_like;

    #[test]
    fn glob_match_smoke() {
        assert!(glob_match_like("*.txt", "a.txt"));
        assert!(glob_match_like("a?c", "abc"));
        assert!(!glob_match_like("a?c", "ac"));
    }
}