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"));
}
}