392 lines
9.7 KiB
Rust
392 lines
9.7 KiB
Rust
use std::{env, path::PathBuf};
|
|
|
|
use ariadne::Fmt;
|
|
use nix::{libc::STDOUT_FILENO, unistd::write};
|
|
use yansi::Color;
|
|
|
|
use crate::{
|
|
libsh::error::{ShErr, ShErrKind, ShResult, next_color},
|
|
parse::{NdRule, Node, execute::prepare_argv, lex::Span},
|
|
procio::borrow_fd,
|
|
state::{self, read_meta, write_meta},
|
|
};
|
|
|
|
enum StackIdx {
|
|
FromTop(usize),
|
|
FromBottom(usize),
|
|
}
|
|
|
|
fn print_dirs() -> ShResult<()> {
|
|
let current_dir = env::current_dir()?;
|
|
let dirs_iter = read_meta(|m| m.dirs().clone().into_iter());
|
|
let all_dirs = [current_dir]
|
|
.into_iter()
|
|
.chain(dirs_iter)
|
|
.map(|d| d.to_string_lossy().to_string())
|
|
.map(|d| {
|
|
let Ok(home) = env::var("HOME") else {
|
|
return d;
|
|
};
|
|
|
|
if d.starts_with(&home) {
|
|
let new = d.strip_prefix(&home).unwrap();
|
|
format!("~{new}")
|
|
} else {
|
|
d
|
|
}
|
|
})
|
|
.collect::<Vec<_>>()
|
|
.join(" ");
|
|
|
|
let stdout = borrow_fd(STDOUT_FILENO);
|
|
write(stdout, all_dirs.as_bytes())?;
|
|
write(stdout, b"\n")?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn change_directory(target: &PathBuf, blame: Span) -> ShResult<()> {
|
|
if !target.is_dir() {
|
|
return Err(
|
|
ShErr::at(ShErrKind::ExecFail, blame, format!("not a directory: '{}'", target.display().fg(next_color())))
|
|
);
|
|
}
|
|
|
|
if let Err(e) = state::change_dir(target) {
|
|
return Err(
|
|
ShErr::at(ShErrKind::ExecFail, blame, format!("Failed to change directory: '{}'", e.fg(Color::Red)))
|
|
);
|
|
}
|
|
let new_dir = env::current_dir().map_err(|e| {
|
|
ShErr::at(ShErrKind::ExecFail, blame, format!("Failed to get current directory: '{}'", e.fg(Color::Red)))
|
|
})?;
|
|
unsafe { env::set_var("PWD", new_dir) };
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_stack_idx(arg: &str, blame: Span, cmd: &str) -> ShResult<StackIdx> {
|
|
let (from_top, digits) = if let Some(rest) = arg.strip_prefix('+') {
|
|
(true, rest)
|
|
} else if let Some(rest) = arg.strip_prefix('-') {
|
|
(false, rest)
|
|
} else {
|
|
unreachable!()
|
|
};
|
|
|
|
if digits.is_empty() {
|
|
return Err(
|
|
ShErr::at(ShErrKind::ExecFail, blame, format!(
|
|
"{cmd}: missing index after '{}'",
|
|
if from_top { "+" } else { "-" }
|
|
))
|
|
);
|
|
}
|
|
|
|
for ch in digits.chars() {
|
|
if !ch.is_ascii_digit() {
|
|
return Err(
|
|
ShErr::at(ShErrKind::ExecFail, blame, format!("{cmd}: invalid argument: '{}'",arg.fg(next_color())))
|
|
);
|
|
}
|
|
}
|
|
|
|
let n = digits.parse::<usize>().map_err(|e| {
|
|
ShErr::at(ShErrKind::ExecFail, blame, format!("{cmd}: invalid index: '{}'",e.fg(next_color())))
|
|
})?;
|
|
|
|
if from_top {
|
|
Ok(StackIdx::FromTop(n))
|
|
} else {
|
|
Ok(StackIdx::FromBottom(n))
|
|
}
|
|
}
|
|
|
|
pub fn pushd(node: Node) -> ShResult<()> {
|
|
let blame = node.get_span().clone();
|
|
let NdRule::Command {
|
|
assignments: _,
|
|
argv,
|
|
} = node.class
|
|
else {
|
|
unreachable!()
|
|
};
|
|
|
|
let mut argv = prepare_argv(argv)?;
|
|
if !argv.is_empty() { argv.remove(0); }
|
|
|
|
let mut dir = None;
|
|
let mut rotate_idx = None;
|
|
let mut no_cd = false;
|
|
|
|
for (arg, _) in argv {
|
|
if arg.starts_with('+')
|
|
|| (arg.starts_with('-') && arg.len() > 1 && arg.as_bytes()[1].is_ascii_digit())
|
|
{
|
|
rotate_idx = Some(parse_stack_idx(&arg, blame.clone(), "pushd")?);
|
|
} else if arg == "-n" {
|
|
no_cd = true;
|
|
} else if arg.starts_with('-') {
|
|
return Err(
|
|
ShErr::at(ShErrKind::ExecFail, blame, format!("pushd: invalid option: '{}'", arg.fg(next_color())))
|
|
);
|
|
} else {
|
|
if dir.is_some() {
|
|
return Err(
|
|
ShErr::at(ShErrKind::ExecFail, blame, "pushd: too many arguments")
|
|
);
|
|
}
|
|
let target = PathBuf::from(&arg);
|
|
if !target.is_dir() {
|
|
return Err(
|
|
ShErr::at(ShErrKind::ExecFail, blame, format!("pushd: not a directory: '{}'", target.display().fg(next_color())))
|
|
);
|
|
}
|
|
dir = Some(target);
|
|
}
|
|
}
|
|
|
|
if let Some(idx) = rotate_idx {
|
|
let cwd = env::current_dir().unwrap_or_else(|_| PathBuf::from("/"));
|
|
let new_cwd = write_meta(|m| {
|
|
let dirs = m.dirs_mut();
|
|
dirs.push_front(cwd);
|
|
match idx {
|
|
StackIdx::FromTop(n) => dirs.rotate_left(n),
|
|
StackIdx::FromBottom(n) => dirs.rotate_right(n + 1),
|
|
}
|
|
dirs.pop_front()
|
|
});
|
|
|
|
if let Some(dir) = new_cwd
|
|
&& !no_cd
|
|
{
|
|
change_directory(&dir, blame)?;
|
|
print_dirs()?;
|
|
}
|
|
} else if let Some(dir) = dir {
|
|
let old_dir = env::current_dir()?;
|
|
if old_dir != dir {
|
|
write_meta(|m| m.push_dir(old_dir));
|
|
}
|
|
|
|
if no_cd {
|
|
state::set_status(0);
|
|
return Ok(());
|
|
}
|
|
|
|
change_directory(&dir, blame)?;
|
|
print_dirs()?;
|
|
}
|
|
|
|
state::set_status(0);
|
|
Ok(())
|
|
}
|
|
|
|
pub fn popd(node: Node) -> ShResult<()> {
|
|
let blame = node.get_span().clone();
|
|
let NdRule::Command {
|
|
assignments: _,
|
|
argv,
|
|
} = node.class
|
|
else {
|
|
unreachable!()
|
|
};
|
|
|
|
let mut argv = prepare_argv(argv)?;
|
|
if !argv.is_empty() { argv.remove(0); }
|
|
|
|
let mut remove_idx = None;
|
|
let mut no_cd = false;
|
|
|
|
for (arg, _) in argv {
|
|
if arg.starts_with('+')
|
|
|| (arg.starts_with('-') && arg.len() > 1 && arg.as_bytes()[1].is_ascii_digit())
|
|
{
|
|
remove_idx = Some(parse_stack_idx(&arg, blame.clone(), "popd")?);
|
|
} else if arg == "-n" {
|
|
no_cd = true;
|
|
} else if arg.starts_with('-') {
|
|
return Err(
|
|
ShErr::at(ShErrKind::ExecFail, blame, format!("popd: invalid option: '{}'", arg.fg(next_color())))
|
|
);
|
|
}
|
|
}
|
|
|
|
if let Some(idx) = remove_idx {
|
|
match idx {
|
|
StackIdx::FromTop(0) => {
|
|
// +0 is same as plain popd: pop top, cd to it
|
|
let dir = write_meta(|m| m.pop_dir());
|
|
if !no_cd {
|
|
if let Some(dir) = dir {
|
|
change_directory(&dir, blame.clone())?;
|
|
} else {
|
|
return Err(
|
|
ShErr::at(ShErrKind::ExecFail, blame, "popd: directory stack empty")
|
|
);
|
|
}
|
|
}
|
|
}
|
|
StackIdx::FromTop(n) => {
|
|
// +N (N>0): remove (N-1)th stored entry, no cd
|
|
write_meta(|m| {
|
|
let dirs = m.dirs_mut();
|
|
let idx = n - 1;
|
|
if idx >= dirs.len() {
|
|
return Err(
|
|
ShErr::at(ShErrKind::ExecFail, blame.clone(), format!("popd: directory index out of range: +{n}"))
|
|
);
|
|
}
|
|
dirs.remove(idx);
|
|
Ok(())
|
|
})?;
|
|
}
|
|
StackIdx::FromBottom(n) => {
|
|
write_meta(|m| -> ShResult<()> {
|
|
let dirs = m.dirs_mut();
|
|
let actual = dirs.len().checked_sub(n + 1).ok_or_else(|| {
|
|
ShErr::at(ShErrKind::ExecFail, blame.clone(), format!("popd: directory index out of range: -{n}"))
|
|
})?;
|
|
dirs.remove(actual);
|
|
Ok(())
|
|
})?;
|
|
}
|
|
}
|
|
print_dirs()?;
|
|
} else {
|
|
let dir = write_meta(|m| m.pop_dir());
|
|
|
|
if no_cd {
|
|
state::set_status(0);
|
|
return Ok(());
|
|
}
|
|
|
|
if let Some(dir) = dir {
|
|
change_directory(&dir, blame.clone())?;
|
|
print_dirs()?;
|
|
} else {
|
|
return Err(
|
|
ShErr::at(ShErrKind::ExecFail, blame, "popd: directory stack empty")
|
|
);
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn dirs(node: Node) -> ShResult<()> {
|
|
let blame = node.get_span().clone();
|
|
let NdRule::Command {
|
|
assignments: _,
|
|
argv,
|
|
} = node.class
|
|
else {
|
|
unreachable!()
|
|
};
|
|
|
|
let mut argv = prepare_argv(argv)?;
|
|
if !argv.is_empty() { argv.remove(0); }
|
|
|
|
let mut abbreviate_home = true;
|
|
let mut one_per_line = false;
|
|
let mut one_per_line_indexed = false;
|
|
let mut clear_stack = false;
|
|
let mut target_idx: Option<StackIdx> = None;
|
|
|
|
for (arg, _) in argv {
|
|
match arg.as_str() {
|
|
"-p" => one_per_line = true,
|
|
"-v" => one_per_line_indexed = true,
|
|
"-c" => clear_stack = true,
|
|
"-l" => abbreviate_home = false,
|
|
_ if (arg.starts_with('+') || arg.starts_with('-'))
|
|
&& arg.len() > 1
|
|
&& arg.as_bytes()[1].is_ascii_digit() =>
|
|
{
|
|
target_idx = Some(parse_stack_idx(&arg, blame.clone(), "dirs")?);
|
|
}
|
|
_ if arg.starts_with('-') => {
|
|
return Err(
|
|
ShErr::at(ShErrKind::ExecFail, blame, format!("dirs: invalid option: '{}'", arg.fg(next_color())))
|
|
);
|
|
}
|
|
_ => {
|
|
return Err(
|
|
ShErr::at(ShErrKind::ExecFail, blame, format!("dirs: unexpected argument: '{}'", arg.fg(next_color())))
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
if clear_stack {
|
|
write_meta(|m| m.dirs_mut().clear());
|
|
return Ok(());
|
|
}
|
|
|
|
let mut dirs: Vec<String> = read_meta(|m| {
|
|
let current_dir = env::current_dir().unwrap_or_else(|_| PathBuf::from("/"));
|
|
let stack = [current_dir]
|
|
.into_iter()
|
|
.chain(m.dirs().clone())
|
|
.map(|d| d.to_string_lossy().to_string());
|
|
|
|
if abbreviate_home {
|
|
let Ok(home) = env::var("HOME") else {
|
|
return stack.collect();
|
|
};
|
|
stack
|
|
.map(|d| {
|
|
if d.starts_with(&home) {
|
|
let new = d.strip_prefix(&home).unwrap();
|
|
format!("~{new}")
|
|
} else {
|
|
d
|
|
}
|
|
})
|
|
.collect()
|
|
} else {
|
|
stack.collect()
|
|
}
|
|
});
|
|
|
|
if let Some(idx) = target_idx {
|
|
let target = match idx {
|
|
StackIdx::FromTop(n) => dirs.get(n),
|
|
StackIdx::FromBottom(n) => dirs.get(dirs.len().saturating_sub(n + 1)),
|
|
};
|
|
|
|
if let Some(dir) = target {
|
|
dirs = vec![dir.clone()];
|
|
} else {
|
|
return Err(
|
|
ShErr::at(ShErrKind::ExecFail, blame, format!(
|
|
"dirs: directory index out of range: {}",
|
|
match idx {
|
|
StackIdx::FromTop(n) => format!("+{n}"),
|
|
StackIdx::FromBottom(n) => format!("-{n}"),
|
|
}
|
|
))
|
|
);
|
|
}
|
|
}
|
|
|
|
let mut output = String::new();
|
|
|
|
if one_per_line {
|
|
output = dirs.join("\n");
|
|
} else if one_per_line_indexed {
|
|
for (i, dir) in dirs.iter_mut().enumerate() {
|
|
*dir = format!("{i}\t{dir}");
|
|
}
|
|
output = dirs.join("\n");
|
|
output.push('\n');
|
|
} else {
|
|
print_dirs()?;
|
|
}
|
|
|
|
let stdout = borrow_fd(STDOUT_FILENO);
|
|
write(stdout, output.as_bytes())?;
|
|
|
|
Ok(())
|
|
}
|