90 lines
3.3 KiB
Rust
90 lines
3.3 KiB
Rust
use std::{
|
|
env,
|
|
io::{stdin, stdout, Write},
|
|
path::Path,
|
|
process::{Child, Command, Stdio},
|
|
};
|
|
const VERSION: &str = env!("CARGO_PKG_VERSION");
|
|
fn main() {
|
|
loop {
|
|
// use the `>` character as the prompt
|
|
// need to explicitly flush this to ensure it prints before read_line
|
|
|
|
print!("{} ~> ", std::env::current_dir().unwrap().display());
|
|
stdout().flush().unwrap();
|
|
|
|
let mut input = String::new();
|
|
stdin().read_line(&mut input).unwrap();
|
|
|
|
// read_line leaves a trailing newline, which trim removes
|
|
// this needs to be peekable so we can determine when we are on the last command
|
|
let mut commands = input.trim().split(" | ").peekable();
|
|
let mut previous_command = None;
|
|
|
|
while let Some(command) = commands.next() {
|
|
if command.is_empty() {
|
|
continue;
|
|
}
|
|
|
|
// everything after the first whitespace character is interpreted as args to the command
|
|
let mut parts = command.trim().split_whitespace();
|
|
let command = parts.next().unwrap();
|
|
let args = parts;
|
|
|
|
match command {
|
|
"cd" => {
|
|
// default to '/' as new directory if one was not provided
|
|
let new_dir = args.peekable().peek().map_or("/", |x| *x);
|
|
let root = Path::new(new_dir);
|
|
if let Err(e) = env::set_current_dir(&root) {
|
|
eprintln!("{}", e);
|
|
}
|
|
|
|
previous_command = None;
|
|
}
|
|
"version" => println!("Rash version: {}", VERSION),
|
|
"help" => println!("Able Shell help utility"),
|
|
"exit" => return,
|
|
command => {
|
|
let stdin = previous_command.map_or(Stdio::inherit(), |output: Child| {
|
|
Stdio::from(output.stdout.unwrap())
|
|
});
|
|
|
|
let stdout = if commands.peek().is_some() {
|
|
// there is another command piped behind this one
|
|
// prepare to send output to the next command
|
|
Stdio::piped()
|
|
} else {
|
|
// there are no more commands piped behind this one
|
|
// send output to shell stdout
|
|
Stdio::inherit()
|
|
};
|
|
|
|
let output = Command::new(command)
|
|
.args(args)
|
|
.stdin(stdin)
|
|
.stdout(stdout)
|
|
.spawn();
|
|
|
|
match output {
|
|
Ok(output) => {
|
|
previous_command = Some(output);
|
|
}
|
|
Err(e) => {
|
|
previous_command = None;
|
|
if e.to_string() == "No such file or directory (os error 2)" {
|
|
eprintln!("{} not found", command);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Some(mut final_command) = previous_command {
|
|
// block until the final command has finished
|
|
final_command.wait().unwrap();
|
|
}
|
|
}
|
|
}
|